#pragma once

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

// Package: Kosmos

#include "Basic.hpp"

#include "Kosmos_classes.hpp"
#include "Kosmos_parameters.hpp"


namespace SDK
{

// Function Kosmos.AbilityTask_ApplyRootMotionSpecialForce.ApplyRootMotionSpecialForce
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation_0                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration_0                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSetNewMovementMode_0                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementMode                           MovementMode                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRestrictSpeedToExpected_0                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCurveFloat*                      MovementDistributionCurve_0                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ERootMotionFinishVelocityMode           VelocityOnFinishMode                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SetVelocityOnFinish                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ClampVelocityOnFinish                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_ApplyRootMotionSpecialForce*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_ApplyRootMotionSpecialForce* UAbilityTask_ApplyRootMotionSpecialForce::ApplyRootMotionSpecialForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& TargetLocation_0, float Duration_0, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveFloat* MovementDistributionCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionSpecialForce", "ApplyRootMotionSpecialForce");

	Params::AbilityTask_ApplyRootMotionSpecialForce_ApplyRootMotionSpecialForce Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.TargetLocation_0 = std::move(TargetLocation_0);
	Parms.Duration_0 = Duration_0;
	Parms.bSetNewMovementMode_0 = bSetNewMovementMode_0;
	Parms.MovementMode = MovementMode;
	Parms.bRestrictSpeedToExpected_0 = bRestrictSpeedToExpected_0;
	Parms.MovementDistributionCurve_0 = MovementDistributionCurve_0;
	Parms.VelocityOnFinishMode = VelocityOnFinishMode;
	Parms.SetVelocityOnFinish = std::move(SetVelocityOnFinish);
	Parms.ClampVelocityOnFinish = ClampVelocityOnFinish;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEntitlementManager.DebugDisableAllEntitlement
// (Native, Public, BlueprintCallable)

void UKosmosEntitlementManager::DebugDisableAllEntitlement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementManager", "DebugDisableAllEntitlement");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEntitlementManager.DebugDisableEntitlement
// (Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosEntitlementDataAsset*      InAsset                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosEntitlementManager::DebugDisableEntitlement(class UKosmosEntitlementDataAsset* InAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementManager", "DebugDisableEntitlement");

	Params::KosmosEntitlementManager_DebugDisableEntitlement Parms{};

	Parms.InAsset = InAsset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEntitlementManager.DebugEnableAllEntitlement
// (Native, Public, BlueprintCallable)

void UKosmosEntitlementManager::DebugEnableAllEntitlement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementManager", "DebugEnableAllEntitlement");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEntitlementManager.DebugEnableEntitlement
// (Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosEntitlementDataAsset*      InAsset                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosEntitlementManager::DebugEnableEntitlement(class UKosmosEntitlementDataAsset* InAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementManager", "DebugEnableEntitlement");

	Params::KosmosEntitlementManager_DebugEnableEntitlement Parms{};

	Parms.InAsset = InAsset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEntitlementManager.IsEntitlementEnabled
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosEntitlementDataAsset*      InAsset                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosEntitlementManager::IsEntitlementEnabled(class UKosmosEntitlementDataAsset* InAsset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementManager", "IsEntitlementEnabled");

	Params::KosmosEntitlementManager_IsEntitlementEnabled Parms{};

	Parms.InAsset = InAsset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AnimationControlComponent.CopyLocomotionToDefault
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::CopyLocomotionToDefault(class FName Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "CopyLocomotionToDefault");

	Params::AnimationControlComponent_CopyLocomotionToDefault Parms{};

	Parms.Name_0 = Name_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.IsPlayingAnimationState
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FSoftEnumName&             Name_0                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimationControlComponent::IsPlayingAnimationState(const struct FSoftEnumName& Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "IsPlayingAnimationState");

	Params::AnimationControlComponent_IsPlayingAnimationState Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AnimationControlComponent.OnAnimationStateFinished
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UAnimationControlComponent::OnAnimationStateFinished(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "OnAnimationStateFinished");

	Params::AnimationControlComponent_OnAnimationStateFinished Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.OnAnimationStateStarted
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UAnimationControlComponent::OnAnimationStateStarted(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "OnAnimationStateStarted");

	Params::AnimationControlComponent_OnAnimationStateStarted Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.PlayActionAnimation
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnFinished                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnInterrupted                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayActionAnimation(class FName Name_0, const TDelegate<void(class FName Name)>& OnFinished, const TDelegate<void(class FName Name)>& OnInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayActionAnimation");

	Params::AnimationControlComponent_PlayActionAnimation Parms{};

	Parms.Name_0 = Name_0;
	Parms.OnFinished = OnFinished;
	Parms.OnInterrupted = OnInterrupted;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.PlayAnimationAndWait
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// float*                                  DeltaTime                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimationAsset*                  Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCharacterAnimStateTransitions&Transitions                                            (Parm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// EAnimationLayering                      Layering                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Additive                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Loop                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementRestriction                    RootMotionMode                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
// ELatentPlayAnimationResult*             animResult                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayAnimationAndWait(float* DeltaTime, class UAnimationAsset* Animation, const struct FCharacterAnimStateTransitions& Transitions, EAnimationLayering Layering, bool Additive, bool Loop, EMovementRestriction RootMotionMode, const struct FLatentActionInfo& LatentInfo, ELatentPlayAnimationResult* animResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayAnimationAndWait");

	Params::AnimationControlComponent_PlayAnimationAndWait Parms{};

	Parms.Animation = Animation;
	Parms.Transitions = std::move(Transitions);
	Parms.Layering = Layering;
	Parms.Additive = Additive;
	Parms.Loop = Loop;
	Parms.RootMotionMode = RootMotionMode;
	Parms.LatentInfo = std::move(LatentInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.AnimationControlComponent.PlayAnimationOverrideState
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*                AnimationToPlay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnFinished                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnInterrupted                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// EMovementRestriction                    movementRestriction                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Looping                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCharacterAnimStateTransitions&Transitions                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayAnimationOverrideState(class UAnimSequenceBase* AnimationToPlay, const TDelegate<void(class FName Name)>& OnFinished, const TDelegate<void(class FName Name)>& OnInterrupted, EMovementRestriction movementRestriction, bool Looping, const struct FCharacterAnimStateTransitions& Transitions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayAnimationOverrideState");

	Params::AnimationControlComponent_PlayAnimationOverrideState Parms{};

	Parms.AnimationToPlay = AnimationToPlay;
	Parms.OnFinished = OnFinished;
	Parms.OnInterrupted = OnInterrupted;
	Parms.movementRestriction = movementRestriction;
	Parms.Looping = Looping;
	Parms.Transitions = std::move(Transitions);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.PlayAnimationState
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FSoftEnumName&             Name_0                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnFinished                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnInterrupted                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FPlayAnimStateOptions&     playOptions                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayAnimationState(const struct FSoftEnumName& Name_0, const TDelegate<void(class FName Name)>& OnFinished, const TDelegate<void(class FName Name)>& OnInterrupted, const struct FPlayAnimStateOptions& playOptions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayAnimationState");

	Params::AnimationControlComponent_PlayAnimationState Parms{};

	Parms.Name_0 = std::move(Name_0);
	Parms.OnFinished = OnFinished;
	Parms.OnInterrupted = OnInterrupted;
	Parms.playOptions = std::move(playOptions);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.PlayAnimationStateAndWait
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// float*                                  DeltaTime                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSoftEnumName&             StateName                                              (Parm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// ELatentPlayAnimationResult*             animResult                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayAnimationStateAndWait(float* DeltaTime, const struct FSoftEnumName& StateName, const struct FLatentActionInfo& LatentInfo, ELatentPlayAnimationResult* animResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayAnimationStateAndWait");

	Params::AnimationControlComponent_PlayAnimationStateAndWait Parms{};

	Parms.StateName = std::move(StateName);
	Parms.LatentInfo = std::move(LatentInfo);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.AnimationControlComponent.PlayBlendSpaceOverrideState
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UBlendSpaceBase*                  blendSpaceToPlay                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnFinished                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const TDelegate<void(class FName Name)>&OnInterrupted                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// EMovementRestriction                    movementRestriction                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Looping                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCharacterAnimStateTransitions&Transitions                                            (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UAnimationControlComponent::PlayBlendSpaceOverrideState(class UBlendSpaceBase* blendSpaceToPlay, const TDelegate<void(class FName Name)>& OnFinished, const TDelegate<void(class FName Name)>& OnInterrupted, EMovementRestriction movementRestriction, bool Looping, const struct FCharacterAnimStateTransitions& Transitions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "PlayBlendSpaceOverrideState");

	Params::AnimationControlComponent_PlayBlendSpaceOverrideState Parms{};

	Parms.blendSpaceToPlay = blendSpaceToPlay;
	Parms.OnFinished = OnFinished;
	Parms.OnInterrupted = OnInterrupted;
	Parms.movementRestriction = movementRestriction;
	Parms.Looping = Looping;
	Parms.Transitions = std::move(Transitions);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetAnimationForState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             StateName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                Animation                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetAnimationForState(class FName StateName, class UAnimSequenceBase* Animation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetAnimationForState");

	Params::AnimationControlComponent_SetAnimationForState Parms{};

	Parms.StateName = StateName;
	Parms.Animation = Animation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetAnimationStateBlendspaceInput
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  BlendspaceInput                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetAnimationStateBlendspaceInput(const struct FRotator& BlendspaceInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetAnimationStateBlendspaceInput");

	Params::AnimationControlComponent_SetAnimationStateBlendspaceInput Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetAnimationStateDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetAnimationStateDirection(const struct FVector& Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetAnimationStateDirection");

	Params::AnimationControlComponent_SetAnimationStateDirection Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetBlendSpaceForState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             StateName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBlendSpaceBase*                  BlendSpace                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetBlendSpaceForState(class FName StateName, class UBlendSpaceBase* BlendSpace)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetBlendSpaceForState");

	Params::AnimationControlComponent_SetBlendSpaceForState Parms{};

	Parms.StateName = StateName;
	Parms.BlendSpace = BlendSpace;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetBlendSpaceInputForState
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class FName                             StateName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 Input                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetBlendSpaceInputForState(class FName StateName, const struct FVector2D& Input)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetBlendSpaceInputForState");

	Params::AnimationControlComponent_SetBlendSpaceInputForState Parms{};

	Parms.StateName = StateName;
	Parms.Input = std::move(Input);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.SetLocomotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Run                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::SetLocomotion(class FName Name_0, bool Run)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "SetLocomotion");

	Params::AnimationControlComponent_SetLocomotion Parms{};

	Parms.Name_0 = Name_0;
	Parms.Run = Run;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.StopActionAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::StopActionAnimation(class FName Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "StopActionAnimation");

	Params::AnimationControlComponent_StopActionAnimation Parms{};

	Parms.Name_0 = Name_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.StopAnimationOverrideState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    skipExitAnimation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::StopAnimationOverrideState(bool skipExitAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "StopAnimationOverrideState");

	Params::AnimationControlComponent_StopAnimationOverrideState Parms{};

	Parms.skipExitAnimation = skipExitAnimation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.StopAnimationState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FSoftEnumName&             Name_0                                                 (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    skipExitAnimation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::StopAnimationState(const struct FSoftEnumName& Name_0, bool skipExitAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "StopAnimationState");

	Params::AnimationControlComponent_StopAnimationState Parms{};

	Parms.Name_0 = std::move(Name_0);
	Parms.skipExitAnimation = skipExitAnimation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationControlComponent.UnsetLocomotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Run                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationControlComponent::UnsetLocomotion(class FName Name_0, bool Run)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "UnsetLocomotion");

	Params::AnimationControlComponent_UnsetLocomotion Parms{};

	Parms.Name_0 = Name_0;
	Parms.Run = Run;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

bool UAnimationControlComponent::IsPlayingOverrideAnimation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationControlComponent", "IsPlayingOverrideAnimation");

	Params::AnimationControlComponent_IsPlayingOverrideAnimation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointBlueprintLibrary.GetCheckpointReaderForSoftActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContextObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AActor>            InActor                                                (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosPersistence                      InPersistence                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosCheckpointReader*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosCheckpointReader* UKosmosCheckpointBlueprintLibrary::GetCheckpointReaderForSoftActor(class UObject* InWorldContextObject, TSoftObjectPtr<class AActor> InActor, EKosmosPersistence InPersistence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCheckpointBlueprintLibrary", "GetCheckpointReaderForSoftActor");

	Params::KosmosCheckpointBlueprintLibrary_GetCheckpointReaderForSoftActor Parms{};

	Parms.InWorldContextObject = InWorldContextObject;
	Parms.InActor = InActor;
	Parms.InPersistence = InPersistence;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointBlueprintLibrary.GetCheckpointWriterForSoftActor
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          InWorldContextObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AActor>            InActor                                                (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosPersistence                      InPersistence                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosCheckpointWriter*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosCheckpointWriter* UKosmosCheckpointBlueprintLibrary::GetCheckpointWriterForSoftActor(class UObject* InWorldContextObject, TSoftObjectPtr<class AActor> InActor, EKosmosPersistence InPersistence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCheckpointBlueprintLibrary", "GetCheckpointWriterForSoftActor");

	Params::KosmosCheckpointBlueprintLibrary_GetCheckpointWriterForSoftActor Parms{};

	Parms.InWorldContextObject = InWorldContextObject;
	Parms.InActor = InActor;
	Parms.InPersistence = InPersistence;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_ApplyRootMotionVariableForce.ApplyRootMotionVariableForce
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   WorldDirection_0                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Strength_0                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration_0                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EEasingFunc                             EaseFunc_0                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReverseEase_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnableGravity_0                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_ApplyRootMotionVariableForce*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_ApplyRootMotionVariableForce* UAbilityTask_ApplyRootMotionVariableForce::ApplyRootMotionVariableForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& WorldDirection_0, float Strength_0, float Duration_0, EEasingFunc EaseFunc_0, bool bReverseEase_0, bool bEnableGravity_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_ApplyRootMotionVariableForce", "ApplyRootMotionVariableForce");

	Params::AbilityTask_ApplyRootMotionVariableForce_ApplyRootMotionVariableForce Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.WorldDirection_0 = std::move(WorldDirection_0);
	Parms.Strength_0 = Strength_0;
	Parms.Duration_0 = Duration_0;
	Parms.EaseFunc_0 = EaseFunc_0;
	Parms.bReverseEase_0 = bReverseEase_0;
	Parms.bEnableGravity_0 = bEnableGravity_0;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayAnimationDelegateProxy.AnimationFinished
// (Final, Native, Private)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayAnimationDelegateProxy::AnimationFinished(class FName Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayAnimationDelegateProxy", "AnimationFinished");

	Params::PlayAnimationDelegateProxy_AnimationFinished Parms{};

	Parms.Name_0 = Name_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayAnimationDelegateProxy.AnimationInterrupted
// (Final, Native, Private)
// Parameters:
// class FName                             Name_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayAnimationDelegateProxy::AnimationInterrupted(class FName Name_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayAnimationDelegateProxy", "AnimationInterrupted");

	Params::PlayAnimationDelegateProxy_AnimationInterrupted Parms{};

	Parms.Name_0 = Name_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayAnimationDelegateProxy.OnWorldReloaded
// (Final, Native, Private)
// Parameters:
// class UWorld*                           World                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayAnimationDelegateProxy::OnWorldReloaded(class UWorld* World)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayAnimationDelegateProxy", "OnWorldReloaded");

	Params::PlayAnimationDelegateProxy_OnWorldReloaded Parms{};

	Parms.World = World;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.ClearSubscribeOnGrabEnd
// (Final, Native, Public, BlueprintCallable)

void UKosmosBaseGrabberInterface::ClearSubscribeOnGrabEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "ClearSubscribeOnGrabEnd");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.ClearSubscribeOnGrabStart
// (Final, Native, Public, BlueprintCallable)

void UKosmosBaseGrabberInterface::ClearSubscribeOnGrabStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "ClearSubscribeOnGrabStart");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.OnGrabChanged
// (Final, Native, Public)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBaseGrabberInterface::OnGrabChanged(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "OnGrabChanged");

	Params::KosmosBaseGrabberInterface_OnGrabChanged Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.OnWantsRegrabChanged
// (Final, Native, Public)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBaseGrabberInterface::OnWantsRegrabChanged(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "OnWantsRegrabChanged");

	Params::KosmosBaseGrabberInterface_OnWantsRegrabChanged Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.ReleaseGrab
// (Native, Public, BlueprintCallable)
// Parameters:
// EGrabReleaseOptions                     releaseOption                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBaseGrabberInterface::ReleaseGrab(EGrabReleaseOptions releaseOption)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "ReleaseGrab");

	Params::KosmosBaseGrabberInterface_ReleaseGrab Parms{};

	Parms.releaseOption = releaseOption;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.SubscribeOnGrabEnd
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void(class ACharacter* Character)>eventGrabEnd                                           (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosBaseGrabberInterface::SubscribeOnGrabEnd(TDelegate<void(class ACharacter* Character)> eventGrabEnd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "SubscribeOnGrabEnd");

	Params::KosmosBaseGrabberInterface_SubscribeOnGrabEnd Parms{};

	Parms.eventGrabEnd = eventGrabEnd;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.SubscribeOnGrabStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TDelegate<void(class ACharacter* Character)>eventGrabStart                                         (Parm, ZeroConstructor, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosBaseGrabberInterface::SubscribeOnGrabStart(TDelegate<void(class ACharacter* Character)> eventGrabStart)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "SubscribeOnGrabStart");

	Params::KosmosBaseGrabberInterface_SubscribeOnGrabStart Parms{};

	Parms.eventGrabStart = eventGrabStart;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.UpdateGrabberState
// (Final, Native, Public)

void UKosmosBaseGrabberInterface::UpdateGrabberState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "UpdateGrabberState");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseGrabberInterface.GetGrabbingState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGrabbingStates                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EGrabbingStates UKosmosBaseGrabberInterface::GetGrabbingState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabberInterface", "GetGrabbingState");

	Params::KosmosBaseGrabberInterface_GetGrabbingState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_Approach.Approach
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetDirection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeOutDuration                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          InNotifyObject                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_Approach*            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_Approach* UAbilityTask_Approach::Approach(class UGameplayAbility* OwningAbility, const struct FVector& TargetLocation, const struct FVector& TargetDirection, float TimeOutDuration, class UObject* InNotifyObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_Approach", "Approach");

	Params::AbilityTask_Approach_Approach Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetDirection = std::move(TargetDirection);
	Parms.TimeOutDuration = TimeOutDuration;
	Parms.InNotifyObject = InNotifyObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AnimationOverrideBlueprintLibrary.ClearOverride
// (Final, Native, Static, Public, HasOutParams)
// Parameters:
// struct FAnimationOverrideHandle&        Handle                                                 (Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UAnimationOverrideBlueprintLibrary::ClearOverride(struct FAnimationOverrideHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimationOverrideBlueprintLibrary", "ClearOverride");

	Params::AnimationOverrideBlueprintLibrary_ClearOverride Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	Handle = std::move(Parms.Handle);
}


// Function Kosmos.AnimationOverrideBlueprintLibrary.IsValid
// (Final, Native, Static, Public, HasOutParams)
// Parameters:
// const struct FAnimationOverrideHandle&  Handle                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAnimationOverrideBlueprintLibrary::IsValid(const struct FAnimationOverrideHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AnimationOverrideBlueprintLibrary", "IsValid");

	Params::AnimationOverrideBlueprintLibrary_IsValid Parms{};

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

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.AttachCarriable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InAttachableParent                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  InAttachmentComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::AttachCarriable(class AActor* InAttachableParent, class USceneComponent* InAttachmentComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "AttachCarriable");

	Params::KosmosCarriable_AttachCarriable Parms{};

	Parms.InAttachableParent = InAttachableParent;
	Parms.InAttachmentComponent = InAttachmentComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.CanBePickedUpPutdown
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::CanBePickedUpPutdown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "CanBePickedUpPutdown");

	Params::KosmosCarriable_CanBePickedUpPutdown Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.CanGrab
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::CanGrab(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "CanGrab");

	Params::KosmosCarriable_CanGrab Parms{};

	Parms.Character = Character;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.DetachCarriable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIsEjected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::DetachCarriable(bool bIsEjected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "DetachCarriable");

	Params::KosmosCarriable_DetachCarriable Parms{};

	Parms.bIsEjected = bIsEjected;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.GetCanPickup
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::GetCanPickup()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetCanPickup");

	Params::KosmosCarriable_GetCanPickup Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.GetClosestLocationInfo
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outForward                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::GetClosestLocationInfo(const struct FVector& TargetLocation, struct FVector* OutLocation, struct FVector* outForward)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetClosestLocationInfo");

	Params::KosmosCarriable_GetClosestLocationInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

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

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.GetPickupInfo
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const bool                              bIsAlone                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosCarriableInteractData     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FKosmosCarriableInteractData AKosmosCarriable::GetPickupInfo(const bool bIsAlone)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetPickupInfo");

	Params::KosmosCarriable_GetPickupInfo Parms{};

	Parms.bIsAlone = bIsAlone;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.GetPutdownInfo
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const bool                              bIsAlone                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosCarriableInteractData     ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FKosmosCarriableInteractData AKosmosCarriable::GetPutdownInfo(const bool bIsAlone)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetPutdownInfo");

	Params::KosmosCarriable_GetPutdownInfo Parms{};

	Parms.bIsAlone = bIsAlone;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.HandleKosmosRoomLoaded
// (Final, Native, Private)

void AKosmosCarriable::HandleKosmosRoomLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "HandleKosmosRoomLoaded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.HandleKosmosRoomUnloaded
// (Final, Native, Private)

void AKosmosCarriable::HandleKosmosRoomUnloaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "HandleKosmosRoomUnloaded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.HandleResume
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "HandleResume");

	Params::KosmosCarriable_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.HandleSnapshot
// (Final, Native, Private)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "HandleSnapshot");

	Params::KosmosCarriable_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.IsInHandStateSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsInHandStateSet(int32 Bitmask)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsInHandStateSet");

	Params::KosmosCarriable_IsInHandStateSet Parms{};

	Parms.Bitmask = Bitmask;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.IsOnGroundStateSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsOnGroundStateSet(int32 Bitmask)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsOnGroundStateSet");

	Params::KosmosCarriable_IsOnGroundStateSet Parms{};

	Parms.Bitmask = Bitmask;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.IsOtherStateSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsOtherStateSet(int32 Bitmask)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsOtherStateSet");

	Params::KosmosCarriable_IsOtherStateSet Parms{};

	Parms.Bitmask = Bitmask;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.IsWithinHorizontalPickUpRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsWithinHorizontalPickUpRange(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsWithinHorizontalPickUpRange");

	Params::KosmosCarriable_IsWithinHorizontalPickUpRange Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.IsWithinMaxFacingPickUpAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsWithinMaxFacingPickUpAngle(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsWithinMaxFacingPickUpAngle");

	Params::KosmosCarriable_IsWithinMaxFacingPickUpAngle Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.IsWithinVerticalPickUpRange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosCarriable::IsWithinVerticalPickUpRange(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsWithinVerticalPickUpRange");

	Params::KosmosCarriable_IsWithinVerticalPickUpRange Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.Multi_Resume
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    InCanPickup                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::Multi_Resume(bool InCanPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "Multi_Resume");

	Params::KosmosCarriable_Multi_Resume Parms{};

	Parms.InCanPickup = InCanPickup;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.Multi_Resume_Full
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    InCanPickup                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize&       InLocation                                             (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize&       InRotation                                             (ConstParm, Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::Multi_Resume_Full(bool InCanPickup, const struct FVector_NetQuantize& InLocation, const struct FVector_NetQuantize& InRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "Multi_Resume_Full");

	Params::KosmosCarriable_Multi_Resume_Full Parms{};

	Parms.InCanPickup = InCanPickup;
	Parms.InLocation = std::move(InLocation);
	Parms.InRotation = std::move(InRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.Multicast_AttachCarriable
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// class USceneComponent*                  InAttachmentComponent                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::Multicast_AttachCarriable(class USceneComponent* InAttachmentComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "Multicast_AttachCarriable");

	Params::KosmosCarriable_Multicast_AttachCarriable Parms{};

	Parms.InAttachmentComponent = InAttachmentComponent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.OnCarriableUsageStateChange
// (Event, Public, BlueprintEvent)

void AKosmosCarriable::OnCarriableUsageStateChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "OnCarriableUsageStateChange");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCarriable.SetAttachParent
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TSoftObjectPtr<class AActor>&     Parent                                                 (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetAttachParent(const TSoftObjectPtr<class AActor>& Parent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetAttachParent");

	Params::KosmosCarriable_SetAttachParent Parms{};

	Parms.Parent = Parent;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.SetCanPickup
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    CanPickup                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetCanPickup(bool CanPickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetCanPickup");

	Params::KosmosCarriable_SetCanPickup Parms{};

	Parms.CanPickup = CanPickup;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.SetCarriableUsage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosCarriableUsage                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetCarriableUsage(EKosmosCarriableUsage Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetCarriableUsage");

	Params::KosmosCarriable_SetCarriableUsage Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.SetInHandState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetInHandState(int32 Bitmask, bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetInHandState");

	Params::KosmosCarriable_SetInHandState Parms{};

	Parms.Bitmask = Bitmask;
	Parms.bSet = bSet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.SetOnGroundState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetOnGroundState(int32 Bitmask, bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetOnGroundState");

	Params::KosmosCarriable_SetOnGroundState Parms{};

	Parms.Bitmask = Bitmask;
	Parms.bSet = bSet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.SetOtherState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Bitmask                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSet                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::SetOtherState(int32 Bitmask, bool bSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "SetOtherState");

	Params::KosmosCarriable_SetOtherState Parms{};

	Parms.Bitmask = Bitmask;
	Parms.bSet = bSet;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.TriggerCollectedDelegate
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable::TriggerCollectedDelegate(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "TriggerCollectedDelegate");

	Params::KosmosCarriable_TriggerCollectedDelegate Parms{};

	Parms.InCharacter = InCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.UpdateState
// (Final, Native, Private)

void AKosmosCarriable::UpdateState()
{
	static class UFunction* Func = nullptr;

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

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCarriable.GetAttachParent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosCarriable::GetAttachParent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetAttachParent");

	Params::KosmosCarriable_GetAttachParent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable.GetCarriableUsage
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosCarriableUsage                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosCarriableUsage AKosmosCarriable::GetCarriableUsage() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "GetCarriableUsage");

	Params::KosmosCarriable_GetCarriableUsage Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosCarriable::HasAttachmentParentReference() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "HasAttachmentParentReference");

	Params::KosmosCarriable_HasAttachmentParentReference Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosCarriable::IsPickupMoving() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable", "IsPickupMoving");

	Params::KosmosCarriable_IsPickupMoving Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCarriable_SkeletalMesh.OnThrow
// (Final, Native, Protected, HasDefaults)
// Parameters:
// class AKosmosBaseCharacter*             Holder                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Velocity                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCarriable_SkeletalMesh::OnThrow(class AKosmosBaseCharacter* Holder, const struct FVector& Velocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCarriable_SkeletalMesh", "OnThrow");

	Params::KosmosCarriable_SkeletalMesh_OnThrow Parms{};

	Parms.Holder = Holder;
	Parms.Velocity = std::move(Velocity);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_ApproachByTransitionManager.ApproachByTransitionManager
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetDirection                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FCharacterTransitionData&  TransitionData                                         (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class UObject*                          InNotifyObject                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_ApproachByTransitionManager*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_ApproachByTransitionManager* UAbilityTask_ApproachByTransitionManager::ApproachByTransitionManager(class UGameplayAbility* OwningAbility, const struct FVector& TargetLocation, const struct FVector& TargetDirection, const struct FCharacterTransitionData& TransitionData, class UObject* InNotifyObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_ApproachByTransitionManager", "ApproachByTransitionManager");

	Params::AbilityTask_ApproachByTransitionManager_ApproachByTransitionManager Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetDirection = std::move(TargetDirection);
	Parms.TransitionData = std::move(TransitionData);
	Parms.InNotifyObject = InNotifyObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_ApproachByTransitionManager.OnCancelledTransition
// (Final, Native, Public)

void UAbilityTask_ApproachByTransitionManager::OnCancelledTransition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_ApproachByTransitionManager", "OnCancelledTransition");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_ApproachByTransitionManager.OnReachedGrabPosition
// (Final, Native, Public)

void UAbilityTask_ApproachByTransitionManager::OnReachedGrabPosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_ApproachByTransitionManager", "OnReachedGrabPosition");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.AddOverrideAnimationSlots
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UCharacterAnimationSlots*   overrideInfo                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAnimationOverridePriority              Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FAnimationOverrideHandle         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

struct FAnimationOverrideHandle UAnimationOverrideComponent::AddOverrideAnimationSlots(const class UCharacterAnimationSlots* overrideInfo, EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "AddOverrideAnimationSlots");

	Params::AnimationOverrideComponent_AddOverrideAnimationSlots Parms{};

	Parms.overrideInfo = overrideInfo;
	Parms.Priority = Priority;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AnimationOverrideComponent.NotifyAnimationOverrideFinished
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FFlowControlAnimNotifyData&AnimNotify                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UAnimationOverrideComponent::NotifyAnimationOverrideFinished(const struct FFlowControlAnimNotifyData& AnimNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "NotifyAnimationOverrideFinished");

	Params::AnimationOverrideComponent_NotifyAnimationOverrideFinished Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.PlayAnimationSequenceOverride2
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAnimSequenceBase*                AnimationToPlay                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementRestriction                    movementRestriction                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    Looping                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   options                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendInTime                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   BlendOutTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationOverrideComponent::PlayAnimationSequenceOverride2(class UAnimSequenceBase* AnimationToPlay, EMovementRestriction movementRestriction, bool Looping, int32 options, float BlendInTime, float BlendOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "PlayAnimationSequenceOverride2");

	Params::AnimationOverrideComponent_PlayAnimationSequenceOverride2 Parms{};

	Parms.AnimationToPlay = AnimationToPlay;
	Parms.movementRestriction = movementRestriction;
	Parms.Looping = Looping;
	Parms.options = options;
	Parms.BlendInTime = BlendInTime;
	Parms.BlendOutTime = BlendOutTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.SetBlendspaceXY
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationOverrideComponent::SetBlendspaceXY(float X, float Y)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "SetBlendspaceXY");

	Params::AnimationOverrideComponent_SetBlendspaceXY Parms{};

	Parms.X = X;
	Parms.Y = Y;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.SetOverrideAnimation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAnimationOverrideType                  overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   enterBlendTime                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   exitBlendtime                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationOverrideComponent::SetOverrideAnimation(EAnimationOverrideType overrideType, float enterBlendTime, float exitBlendtime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "SetOverrideAnimation");

	Params::AnimationOverrideComponent_SetOverrideAnimation Parms{};

	Parms.overrideType = overrideType;
	Parms.enterBlendTime = enterBlendTime;
	Parms.exitBlendtime = exitBlendtime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.StopAnimationSequenceOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    skipExitAnimation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationOverrideComponent::StopAnimationSequenceOverride(bool skipExitAnimation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "StopAnimationSequenceOverride");

	Params::AnimationOverrideComponent_StopAnimationSequenceOverride Parms{};

	Parms.skipExitAnimation = skipExitAnimation;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationOverrideComponent.StopComplexOverrideLoop
// (Final, Native, Public, BlueprintCallable)

void UAnimationOverrideComponent::StopComplexOverrideLoop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationOverrideComponent", "StopComplexOverrideLoop");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_ApproachNavmesh.ApproachNav
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetDirection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeOutDuration                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          InNotifyObject                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShowDebug                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_ApproachNavmesh*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_ApproachNavmesh* UAbilityTask_ApproachNavmesh::ApproachNav(class UGameplayAbility* OwningAbility, const struct FVector& TargetLocation, const struct FVector& TargetDirection, float TimeOutDuration, class UObject* InNotifyObject, bool bShowDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_ApproachNavmesh", "ApproachNav");

	Params::AbilityTask_ApproachNavmesh_ApproachNav Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetDirection = std::move(TargetDirection);
	Parms.TimeOutDuration = TimeOutDuration;
	Parms.InNotifyObject = InNotifyObject;
	Parms.bShowDebug = bShowDebug;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAtmosphereVolumeController.ClearAlternativePlayerPoint
// (Final, Native, Public, BlueprintCallable)

void AKosmosAtmosphereVolumeController::ClearAlternativePlayerPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolumeController", "ClearAlternativePlayerPoint");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAtmosphereVolumeController.ImmediatelyCompleteBlending
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosAtmosphereVolume*          VolumeToCompleteBlending                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAtmosphereVolumeController::ImmediatelyCompleteBlending(class AKosmosAtmosphereVolume* VolumeToCompleteBlending)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolumeController", "ImmediatelyCompleteBlending");

	Params::KosmosAtmosphereVolumeController_ImmediatelyCompleteBlending Parms{};

	Parms.VolumeToCompleteBlending = VolumeToCompleteBlending;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAtmosphereVolumeController.SetAlternativePlayerPoint
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Point                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAtmosphereVolumeController::SetAlternativePlayerPoint(const struct FVector& Point)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolumeController", "SetAlternativePlayerPoint");

	Params::KosmosAtmosphereVolumeController_SetAlternativePlayerPoint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_CheckDistanceAndAngle.CheckDistanceAndAngle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UGrabHelper*>&       GrabHelpers_0                                          (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// ECheckingType                           CheckingType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bLockGrabHelperPosition                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationCharacterAngle                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationInputsAngle                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckCharacterInputsDirection                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawDebug                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_CheckDistanceAndAngle*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_CheckDistanceAndAngle* UAbilityTask_CheckDistanceAndAngle::CheckDistanceAndAngle(class UGameplayAbility* OwningAbility, const TArray<class UGrabHelper*>& GrabHelpers_0, ECheckingType CheckingType, bool bLockGrabHelperPosition, float ActivationDistance, float ActivationCharacterAngle, float ActivationInputsAngle, bool bCheckCharacterInputsDirection, bool bDrawDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_CheckDistanceAndAngle", "CheckDistanceAndAngle");

	Params::AbilityTask_CheckDistanceAndAngle_CheckDistanceAndAngle Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.GrabHelpers_0 = std::move(GrabHelpers_0);
	Parms.CheckingType = CheckingType;
	Parms.bLockGrabHelperPosition = bLockGrabHelperPosition;
	Parms.ActivationDistance = ActivationDistance;
	Parms.ActivationCharacterAngle = ActivationCharacterAngle;
	Parms.ActivationInputsAngle = ActivationInputsAngle;
	Parms.bCheckCharacterInputsDirection = bCheckCharacterInputsDirection;
	Parms.bDrawDebug = bDrawDebug;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_CheckDistanceAndAngleByTick.CheckDistanceAndAngleByTick
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UGrabHelper*>&       GrabHelpers_0                                          (Parm, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    bLockGrabHelperPosition                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationDistance                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationCharacterAngle                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ActivationInputsAngle                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckCharacterInputsDirection                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bDrawDebug                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_CheckDistanceAndAngleByTick*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_CheckDistanceAndAngleByTick* UAbilityTask_CheckDistanceAndAngleByTick::CheckDistanceAndAngleByTick(class UGameplayAbility* OwningAbility, const TArray<class UGrabHelper*>& GrabHelpers_0, bool bLockGrabHelperPosition, float ActivationDistance, float ActivationCharacterAngle, float ActivationInputsAngle, bool bCheckCharacterInputsDirection, bool bDrawDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_CheckDistanceAndAngleByTick", "CheckDistanceAndAngleByTick");

	Params::AbilityTask_CheckDistanceAndAngleByTick_CheckDistanceAndAngleByTick Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.GrabHelpers_0 = std::move(GrabHelpers_0);
	Parms.bLockGrabHelperPosition = bLockGrabHelperPosition;
	Parms.ActivationDistance = ActivationDistance;
	Parms.ActivationCharacterAngle = ActivationCharacterAngle;
	Parms.ActivationInputsAngle = ActivationInputsAngle;
	Parms.bCheckCharacterInputsDirection = bCheckCharacterInputsDirection;
	Parms.bDrawDebug = bDrawDebug;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_KosmosListenToInput.KosmosListenToInput
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_KosmosListenToInput* ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_KosmosListenToInput* UAbilityTask_KosmosListenToInput::KosmosListenToInput(class UGameplayAbility* OwningAbility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_KosmosListenToInput", "KosmosListenToInput");

	Params::AbilityTask_KosmosListenToInput_KosmosListenToInput Parms{};

	Parms.OwningAbility = OwningAbility;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_KosmosListenToInput.OnGrabCallback
// (Final, Native, Public)
// Parameters:
// bool                                    bPressed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityTask_KosmosListenToInput::OnGrabCallback(bool bPressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_KosmosListenToInput", "OnGrabCallback");

	Params::AbilityTask_KosmosListenToInput_OnGrabCallback Parms{};

	Parms.bPressed = bPressed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_KosmosListenToInput.OnUseWeaponCallback
// (Final, Native, Public)
// Parameters:
// bool                                    bPressed                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityTask_KosmosListenToInput::OnUseWeaponCallback(bool bPressed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_KosmosListenToInput", "OnUseWeaponCallback");

	Params::AbilityTask_KosmosListenToInput_OnUseWeaponCallback Parms{};

	Parms.bPressed = bPressed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_KosmosWaitInputPress.KosmosWaitInputPress
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTestAlreadyReleased                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_KosmosWaitInputPress*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_KosmosWaitInputPress* UAbilityTask_KosmosWaitInputPress::KosmosWaitInputPress(class UGameplayAbility* OwningAbility, bool bTestAlreadyReleased)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_KosmosWaitInputPress", "KosmosWaitInputPress");

	Params::AbilityTask_KosmosWaitInputPress_KosmosWaitInputPress Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.bTestAlreadyReleased = bTestAlreadyReleased;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_KosmosWaitInputPress.OnPressCallback
// (Final, Native, Public)
// Parameters:
// bool                                    bIsGrabbed                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityTask_KosmosWaitInputPress::OnPressCallback(bool bIsGrabbed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_KosmosWaitInputPress", "OnPressCallback");

	Params::AbilityTask_KosmosWaitInputPress_OnPressCallback Parms{};

	Parms.bIsGrabbed = bIsGrabbed;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_CrouchSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldCrouchSpeed                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_CrouchSpeed(const struct FGameplayAttributeData& OldCrouchSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_CrouchSpeed");

	Params::KosmosAttributeSetBase_OnRep_CrouchSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_DummyValue
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldDummyValue                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_DummyValue(const struct FGameplayAttributeData& OldDummyValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_DummyValue");

	Params::KosmosAttributeSetBase_OnRep_DummyValue Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_FastCrouchSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldFastCrouchSpeed                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_FastCrouchSpeed(const struct FGameplayAttributeData& OldFastCrouchSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_FastCrouchSpeed");

	Params::KosmosAttributeSetBase_OnRep_FastCrouchSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_JogSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldJogSpeed                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_JogSpeed(const struct FGameplayAttributeData& OldJogSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_JogSpeed");

	Params::KosmosAttributeSetBase_OnRep_JogSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_RunSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldRunSpeed                                            (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_RunSpeed(const struct FGameplayAttributeData& OldRunSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_RunSpeed");

	Params::KosmosAttributeSetBase_OnRep_RunSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_SwimDownSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldSwimDownSpeed                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_SwimDownSpeed(const struct FGameplayAttributeData& OldSwimDownSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_SwimDownSpeed");

	Params::KosmosAttributeSetBase_OnRep_SwimDownSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_SwimSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldSwimSpeed                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_SwimSpeed(const struct FGameplayAttributeData& OldSwimSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_SwimSpeed");

	Params::KosmosAttributeSetBase_OnRep_SwimSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_SwimUpSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldSwimUpSpeed                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_SwimUpSpeed(const struct FGameplayAttributeData& OldSwimUpSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_SwimUpSpeed");

	Params::KosmosAttributeSetBase_OnRep_SwimUpSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAttributeSetBase.OnRep_WalkSpeed
// (Native, Public, HasOutParams)
// Parameters:
// const struct FGameplayAttributeData&    OldWalkSpeed                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAttributeSetBase::OnRep_WalkSpeed(const struct FGameplayAttributeData& OldWalkSpeed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAttributeSetBase", "OnRep_WalkSpeed");

	Params::KosmosAttributeSetBase_OnRep_WalkSpeed Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_KosmosWaitInputRelease.KosmosWaitInputRelease
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTestAlreadyReleased                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_KosmosWaitInputRelease*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_KosmosWaitInputRelease* UAbilityTask_KosmosWaitInputRelease::KosmosWaitInputRelease(class UGameplayAbility* OwningAbility, bool bTestAlreadyReleased)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_KosmosWaitInputRelease", "KosmosWaitInputRelease");

	Params::AbilityTask_KosmosWaitInputRelease_KosmosWaitInputRelease Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.bTestAlreadyReleased = bTestAlreadyReleased;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_KosmosWaitInputRelease.OnReleaseCallback
// (Final, Native, Public)

void UAbilityTask_KosmosWaitInputRelease::OnReleaseCallback()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_KosmosWaitInputRelease", "OnReleaseCallback");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlayMontageAndReceiveNotify.PlayMontageAndReceiveNotify
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Rate_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSection_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ExitSection_0                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopWhenAbilityEnds_0                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AnimRootMotionTranslationScale_0                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_PlayMontageAndReceiveNotify*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_PlayMontageAndReceiveNotify* UAbilityTask_PlayMontageAndReceiveNotify::PlayMontageAndReceiveNotify(class UGameplayAbility* OwningAbility, class UAnimMontage* MontageToPlay_0, float Rate_0, class FName StartSection_0, class FName ExitSection_0, bool bStopWhenAbilityEnds_0, float AnimRootMotionTranslationScale_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_PlayMontageAndReceiveNotify", "PlayMontageAndReceiveNotify");

	Params::AbilityTask_PlayMontageAndReceiveNotify_PlayMontageAndReceiveNotify Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.MontageToPlay_0 = MontageToPlay_0;
	Parms.Rate_0 = Rate_0;
	Parms.StartSection_0 = StartSection_0;
	Parms.ExitSection_0 = ExitSection_0;
	Parms.bStopWhenAbilityEnds_0 = bStopWhenAbilityEnds_0;
	Parms.AnimRootMotionTranslationScale_0 = AnimRootMotionTranslationScale_0;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_PlayMontageAndReceiveNotify.OnAnimNotifyReceived
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UAbilityTask_PlayMontageAndReceiveNotify::OnAnimNotifyReceived(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlayMontageAndReceiveNotify", "OnAnimNotifyReceived");

	Params::AbilityTask_PlayMontageAndReceiveNotify_OnAnimNotifyReceived Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlayMontageAndReceiveNotify.OnMontageNotifyBeginReceived
// (Final, Native, Private, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAbilityTask_PlayMontageAndReceiveNotify::OnMontageNotifyBeginReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlayMontageAndReceiveNotify", "OnMontageNotifyBeginReceived");

	Params::AbilityTask_PlayMontageAndReceiveNotify_OnMontageNotifyBeginReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlayMontageAndReceiveNotify.OnMontageNotifyEndReceived
// (Final, Native, Private, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UAbilityTask_PlayMontageAndReceiveNotify::OnMontageNotifyEndReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlayMontageAndReceiveNotify", "OnMontageNotifyEndReceived");

	Params::AbilityTask_PlayMontageAndReceiveNotify_OnMontageNotifyEndReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterSpawningComponent.Multicast_MoveCharacterToStartingCheckpointLocation
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, HasDefaults)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector_NetQuantize&       NewLocation                                            (ConstParm, Parm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  NewRotation                                            (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterSpawningComponent::Multicast_MoveCharacterToStartingCheckpointLocation(class AKosmosBaseCharacter* Character, const struct FVector_NetQuantize& NewLocation, const struct FRotator& NewRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterSpawningComponent", "Multicast_MoveCharacterToStartingCheckpointLocation");

	Params::KosmosCharacterSpawningComponent_Multicast_MoveCharacterToStartingCheckpointLocation Parms{};

	Parms.Character = Character;
	Parms.NewLocation = std::move(NewLocation);
	Parms.NewRotation = std::move(NewRotation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterSpawningComponent.Server_MoveCharacterToStartingCheckpointLocation
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterSpawningComponent::Server_MoveCharacterToStartingCheckpointLocation(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterSpawningComponent", "Server_MoveCharacterToStartingCheckpointLocation");

	Params::KosmosCharacterSpawningComponent_Server_MoveCharacterToStartingCheckpointLocation Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlayMontageAndWaitForEvent.PlayMontageAndWaitForEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             TaskInstanceName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay_0                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayTagContainer&     EventTags_0                                            (Parm, NativeAccessSpecifierPublic)
// float                                   Rate_0                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartSection_0                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopWhenAbilityEnds_0                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AnimRootMotionTranslationScale_0                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_PlayMontageAndWaitForEvent*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_PlayMontageAndWaitForEvent* UAbilityTask_PlayMontageAndWaitForEvent::PlayMontageAndWaitForEvent(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class UAnimMontage* MontageToPlay_0, const struct FGameplayTagContainer& EventTags_0, float Rate_0, class FName StartSection_0, bool bStopWhenAbilityEnds_0, float AnimRootMotionTranslationScale_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_PlayMontageAndWaitForEvent", "PlayMontageAndWaitForEvent");

	Params::AbilityTask_PlayMontageAndWaitForEvent_PlayMontageAndWaitForEvent Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.TaskInstanceName = TaskInstanceName;
	Parms.MontageToPlay_0 = MontageToPlay_0;
	Parms.EventTags_0 = std::move(EventTags_0);
	Parms.Rate_0 = Rate_0;
	Parms.StartSection_0 = StartSection_0;
	Parms.bStopWhenAbilityEnds_0 = bStopWhenAbilityEnds_0;
	Parms.AnimRootMotionTranslationScale_0 = AnimRootMotionTranslationScale_0;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_ReadCurveValue.ReadCurveValue
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             CurveName_0                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_ReadCurveValue*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_ReadCurveValue* UAbilityTask_ReadCurveValue::ReadCurveValue(class UGameplayAbility* OwningAbility, class FName CurveName_0)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_ReadCurveValue", "ReadCurveValue");

	Params::AbilityTask_ReadCurveValue_ReadCurveValue Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.CurveName_0 = CurveName_0;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioManagerActor.GetDefaultListenerComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UKosmosAudioManagerActor::GetDefaultListenerComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAudioManagerActor", "GetDefaultListenerComponent");

	Params::KosmosAudioManagerActor_GetDefaultListenerComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioManagerActor.OnAudioVolumeTransition
// (Final, Native, Protected)
// Parameters:
// class AKosmosAudioVolume*               activeAudioVolume                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioManagerActor::OnAudioVolumeTransition(class AKosmosAudioVolume* activeAudioVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAudioManagerActor", "OnAudioVolumeTransition");

	Params::KosmosAudioManagerActor_OnAudioVolumeTransition Parms{};

	Parms.activeAudioVolume = activeAudioVolume;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


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

int32 UKosmosAudioManagerActor::GetAntagonistsActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAudioManagerActor", "GetAntagonistsActive");

	Params::KosmosAudioManagerActor_GetAntagonistsActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_WaitForPuzzlePieceValue.WaitForPuzzlePieceValue
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LowValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HighValue                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EWaitForPuzzlePieceEndBehaviour         EndLowBehaviour                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EWaitForPuzzlePieceEndBehaviour         EndHighBehaviour                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_WaitForPuzzlePieceValue*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_WaitForPuzzlePieceValue* UAbilityTask_WaitForPuzzlePieceValue::WaitForPuzzlePieceValue(class UGameplayAbility* OwningAbility, float LowValue, float HighValue, EWaitForPuzzlePieceEndBehaviour EndLowBehaviour, EWaitForPuzzlePieceEndBehaviour EndHighBehaviour)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_WaitForPuzzlePieceValue", "WaitForPuzzlePieceValue");

	Params::AbilityTask_WaitForPuzzlePieceValue_WaitForPuzzlePieceValue Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.LowValue = LowValue;
	Parms.HighValue = HighValue;
	Parms.EndLowBehaviour = EndLowBehaviour;
	Parms.EndHighBehaviour = EndHighBehaviour;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTriggerComponent.OnBeginOverlap
// (Final, Native, Private, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UAbilityTriggerComponent::OnBeginOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTriggerComponent", "OnBeginOverlap");

	Params::AbilityTriggerComponent_OnBeginOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTriggerComponent.OnEndOverlap
// (Final, Native, Private)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAbilityTriggerComponent::OnEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTriggerComponent", "OnEndOverlap");

	Params::AbilityTriggerComponent_OnEndOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.CheckIfInviteHasBeenAccepted
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::CheckIfInviteHasBeenAccepted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "CheckIfInviteHasBeenAccepted");

	Params::KosmosComplianceLayer_CheckIfInviteHasBeenAccepted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.GetAccountCountryCode
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosComplianceLayer::GetAccountCountryCode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "GetAccountCountryCode");

	Params::KosmosComplianceLayer_GetAccountCountryCode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.GetActivityManager
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosActivityManager*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosActivityManager* UKosmosComplianceLayer::GetActivityManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "GetActivityManager");

	Params::KosmosComplianceLayer_GetActivityManager Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_GetGameVersion
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosComplianceLayer::K2_GetGameVersion()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_GetGameVersion");

	Params::KosmosComplianceLayer_K2_GetGameVersion Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_IsAccountFromCountry
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EIsCountries                            InCountry                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::K2_IsAccountFromCountry(EIsCountries InCountry)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_IsAccountFromCountry");

	Params::KosmosComplianceLayer_K2_IsAccountFromCountry Parms{};

	Parms.InCountry = InCountry;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_IsEntitlementEnabled
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosEntitlementDataAsset*      InEntitlement                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::K2_IsEntitlementEnabled(class UKosmosEntitlementDataAsset* InEntitlement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_IsEntitlementEnabled");

	Params::KosmosComplianceLayer_K2_IsEntitlementEnabled Parms{};

	Parms.InEntitlement = InEntitlement;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_IsLoggedIn
// (Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// bool*                                   OutIsLoggedIn                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::K2_IsLoggedIn(bool* OutIsLoggedIn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_IsLoggedIn");

	Params::KosmosComplianceLayer_K2_IsLoggedIn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_IsTrialGame
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::K2_IsTrialGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_IsTrialGame");

	Params::KosmosComplianceLayer_K2_IsTrialGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.K2_UpdateEntitlementStatus
// (Native, Public, BlueprintCallable)

void UKosmosComplianceLayer::K2_UpdateEntitlementStatus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "K2_UpdateEntitlementStatus");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.Login
// (Native, Public, BlueprintCallable)

void UKosmosComplianceLayer::Login()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "Login");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.OnControllerConnectionChange
// (Native, Protected)
// Parameters:
// bool                                    IsConnected                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   platformId                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ControllerId                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosComplianceLayer::OnControllerConnectionChange(bool IsConnected, int32 platformId, int32 ControllerId)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "OnControllerConnectionChange");

	Params::KosmosComplianceLayer_OnControllerConnectionChange Parms{};

	Parms.IsConnected = IsConnected;
	Parms.platformId = platformId;
	Parms.ControllerId = ControllerId;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.PlayerLoggedIn
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::PlayerLoggedIn()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "PlayerLoggedIn");

	Params::KosmosComplianceLayer_PlayerLoggedIn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.SetDebugEntitlementStatus
// (Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosEntitlementDataAsset*      InEntitlement                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosComplianceLayer::SetDebugEntitlementStatus(class UKosmosEntitlementDataAsset* InEntitlement, bool bIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "SetDebugEntitlementStatus");

	Params::KosmosComplianceLayer_SetDebugEntitlementStatus Parms{};

	Parms.InEntitlement = InEntitlement;
	Parms.bIsEnabled = bIsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.SetShowControllerDisconnectUI
// (Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosComplianceLayer::SetShowControllerDisconnectUI(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "SetShowControllerDisconnectUI");

	Params::KosmosComplianceLayer_SetShowControllerDisconnectUI Parms{};

	Parms.Value = Value;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.ControllerReconnected
// (Final, Native, Protected, BlueprintCallable, Const)

void UKosmosComplianceLayer::ControllerReconnected() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "ControllerReconnected");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosComplianceLayer.GetSkuRegion
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosSKUs                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosSKUs UKosmosComplianceLayer::GetSkuRegion() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "GetSkuRegion");

	Params::KosmosComplianceLayer_GetSkuRegion Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.IsControllerValid
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::IsControllerValid() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "IsControllerValid");

	Params::KosmosComplianceLayer_IsControllerValid Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayer.ShowControllerDisconnectUI
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayer::ShowControllerDisconnectUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosComplianceLayer", "ShowControllerDisconnectUI");

	Params::KosmosComplianceLayer_ShowControllerDisconnectUI Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayerNinSage.IsUsingSageProController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   PlayerIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayerNinSage::IsUsingSageProController(int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosComplianceLayerNinSage", "IsUsingSageProController");

	Params::KosmosComplianceLayerNinSage_IsUsingSageProController Parms{};

	Parms.PlayerIndex = PlayerIndex;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.HeliosAnimationBlueprintLibrary.ExtractRootMotion
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UAnimSequence*              AnimationSequence                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StartTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bAllowLooping                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UHeliosAnimationBlueprintLibrary::ExtractRootMotion(const class UAnimSequence* AnimationSequence, float StartTime, float DeltaTime, bool bAllowLooping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("HeliosAnimationBlueprintLibrary", "ExtractRootMotion");

	Params::HeliosAnimationBlueprintLibrary_ExtractRootMotion Parms{};

	Parms.AnimationSequence = AnimationSequence;
	Parms.StartTime = StartTime;
	Parms.DeltaTime = DeltaTime;
	Parms.bAllowLooping = bAllowLooping;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilityBlueprintLibrary.ClosestActor
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const TArray<class AActor*>&            Actors                                                 (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UKosmosAbilityBlueprintLibrary::ClosestActor(const TArray<class AActor*>& Actors, const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAbilityBlueprintLibrary", "ClosestActor");

	Params::KosmosAbilityBlueprintLibrary_ClosestActor Parms{};

	Parms.Actors = std::move(Actors);
	Parms.Location = std::move(Location);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilityBlueprintLibrary.GetGrabbablesOfType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Searcher                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UKosmosBaseGrabbableComponent>GrabbableType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UKosmosAbilityBlueprintLibrary::GetGrabbablesOfType(class AActor* Searcher, TSubclassOf<class UKosmosBaseGrabbableComponent> GrabbableType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAbilityBlueprintLibrary", "GetGrabbablesOfType");

	Params::KosmosAbilityBlueprintLibrary_GetGrabbablesOfType Parms{};

	Parms.Searcher = Searcher;
	Parms.GrabbableType = GrabbableType;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilityBlueprintLibrary.GetPickupOfType
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Searcher                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UKosmosPickupComponent>PickupType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AActor*>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AActor*> UKosmosAbilityBlueprintLibrary::GetPickupOfType(class AActor* Searcher, TSubclassOf<class UKosmosPickupComponent> PickupType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAbilityBlueprintLibrary", "GetPickupOfType");

	Params::KosmosAbilityBlueprintLibrary_GetPickupOfType Parms{};

	Parms.Searcher = Searcher;
	Parms.PickupType = PickupType;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilityBlueprintLibrary.GetPrimaryAbilityInstanceFromClass
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayAbility>     InAbilityClass                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayAbility* UKosmosAbilityBlueprintLibrary::GetPrimaryAbilityInstanceFromClass(class UAbilitySystemComponent* AbilitySystemComponent, TSubclassOf<class UGameplayAbility> InAbilityClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAbilityBlueprintLibrary", "GetPrimaryAbilityInstanceFromClass");

	Params::KosmosAbilityBlueprintLibrary_GetPrimaryAbilityInstanceFromClass Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.InAbilityClass = InAbilityClass;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilityBlueprintLibrary.GetPrimaryAbilityInstanceFromHandle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAbilitySystemComponent*          AbilitySystemComponent                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FGameplayAbilitySpecHandle&Handle                                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGameplayAbility*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGameplayAbility* UKosmosAbilityBlueprintLibrary::GetPrimaryAbilityInstanceFromHandle(class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayAbilitySpecHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAbilityBlueprintLibrary", "GetPrimaryAbilityInstanceFromHandle");

	Params::KosmosAbilityBlueprintLibrary_GetPrimaryAbilityInstanceFromHandle Parms{};

	Parms.AbilitySystemComponent = AbilitySystemComponent;
	Parms.Handle = std::move(Handle);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilitySystemComponent.FindAbilitySpecHandleForClass
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TSubclassOf<class UGameplayAbility>     AbilityClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          OptionalSourceObject                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayAbilitySpecHandle       ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayAbilitySpecHandle UKosmosAbilitySystemComponent::FindAbilitySpecHandleForClass(TSubclassOf<class UGameplayAbility> AbilityClass, class UObject* OptionalSourceObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "FindAbilitySpecHandleForClass");

	Params::KosmosAbilitySystemComponent_FindAbilitySpecHandleForClass Parms{};

	Parms.AbilityClass = AbilityClass;
	Parms.OptionalSourceObject = OptionalSourceObject;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_AddLooseGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_AddLooseGameplayTag(const struct FGameplayTag& GameplayTag, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_AddLooseGameplayTag");

	Params::KosmosAbilitySystemComponent_K2_AddLooseGameplayTag Parms{};

	Parms.GameplayTag = std::move(GameplayTag);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_AddLooseGameplayTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_AddLooseGameplayTags(const struct FGameplayTagContainer& GameplayTags, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_AddLooseGameplayTags");

	Params::KosmosAbilitySystemComponent_K2_AddLooseGameplayTags Parms{};

	Parms.GameplayTags = std::move(GameplayTags);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_ApplyGameplayEffectToSelfWithPredictionKey
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TSubclassOf<class UGameplayEffect>GameplayEffect                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FActiveGameplayEffectHandle      ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FActiveGameplayEffectHandle UKosmosAbilitySystemComponent::K2_ApplyGameplayEffectToSelfWithPredictionKey(const TSubclassOf<class UGameplayEffect> GameplayEffect)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_ApplyGameplayEffectToSelfWithPredictionKey");

	Params::KosmosAbilitySystemComponent_K2_ApplyGameplayEffectToSelfWithPredictionKey Parms{};

	Parms.GameplayEffect = GameplayEffect;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_RemoveActiveGameplayEffectByHandle
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FActiveGameplayEffectHandle&Handle                                                 (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_RemoveActiveGameplayEffectByHandle(const struct FActiveGameplayEffectHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_RemoveActiveGameplayEffectByHandle");

	Params::KosmosAbilitySystemComponent_K2_RemoveActiveGameplayEffectByHandle Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_RemoveLooseGameplayTag
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayTag                                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_RemoveLooseGameplayTag(const struct FGameplayTag& GameplayTag, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_RemoveLooseGameplayTag");

	Params::KosmosAbilitySystemComponent_K2_RemoveLooseGameplayTag Parms{};

	Parms.GameplayTag = std::move(GameplayTag);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_RemoveLooseGameplayTags
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTagContainer&     GameplayTags                                           (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_RemoveLooseGameplayTags(const struct FGameplayTagContainer& GameplayTags, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_RemoveLooseGameplayTags");

	Params::KosmosAbilitySystemComponent_K2_RemoveLooseGameplayTags Parms{};

	Parms.GameplayTags = std::move(GameplayTags);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAbilitySystemComponent.K2_SetLooseGameplayTagCount
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              GameplayTags                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Count                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAbilitySystemComponent::K2_SetLooseGameplayTagCount(const struct FGameplayTag& GameplayTags, int32 Count)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAbilitySystemComponent", "K2_SetLooseGameplayTagCount");

	Params::KosmosAbilitySystemComponent_K2_SetLooseGameplayTagCount Parms{};

	Parms.GameplayTags = std::move(GameplayTags);
	Parms.Count = Count;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.CheckForPlatinum
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::CheckForPlatinum(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "CheckForPlatinum");

	Params::KosmosAchievementBlueprintLibrary_CheckForPlatinum Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.CheckOfflineAchievements
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::CheckOfflineAchievements(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "CheckOfflineAchievements");

	Params::KosmosAchievementBlueprintLibrary_CheckOfflineAchievements Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.DebugFillAchievementSaveData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::DebugFillAchievementSaveData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "DebugFillAchievementSaveData");

	Params::KosmosAchievementBlueprintLibrary_DebugFillAchievementSaveData Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.GetAllAchievementNames
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FKosmosAchievementNameReference>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

const TArray<struct FKosmosAchievementNameReference> UKosmosAchievementBlueprintLibrary::GetAllAchievementNames(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "GetAllAchievementNames");

	Params::KosmosAchievementBlueprintLibrary_GetAllAchievementNames Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.IncrementAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::IncrementAchievement(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName, int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "IncrementAchievement");

	Params::KosmosAchievementBlueprintLibrary_IncrementAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);
	Parms.Value = Value;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.IncrementCharacterSpeicificAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosBaseCharacter*       LocalChar                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsForPrimaryCharacter                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::IncrementCharacterSpeicificAchievement(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName, int32 Value, const class AKosmosBaseCharacter* LocalChar, bool bIsForPrimaryCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "IncrementCharacterSpeicificAchievement");

	Params::KosmosAchievementBlueprintLibrary_IncrementCharacterSpeicificAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);
	Parms.Value = Value;
	Parms.LocalChar = LocalChar;
	Parms.bIsForPrimaryCharacter = bIsForPrimaryCharacter;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.IncrementCollectableAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&ReferenceID                                            (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::IncrementCollectableAchievement(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName, const struct FKosmosCollectableNameReference& ReferenceID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "IncrementCollectableAchievement");

	Params::KosmosAchievementBlueprintLibrary_IncrementCollectableAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);
	Parms.ReferenceID = std::move(ReferenceID);

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.IsAchievementUnlockedLocal
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosAchievementBlueprintLibrary::IsAchievementUnlockedLocal(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "IsAchievementUnlockedLocal");

	Params::KosmosAchievementBlueprintLibrary_IsAchievementUnlockedLocal Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.QueryAchievements
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::QueryAchievements(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "QueryAchievements");

	Params::KosmosAchievementBlueprintLibrary_QueryAchievements Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.ResetAllAchievements
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::ResetAllAchievements(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "ResetAllAchievements");

	Params::KosmosAchievementBlueprintLibrary_ResetAllAchievements Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.SetAchievementProgress
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::SetAchievementProgress(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName, int32 Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "SetAchievementProgress");

	Params::KosmosAchievementBlueprintLibrary_SetAchievementProgress Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);
	Parms.Value = Value;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.UnlockAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementName                                        (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::UnlockAchievement(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "UnlockAchievement");

	Params::KosmosAchievementBlueprintLibrary_UnlockAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementName = std::move(AchievementName);

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.UpdateCompleteGameCharacterSpecificAchievement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementPrimaryName                                 (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAchievementNameReference&AchievementSecondaryName                               (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosLevelNameReference& LevelCompleted                                         (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::UpdateCompleteGameCharacterSpecificAchievement(class UObject* WorldContextObject, const struct FKosmosAchievementNameReference& AchievementPrimaryName, const struct FKosmosAchievementNameReference& AchievementSecondaryName, const struct FKosmosLevelNameReference& LevelCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "UpdateCompleteGameCharacterSpecificAchievement");

	Params::KosmosAchievementBlueprintLibrary_UpdateCompleteGameCharacterSpecificAchievement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AchievementPrimaryName = std::move(AchievementPrimaryName);
	Parms.AchievementSecondaryName = std::move(AchievementSecondaryName);
	Parms.LevelCompleted = std::move(LevelCompleted);

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementBlueprintLibrary.UpdateLocalDataFromSaveData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementBlueprintLibrary::UpdateLocalDataFromSaveData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAchievementBlueprintLibrary", "UpdateLocalDataFromSaveData");

	Params::KosmosAchievementBlueprintLibrary_UpdateLocalDataFromSaveData Parms{};

	Parms.WorldContextObject = WorldContextObject;

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

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

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAchievementManager.UpdateAchievementsAfterSwitchingTrial
// (Final, Native, Public)
// Parameters:
// const ETrialLicenceStatus               OldStatus                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const ETrialLicenceStatus               NewStatus                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAchievementManager::UpdateAchievementsAfterSwitchingTrial(const ETrialLicenceStatus OldStatus, const ETrialLicenceStatus NewStatus)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAchievementManager", "UpdateAchievementsAfterSwitchingTrial");

	Params::KosmosAchievementManager_UpdateAchievementsAfterSwitchingTrial Parms{};

	Parms.OldStatus = OldStatus;
	Parms.NewStatus = NewStatus;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.GetCanSwapInJapanese
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosActionKeyBinding::GetCanSwapInJapanese()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCanSwapInJapanese");

	Params::KosmosActionKeyBinding_GetCanSwapInJapanese Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetCurrentGamepadKeyPress
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosActionKeyBinding::GetCurrentGamepadKeyPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCurrentGamepadKeyPress");

	Params::KosmosActionKeyBinding_GetCurrentGamepadKeyPress Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetCurrentKeyboardKeyPress
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosActionKeyBinding::GetCurrentKeyboardKeyPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCurrentKeyboardKeyPress");

	Params::KosmosActionKeyBinding_GetCurrentKeyboardKeyPress Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetCurrentKeyForIcon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosActionKeyBinding::GetCurrentKeyForIcon(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCurrentKeyForIcon");

	Params::KosmosActionKeyBinding_GetCurrentKeyForIcon Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetCurrentKeyState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosActionKeyBinding::GetCurrentKeyState(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCurrentKeyState");

	Params::KosmosActionKeyBinding_GetCurrentKeyState Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetCurrentMouseKeyPress
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosActionKeyBinding::GetCurrentMouseKeyPress()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetCurrentMouseKeyPress");

	Params::KosmosActionKeyBinding_GetCurrentMouseKeyPress Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetIsInputKeyDown
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosActionKeyBinding::GetIsInputKeyDown(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetIsInputKeyDown");

	Params::KosmosActionKeyBinding_GetIsInputKeyDown Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.GetWasInputKeyJustPressed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosActionKeyBinding::GetWasInputKeyJustPressed(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "GetWasInputKeyJustPressed");

	Params::KosmosActionKeyBinding_GetWasInputKeyJustPressed Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosActionKeyBinding.InitialiseBinding
// (Final, Native, Public, BlueprintCallable)

void UKosmosActionKeyBinding::InitialiseBinding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "InitialiseBinding");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.LoadKeybindingFromBlackboard
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActionKeyBinding::LoadKeybindingFromBlackboard(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "LoadKeybindingFromBlackboard");

	Params::KosmosActionKeyBinding_LoadKeybindingFromBlackboard Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.NullKey
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKey&                      InKeyUsed                                              (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActionKeyBinding::NullKey(const struct FKey& InKeyUsed)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "NullKey");

	Params::KosmosActionKeyBinding_NullKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.RebindKey
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActionKeyBinding::RebindKey(const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "RebindKey");

	Params::KosmosActionKeyBinding_RebindKey Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.ResetKeybindingToDefault
// (Final, Native, Public, BlueprintCallable)

void UKosmosActionKeyBinding::ResetKeybindingToDefault()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "ResetKeybindingToDefault");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActionKeyBinding.SaveKeybindingToBlackboard
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActionKeyBinding::SaveKeybindingToBlackboard(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActionKeyBinding", "SaveKeybindingToBlackboard");

	Params::KosmosActionKeyBinding_SaveKeybindingToBlackboard Parms{};

	Parms.InPlayerController = InPlayerController;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.BindActivityDelegates
// (Final, Native, Public, BlueprintCallable)

void UKosmosActivityManager::BindActivityDelegates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "BindActivityDelegates");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.ClearCurrentActivityRequests
// (Final, Native, Public, BlueprintCallable)

void UKosmosActivityManager::ClearCurrentActivityRequests()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "ClearCurrentActivityRequests");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.EndActivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosActivityData*              InActivity                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosActivityEndReason                InReason                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActivityManager::EndActivity(class UKosmosActivityData* InActivity, EKosmosActivityEndReason InReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "EndActivity");

	Params::KosmosActivityManager_EndActivity Parms{};

	Parms.InActivity = InActivity;
	Parms.InReason = InReason;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.ResetAllActivities
// (Final, Native, Public, BlueprintCallable)

void UKosmosActivityManager::ResetAllActivities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "ResetAllActivities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.ResumeActivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosActivityData*              InActivity                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActivityManager::ResumeActivity(class UKosmosActivityData* InActivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "ResumeActivity");

	Params::KosmosActivityManager_ResumeActivity Parms{};

	Parms.InActivity = InActivity;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.SetActivityAvailability
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosActivityData*              InActivity                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosActivityAvailability             InAvailability                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActivityManager::SetActivityAvailability(class UKosmosActivityData* InActivity, EKosmosActivityAvailability InAvailability)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "SetActivityAvailability");

	Params::KosmosActivityManager_SetActivityAvailability Parms{};

	Parms.InActivity = InActivity;
	Parms.InAvailability = InAvailability;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.StartActivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosActivityData*              InActivity                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosActivityManager::StartActivity(class UKosmosActivityData* InActivity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "StartActivity");

	Params::KosmosActivityManager_StartActivity Parms{};

	Parms.InActivity = InActivity;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActivityManager.UnBindActivityDelegates
// (Final, Native, Public, BlueprintCallable)

void UKosmosActivityManager::UnBindActivityDelegates()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActivityManager", "UnBindActivityDelegates");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActorTriggerVolume.OnBeginOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosActorTriggerVolume::OnBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "OnBeginOverlap");

	Params::KosmosActorTriggerVolume_OnBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActorTriggerVolume.OnEndOverlap
// (Final, Native, Private)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosActorTriggerVolume::OnEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "OnEndOverlap");

	Params::KosmosActorTriggerVolume_OnEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActorTriggerVolume.OnKosmosActorBeginOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosActorTriggerVolume::OnKosmosActorBeginOverlap_Blueprint(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "OnKosmosActorBeginOverlap_Blueprint");

	Params::KosmosActorTriggerVolume_OnKosmosActorBeginOverlap_Blueprint Parms{};

	Parms.Actor = Actor;

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


// Function Kosmos.KosmosActorTriggerVolume.OnKosmosActorEndOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosActorTriggerVolume::OnKosmosActorEndOverlap_Blueprint(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "OnKosmosActorEndOverlap_Blueprint");

	Params::KosmosActorTriggerVolume_OnKosmosActorEndOverlap_Blueprint Parms{};

	Parms.Actor = Actor;

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


// Function Kosmos.KosmosActorTriggerVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosActorTriggerVolume::SetEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "SetEnabled");

	Params::KosmosActorTriggerVolume_SetEnabled Parms{};

	Parms.Enabled = Enabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosActorTriggerVolume.IsActorOverlapping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosActorTriggerVolume::IsActorOverlapping(class AActor* Actor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "IsActorOverlapping");

	Params::KosmosActorTriggerVolume_IsActorOverlapping Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

int32 AKosmosActorTriggerVolume::NumOverlappingActors() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosActorTriggerVolume", "NumOverlappingActors");

	Params::KosmosActorTriggerVolume_NumOverlappingActors Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAerodynamicsComponent.SleepCallback
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              WakingComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAerodynamicsComponent::SleepCallback(class UPrimitiveComponent* WakingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAerodynamicsComponent", "SleepCallback");

	Params::KosmosAerodynamicsComponent_SleepCallback Parms{};

	Parms.WakingComponent = WakingComponent;
	Parms.BoneName = BoneName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAerodynamicsComponent.WakeCallback
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              WakingComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAerodynamicsComponent::WakeCallback(class UPrimitiveComponent* WakingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAerodynamicsComponent", "WakeCallback");

	Params::KosmosAerodynamicsComponent_WakeCallback Parms{};

	Parms.WakingComponent = WakingComponent;
	Parms.BoneName = BoneName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.Cancel
// (Final, Native, Protected, BlueprintCallable)

void UKosmosAIAsyncAction::Cancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "Cancel");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.Failed
// (Final, Native, Protected, BlueprintCallable)

void UKosmosAIAsyncAction::Failed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "Failed");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.InternalRemovePaused
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIAsyncAction::InternalRemovePaused()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "InternalRemovePaused");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.InternalTick
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIAsyncAction::InternalTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "InternalTick");

	Params::KosmosAIAsyncAction_InternalTick Parms{};

	Parms.DeltaTime = DeltaTime;

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


// Function Kosmos.KosmosAIAsyncAction.OnExecuteCommand
// (Event, Protected, BlueprintEvent)

void UKosmosAIAsyncAction::OnExecuteCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "OnExecuteCommand");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAIAsyncAction.OnPauseCommand
// (Event, Protected, BlueprintEvent)

void UKosmosAIAsyncAction::OnPauseCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "OnPauseCommand");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAIAsyncAction.OnResumeCommand
// (Event, Protected, BlueprintEvent)

void UKosmosAIAsyncAction::OnResumeCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "OnResumeCommand");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAIAsyncAction.OnStopCommand
// (Event, Protected, BlueprintEvent)

void UKosmosAIAsyncAction::OnStopCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "OnStopCommand");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAIAsyncAction.StopCommand
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIAsyncAction::StopCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "StopCommand");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.Success
// (Final, Native, Protected, BlueprintCallable)

void UKosmosAIAsyncAction::Success()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "Success");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIAsyncAction.GetActionState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIAsyncActionState                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIAsyncActionState UKosmosAIAsyncAction::GetActionState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "GetActionState");

	Params::KosmosAIAsyncAction_GetActionState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIAsyncAction.GetAiController
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosAIController*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosAIController* UKosmosAIAsyncAction::GetAiController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "GetAiController");

	Params::KosmosAIAsyncAction_GetAiController Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIAsyncAction.GetCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosAIAsyncAction::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIAsyncAction", "GetCharacter");

	Params::KosmosAIAsyncAction_GetCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIActionBoost.OnBoostFinished
// (Final, Native, Public)

void UKosmosAIActionBoost::OnBoostFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionBoost", "OnBoostFinished");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyAllSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyAllSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyAllSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyAntiAliasingTechnique
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyAntiAliasingTechnique()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyAntiAliasingTechnique");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyBackgroundSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyBackgroundSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyBackgroundSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyColourBlindnessMode
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyColourBlindnessMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyColourBlindnessMode");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyDisplaySettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyDisplaySettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyDisplaySettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyGameplaySettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyGameplaySettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyGameplaySettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyGraphicsSettings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::ApplyGraphicsSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyGraphicsSettings");

	Params::KosmosGameUserSettings_ApplyGraphicsSettings Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.ApplyHighlightColours
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyHighlightColours()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyHighlightColours");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyRecommendedHardwareSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyRecommendedHardwareSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyRecommendedHardwareSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyScreenSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyScreenSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyScreenSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyTextSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyTextSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyTextSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyUserSavedGamma
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyUserSavedGamma()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyUserSavedGamma");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyVolumeSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyVolumeSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyVolumeSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.ApplyVSync
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::ApplyVSync()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ApplyVSync");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.GetAudioOutputMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAudioOutputMode                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAudioOutputMode UKosmosGameUserSettings::GetAudioOutputMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetAudioOutputMode");

	Params::KosmosGameUserSettings_GetAudioOutputMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetAvailableDisplays
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class FString>*                  displays                                               (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::GetAvailableDisplays(TArray<class FString>* displays)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetAvailableDisplays");

	Params::KosmosGameUserSettings_GetAvailableDisplays Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetBackgroundAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetBackgroundAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetBackgroundAudioVolume");

	Params::KosmosGameUserSettings_GetBackgroundAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultBeautyMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosGameQualityMode                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGameQualityMode UKosmosGameUserSettings::GetDefaultBeautyMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultBeautyMode");

	Params::KosmosGameUserSettings_GetDefaultBeautyMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultGammaValue
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetDefaultGammaValue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultGammaValue");

	Params::KosmosGameUserSettings_GetDefaultGammaValue Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultGraphicsQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetDefaultGraphicsQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultGraphicsQuality");

	Params::KosmosGameUserSettings_GetDefaultGraphicsQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultMasterAudioVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetDefaultMasterAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultMasterAudioVolume");

	Params::KosmosGameUserSettings_GetDefaultMasterAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultPresetQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosPresetGraphicsQualityLevel       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosPresetGraphicsQualityLevel UKosmosGameUserSettings::GetDefaultPresetQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultPresetQuality");

	Params::KosmosGameUserSettings_GetDefaultPresetQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultSelectedDisplay
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosGameUserSettings::GetDefaultSelectedDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultSelectedDisplay");

	Params::KosmosGameUserSettings_GetDefaultSelectedDisplay Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDesiredDisplay
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosGameUserSettings::GetDesiredDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDesiredDisplay");

	Params::KosmosGameUserSettings_GetDesiredDisplay Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetEngineGamma
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetEngineGamma()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetEngineGamma");

	Params::KosmosGameUserSettings_GetEngineGamma Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetMasterAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetMasterAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetMasterAudioVolume");

	Params::KosmosGameUserSettings_GetMasterAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetOptionSaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FKosmosSaveDataValues            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FKosmosSaveDataValues UKosmosGameUserSettings::GetOptionSaveData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetOptionSaveData");

	Params::KosmosGameUserSettings_GetOptionSaveData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedOptionSaveData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FKosmosSaveDataValues            ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FKosmosSaveDataValues UKosmosGameUserSettings::GetRecommendedOptionSaveData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedOptionSaveData");

	Params::KosmosGameUserSettings_GetRecommendedOptionSaveData Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetSFXAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetSFXAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetSFXAudioVolume");

	Params::KosmosGameUserSettings_GetSFXAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetSupportedScreenResolutions
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class FString>*                  Resolutions                                            (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::GetSupportedScreenResolutions(TArray<class FString>* Resolutions)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetSupportedScreenResolutions");

	Params::KosmosGameUserSettings_GetSupportedScreenResolutions Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetUserSavedGamma
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetUserSavedGamma()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetUserSavedGamma");

	Params::KosmosGameUserSettings_GetUserSavedGamma Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetVoiceAntagonistAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetVoiceAntagonistAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetVoiceAntagonistAudioVolume");

	Params::KosmosGameUserSettings_GetVoiceAntagonistAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetVoiceFriendlyAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetVoiceFriendlyAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetVoiceFriendlyAudioVolume");

	Params::KosmosGameUserSettings_GetVoiceFriendlyAudioVolume Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.IsInBigPictureMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::IsInBigPictureMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "IsInBigPictureMode");

	Params::KosmosGameUserSettings_IsInBigPictureMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.IsRayTracingAvailable
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::IsRayTracingAvailable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "IsRayTracingAvailable");

	Params::KosmosGameUserSettings_IsRayTracingAvailable Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.ResolutionToString
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   resolutionX                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   resolutionY                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosGameUserSettings::ResolutionToString(int32 resolutionX, int32 resolutionY)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ResolutionToString");

	Params::KosmosGameUserSettings_ResolutionToString Parms{};

	Parms.resolutionX = resolutionX;
	Parms.resolutionY = resolutionY;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.ResolutionToText
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   resolutionX                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   resolutionY                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UKosmosGameUserSettings::ResolutionToText(int32 resolutionX, int32 resolutionY)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "ResolutionToText");

	Params::KosmosGameUserSettings_ResolutionToText Parms{};

	Parms.resolutionX = resolutionX;
	Parms.resolutionY = resolutionY;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.RunBenchmarkForRecommendedSettings
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::RunBenchmarkForRecommendedSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "RunBenchmarkForRecommendedSettings");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SaveToConfigFile
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameUserSettings::SaveToConfigFile()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SaveToConfigFile");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetAntiAliasingTechnique
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAntiAliasingTechniques           InTechnique                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetAntiAliasingTechnique(EKosmosAntiAliasingTechniques InTechnique)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetAntiAliasingTechnique");

	Params::KosmosGameUserSettings_SetAntiAliasingTechnique Parms{};

	Parms.InTechnique = InTechnique;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetAudioMix
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAudioMix                         InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetAudioMix(EKosmosAudioMix InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetAudioMix");

	Params::KosmosGameUserSettings_SetAudioMix Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetAudioOutputMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAudioOutputMode                  InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetAudioOutputMode(EKosmosAudioOutputMode InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetAudioOutputMode");

	Params::KosmosGameUserSettings_SetAudioOutputMode Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetBackgroundAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   volumeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetBackgroundAudioVolume(float volumeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetBackgroundAudioVolume");

	Params::KosmosGameUserSettings_SetBackgroundAudioVolume Parms{};

	Parms.volumeValue = volumeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetColourBlindnessMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosColourBlindMode                  InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetColourBlindnessMode(EKosmosColourBlindMode InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetColourBlindnessMode");

	Params::KosmosGameUserSettings_SetColourBlindnessMode Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetControllerVibration
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetControllerVibration(bool InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetControllerVibration");

	Params::KosmosGameUserSettings_SetControllerVibration Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetDefaultSettings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    SaveChanges                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetDefaultSettings(bool SaveChanges)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetDefaultSettings");

	Params::KosmosGameUserSettings_SetDefaultSettings Parms{};

	Parms.SaveChanges = SaveChanges;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetDesiredDisplay
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   displayIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetDesiredDisplay(int32 displayIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetDesiredDisplay");

	Params::KosmosGameUserSettings_SetDesiredDisplay Parms{};

	Parms.displayIndex = displayIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetEnableTutorials
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetEnableTutorials(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetEnableTutorials");

	Params::KosmosGameUserSettings_SetEnableTutorials Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetGameQualityMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGameQualityMode                  inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetGameQualityMode(EKosmosGameQualityMode inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetGameQualityMode");

	Params::KosmosGameUserSettings_SetGameQualityMode Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetGamma
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Gamma                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetGamma(float Gamma)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetGamma");

	Params::KosmosGameUserSettings_SetGamma Parms{};

	Parms.Gamma = Gamma;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_Antagonists
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_Antagonists(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_Antagonists");

	Params::KosmosGameUserSettings_SetHighlightColour_Antagonists Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_Carriables
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_Carriables(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_Carriables");

	Params::KosmosGameUserSettings_SetHighlightColour_Carriables Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_GrabLedges
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_GrabLedges(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_GrabLedges");

	Params::KosmosGameUserSettings_SetHighlightColour_GrabLedges Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_Interactables
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_Interactables(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_Interactables");

	Params::KosmosGameUserSettings_SetHighlightColour_Interactables Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_OtherPlayerCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_OtherPlayerCharacter(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_OtherPlayerCharacter");

	Params::KosmosGameUserSettings_SetHighlightColour_OtherPlayerCharacter Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetHighlightColour_PlayerCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAccessibilityColours             InSetting                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetHighlightColour_PlayerCharacter(EKosmosAccessibilityColours InSetting)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetHighlightColour_PlayerCharacter");

	Params::KosmosGameUserSettings_SetHighlightColour_PlayerCharacter Parms{};

	Parms.InSetting = InSetting;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetInvertLookVertAxis
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetInvertLookVertAxis(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetInvertLookVertAxis");

	Params::KosmosGameUserSettings_SetInvertLookVertAxis Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetInvertMoveVertAxis
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetInvertMoveVertAxis(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetInvertMoveVertAxis");

	Params::KosmosGameUserSettings_SetInvertMoveVertAxis Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosAmbientOcclusionQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosAmbientOcclusionQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosAmbientOcclusionQuality");

	Params::KosmosGameUserSettings_SetKosmosAmbientOcclusionQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosAntiAliasingQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosAntiAliasingQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosAntiAliasingQuality");

	Params::KosmosGameUserSettings_SetKosmosAntiAliasingQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosBloomQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosBloomQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosBloomQuality");

	Params::KosmosGameUserSettings_SetKosmosBloomQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosDepthOfFieldQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosDepthOfFieldQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosDepthOfFieldQuality");

	Params::KosmosGameUserSettings_SetKosmosDepthOfFieldQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosEffectsQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosEffectsQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosEffectsQuality");

	Params::KosmosGameUserSettings_SetKosmosEffectsQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosFrameRateLimit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InFrameRateLimit                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosFrameRateLimit(float InFrameRateLimit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosFrameRateLimit");

	Params::KosmosGameUserSettings_SetKosmosFrameRateLimit Parms{};

	Parms.InFrameRateLimit = InFrameRateLimit;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosPostProcessingQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosPostProcessingQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosPostProcessingQuality");

	Params::KosmosGameUserSettings_SetKosmosPostProcessingQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosRayTracingQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosRayTracingQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosRayTracingQuality");

	Params::KosmosGameUserSettings_SetKosmosRayTracingQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosShadowQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosShadowQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosShadowQuality");

	Params::KosmosGameUserSettings_SetKosmosShadowQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosTextureQuality
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGraphicsQualityLevel             QualityLevel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosTextureQuality(EKosmosGraphicsQualityLevel QualityLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosTextureQuality");

	Params::KosmosGameUserSettings_SetKosmosTextureQuality Parms{};

	Parms.QualityLevel = QualityLevel;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetKosmosVSync
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bVSyncEnabled                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetKosmosVSync(bool bVSyncEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetKosmosVSync");

	Params::KosmosGameUserSettings_SetKosmosVSync Parms{};

	Parms.bVSyncEnabled = bVSyncEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetLookSensitivity
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetLookSensitivity(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetLookSensitivity");

	Params::KosmosGameUserSettings_SetLookSensitivity Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetMasterAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   volumeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetMasterAudioVolume(float volumeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetMasterAudioVolume");

	Params::KosmosGameUserSettings_SetMasterAudioVolume Parms{};

	Parms.volumeValue = volumeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetNewUserFrontendTitleSettings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetNewUserFrontendTitleSettings(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetNewUserFrontendTitleSettings");

	Params::KosmosGameUserSettings_SetNewUserFrontendTitleSettings Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetObjectiveHintMarkers
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetObjectiveHintMarkers(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetObjectiveHintMarkers");

	Params::KosmosGameUserSettings_SetObjectiveHintMarkers Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetOffScreenIndicator
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetOffScreenIndicator(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetOffScreenIndicator");

	Params::KosmosGameUserSettings_SetOffScreenIndicator Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetOptionSaveData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosSaveDataValues&     InOptionSaveData                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetOptionSaveData(const struct FKosmosSaveDataValues& InOptionSaveData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetOptionSaveData");

	Params::KosmosGameUserSettings_SetOptionSaveData Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetOptionsLanguage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Language                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetOptionsLanguage(const class FString& Language)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetOptionsLanguage");

	Params::KosmosGameUserSettings_SetOptionsLanguage Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetResolution
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   Width                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetResolution(int32 Width, int32 Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetResolution");

	Params::KosmosGameUserSettings_SetResolution Parms{};

	Parms.Width = Width;
	Parms.Height = Height;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetResolutionScaling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetResolutionScaling(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetResolutionScaling");

	Params::KosmosGameUserSettings_SetResolutionScaling Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetSFXAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   volumeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetSFXAudioVolume(float volumeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetSFXAudioVolume");

	Params::KosmosGameUserSettings_SetSFXAudioVolume Parms{};

	Parms.volumeValue = volumeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetShouldCameraShake
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetShouldCameraShake(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetShouldCameraShake");

	Params::KosmosGameUserSettings_SetShouldCameraShake Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetSwapAxisSticks
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetSwapAxisSticks(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetSwapAxisSticks");

	Params::KosmosGameUserSettings_SetSwapAxisSticks Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextBackgroundAlpha_InGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextBackgroundAlpha_InGame(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextBackgroundAlpha_InGame");

	Params::KosmosGameUserSettings_SetTextBackgroundAlpha_InGame Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextBackgroundAlpha_Menu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextBackgroundAlpha_Menu(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextBackgroundAlpha_Menu");

	Params::KosmosGameUserSettings_SetTextBackgroundAlpha_Menu Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextBackgroundColour_InGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosTextColours                      inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextBackgroundColour_InGame(EKosmosTextColours inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextBackgroundColour_InGame");

	Params::KosmosGameUserSettings_SetTextBackgroundColour_InGame Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextBackgroundColour_Menu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosTextColours                      inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextBackgroundColour_Menu(EKosmosTextColours inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextBackgroundColour_Menu");

	Params::KosmosGameUserSettings_SetTextBackgroundColour_Menu Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextColour_InGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosTextColours                      inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextColour_InGame(EKosmosTextColours inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextColour_InGame");

	Params::KosmosGameUserSettings_SetTextColour_InGame Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextColour_Menu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosTextColours                      inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextColour_Menu(EKosmosTextColours inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextColour_Menu");

	Params::KosmosGameUserSettings_SetTextColour_Menu Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextScale_InGame
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextScale_InGame(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextScale_InGame");

	Params::KosmosGameUserSettings_SetTextScale_InGame Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextScale_Menu
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextScale_Menu(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextScale_Menu");

	Params::KosmosGameUserSettings_SetTextScale_Menu Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextToSpeech
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextToSpeech(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextToSpeech");

	Params::KosmosGameUserSettings_SetTextToSpeech Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetTextUseDyslexicFont
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetTextUseDyslexicFont(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetTextUseDyslexicFont");

	Params::KosmosGameUserSettings_SetTextUseDyslexicFont Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetToggleNoHold
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetToggleNoHold(bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetToggleNoHold");

	Params::KosmosGameUserSettings_SetToggleNoHold Parms{};

	Parms.inValue = inValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetVoiceAntagonistAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   volumeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetVoiceAntagonistAudioVolume(float volumeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetVoiceAntagonistAudioVolume");

	Params::KosmosGameUserSettings_SetVoiceAntagonistAudioVolume Parms{};

	Parms.volumeValue = volumeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetVoiceFriendlyAudioVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   volumeValue                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetVoiceFriendlyAudioVolume(float volumeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetVoiceFriendlyAudioVolume");

	Params::KosmosGameUserSettings_SetVoiceFriendlyAudioVolume Parms{};

	Parms.volumeValue = volumeValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.SetWindowMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWindowMode                             WindowMode                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameUserSettings::SetWindowMode(EWindowMode WindowMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "SetWindowMode");

	Params::KosmosGameUserSettings_SetWindowMode Parms{};

	Parms.WindowMode = WindowMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettings.StringToResolution
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    resolutionString                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FIntPoint                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FIntPoint UKosmosGameUserSettings::StringToResolution(const class FString& resolutionString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "StringToResolution");

	Params::KosmosGameUserSettings_StringToResolution Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.AreSettingsDifferent
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKosmosSaveDataValues&     InOptionSaveData                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameUserSettings::AreSettingsDifferent(const struct FKosmosSaveDataValues& InOptionSaveData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "AreSettingsDifferent");

	Params::KosmosGameUserSettings_AreSettingsDifferent Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetAntiAliasingTechnique
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAntiAliasingTechniques           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAntiAliasingTechniques UKosmosGameUserSettings::GetAntiAliasingTechnique() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetAntiAliasingTechnique");

	Params::KosmosGameUserSettings_GetAntiAliasingTechnique Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetAudioMix
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAudioMix                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAudioMix UKosmosGameUserSettings::GetAudioMix() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetAudioMix");

	Params::KosmosGameUserSettings_GetAudioMix Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetColourBlindnessMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosColourBlindMode                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosColourBlindMode UKosmosGameUserSettings::GetColourBlindnessMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetColourBlindnessMode");

	Params::KosmosGameUserSettings_GetColourBlindnessMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetControllerVibration() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetControllerVibration");

	Params::KosmosGameUserSettings_GetControllerVibration Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultAntiAliasingTechnique
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAntiAliasingTechniques           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAntiAliasingTechniques UKosmosGameUserSettings::GetDefaultAntiAliasingTechnique() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultAntiAliasingTechnique");

	Params::KosmosGameUserSettings_GetDefaultAntiAliasingTechnique Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetDefaultResolutionScaling
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetDefaultResolutionScaling() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetDefaultResolutionScaling");

	Params::KosmosGameUserSettings_GetDefaultResolutionScaling Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetEnableTutorials() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetEnableTutorials");

	Params::KosmosGameUserSettings_GetEnableTutorials Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetGameQualityMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGameQualityMode                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGameQualityMode UKosmosGameUserSettings::GetGameQualityMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetGameQualityMode");

	Params::KosmosGameUserSettings_GetGameQualityMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_Antagonists
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_Antagonists() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_Antagonists");

	Params::KosmosGameUserSettings_GetHighlightColour_Antagonists Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_Carriables
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_Carriables() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_Carriables");

	Params::KosmosGameUserSettings_GetHighlightColour_Carriables Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_GrabLedges
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_GrabLedges() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_GrabLedges");

	Params::KosmosGameUserSettings_GetHighlightColour_GrabLedges Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_Interactables
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_Interactables() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_Interactables");

	Params::KosmosGameUserSettings_GetHighlightColour_Interactables Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_OtherPlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_OtherPlayerCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_OtherPlayerCharacter");

	Params::KosmosGameUserSettings_GetHighlightColour_OtherPlayerCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetHighlightColour_PlayerCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAccessibilityColours UKosmosGameUserSettings::GetHighlightColour_PlayerCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetHighlightColour_PlayerCharacter");

	Params::KosmosGameUserSettings_GetHighlightColour_PlayerCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetInvertLookVertAxis() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetInvertLookVertAxis");

	Params::KosmosGameUserSettings_GetInvertLookVertAxis Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetInvertMoveVertAxis() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetInvertMoveVertAxis");

	Params::KosmosGameUserSettings_GetInvertMoveVertAxis Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosAmbientOcclusionQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosAmbientOcclusionQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosAmbientOcclusionQuality");

	Params::KosmosGameUserSettings_GetKosmosAmbientOcclusionQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosAntiAliasingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosAntiAliasingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosAntiAliasingQuality");

	Params::KosmosGameUserSettings_GetKosmosAntiAliasingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosBloomQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosBloomQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosBloomQuality");

	Params::KosmosGameUserSettings_GetKosmosBloomQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosDepthOfFieldQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosDepthOfFieldQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosDepthOfFieldQuality");

	Params::KosmosGameUserSettings_GetKosmosDepthOfFieldQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosEffectsQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosEffectsQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosEffectsQuality");

	Params::KosmosGameUserSettings_GetKosmosEffectsQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosFrameRateLimit
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetKosmosFrameRateLimit() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosFrameRateLimit");

	Params::KosmosGameUserSettings_GetKosmosFrameRateLimit Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosPostProcessingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosPostProcessingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosPostProcessingQuality");

	Params::KosmosGameUserSettings_GetKosmosPostProcessingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosRayTracingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosRayTracingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosRayTracingQuality");

	Params::KosmosGameUserSettings_GetKosmosRayTracingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosShadowQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosShadowQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosShadowQuality");

	Params::KosmosGameUserSettings_GetKosmosShadowQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetKosmosTextureQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetKosmosTextureQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosTextureQuality");

	Params::KosmosGameUserSettings_GetKosmosTextureQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetKosmosVSync() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetKosmosVSync");

	Params::KosmosGameUserSettings_GetKosmosVSync Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetLookSensitivity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetLookSensitivity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetLookSensitivity");

	Params::KosmosGameUserSettings_GetLookSensitivity Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetMatchingAccessibilityColour
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAccessibilityColours             InColour                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor UKosmosGameUserSettings::GetMatchingAccessibilityColour(EKosmosAccessibilityColours InColour) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetMatchingAccessibilityColour");

	Params::KosmosGameUserSettings_GetMatchingAccessibilityColour Parms{};

	Parms.InColour = InColour;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetMatchingKosmosTextColours
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EKosmosTextColours                InColour                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FLinearColor                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FLinearColor UKosmosGameUserSettings::GetMatchingKosmosTextColours(const EKosmosTextColours InColour) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetMatchingKosmosTextColours");

	Params::KosmosGameUserSettings_GetMatchingKosmosTextColours Parms{};

	Parms.InColour = InColour;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetObjectiveHintMarkers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetObjectiveHintMarkers");

	Params::KosmosGameUserSettings_GetObjectiveHintMarkers Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetOffScreenIndicator() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetOffScreenIndicator");

	Params::KosmosGameUserSettings_GetOffScreenIndicator Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosAmbientOcclusionQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosAmbientOcclusionQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosAmbientOcclusionQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosAmbientOcclusionQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosAntiAliasingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosAntiAliasingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosAntiAliasingQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosAntiAliasingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosBloomQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosBloomQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosBloomQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosBloomQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosDepthOfFieldQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosDepthOfFieldQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosDepthOfFieldQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosDepthOfFieldQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosEffectsQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosEffectsQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosEffectsQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosEffectsQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosPostProcessingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosPostProcessingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosPostProcessingQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosPostProcessingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosRayTracingQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosRayTracingQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosRayTracingQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosRayTracingQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosShadowQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosShadowQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosShadowQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosShadowQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedKosmosTextureQuality
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGraphicsQualityLevel             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGraphicsQualityLevel UKosmosGameUserSettings::GetRecommendedKosmosTextureQuality() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedKosmosTextureQuality");

	Params::KosmosGameUserSettings_GetRecommendedKosmosTextureQuality Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetRecommendedResolutionScaling
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetRecommendedResolutionScaling() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetRecommendedResolutionScaling");

	Params::KosmosGameUserSettings_GetRecommendedResolutionScaling Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetResolutionScaling
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetResolutionScaling() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetResolutionScaling");

	Params::KosmosGameUserSettings_GetResolutionScaling Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetShouldCameraShake() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetShouldCameraShake");

	Params::KosmosGameUserSettings_GetShouldCameraShake Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetSwapAxisSticks() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetSwapAxisSticks");

	Params::KosmosGameUserSettings_GetSwapAxisSticks Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextBackgroundAlpha_InGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetTextBackgroundAlpha_InGame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextBackgroundAlpha_InGame");

	Params::KosmosGameUserSettings_GetTextBackgroundAlpha_InGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextBackgroundAlpha_Menu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetTextBackgroundAlpha_Menu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextBackgroundAlpha_Menu");

	Params::KosmosGameUserSettings_GetTextBackgroundAlpha_Menu Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextBackgroundColour_InGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosTextColours                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosTextColours UKosmosGameUserSettings::GetTextBackgroundColour_InGame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextBackgroundColour_InGame");

	Params::KosmosGameUserSettings_GetTextBackgroundColour_InGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextBackgroundColour_Menu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosTextColours                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosTextColours UKosmosGameUserSettings::GetTextBackgroundColour_Menu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextBackgroundColour_Menu");

	Params::KosmosGameUserSettings_GetTextBackgroundColour_Menu Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextColour_InGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosTextColours                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosTextColours UKosmosGameUserSettings::GetTextColour_InGame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextColour_InGame");

	Params::KosmosGameUserSettings_GetTextColour_InGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextColour_Menu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosTextColours                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosTextColours UKosmosGameUserSettings::GetTextColour_Menu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextColour_Menu");

	Params::KosmosGameUserSettings_GetTextColour_Menu Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextScale_InGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetTextScale_InGame() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextScale_InGame");

	Params::KosmosGameUserSettings_GetTextScale_InGame Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextScale_Menu
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetTextScale_Menu() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextScale_Menu");

	Params::KosmosGameUserSettings_GetTextScale_Menu Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextScaleFromIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const int32                             Index_0                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosGameUserSettings::GetTextScaleFromIndex(const int32 Index_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextScaleFromIndex");

	Params::KosmosGameUserSettings_GetTextScaleFromIndex Parms{};

	Parms.Index_0 = Index_0;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetTextScaleIndexFromScale
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const float                             Scale                                                  (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosGameUserSettings::GetTextScaleIndexFromScale(const float Scale) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextScaleIndexFromScale");

	Params::KosmosGameUserSettings_GetTextScaleIndexFromScale Parms{};

	Parms.Scale = Scale;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetTextToSpeech() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextToSpeech");

	Params::KosmosGameUserSettings_GetTextToSpeech Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetTextUseDyslexicFont() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetTextUseDyslexicFont");

	Params::KosmosGameUserSettings_GetTextUseDyslexicFont Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::GetToggleNoHold() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetToggleNoHold");

	Params::KosmosGameUserSettings_GetToggleNoHold Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameUserSettings.GetWindowMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EWindowMode                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWindowMode UKosmosGameUserSettings::GetWindowMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "GetWindowMode");

	Params::KosmosGameUserSettings_GetWindowMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::HasAppliedFirstTimeDefaultSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "HasAppliedFirstTimeDefaultSettings");

	Params::KosmosGameUserSettings_HasAppliedFirstTimeDefaultSettings Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::HasSetNewUserFrontendTitleSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "HasSetNewUserFrontendTitleSettings");

	Params::KosmosGameUserSettings_HasSetNewUserFrontendTitleSettings Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosGameUserSettings::HaveGraphicsHardwareChanged() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameUserSettings", "HaveGraphicsHardwareChanged");

	Params::KosmosGameUserSettings_HaveGraphicsHardwareChanged Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIActionCrank.StartCranking
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIActionCrank::StartCranking()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionCrank", "StartCranking");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandsBase.EndPausedActions
// (Final, Native, Public, BlueprintCallable)

void UKosmosPlaypalCommandsBase::EndPausedActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalCommandsBase", "EndPausedActions");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandsBase.GetAiController
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosAIController*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosAIController* UKosmosPlaypalCommandsBase::GetAiController() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalCommandsBase", "GetAiController");

	Params::KosmosPlaypalCommandsBase_GetAiController Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsBase.GetCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosPlaypalCommandsBase::GetCharacter() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalCommandsBase", "GetCharacter");

	Params::KosmosPlaypalCommandsBase_GetCharacter Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalFollowPath
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<struct FVector>&           PathPoints                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   SuccessRadius                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalFollowPath(class UObject* WorldContextObject, const TArray<struct FVector>& PathPoints, float SuccessRadius, float GoalRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalFollowPath");

	Params::KosmosPlaypalCommandsCore_PlaypalFollowPath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PathPoints = std::move(PathPoints);
	Parms.SuccessRadius = SuccessRadius;
	Parms.GoalRadius = GoalRadius;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalFollowSpline
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosPlaypalSplinePath*         SplinePath                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalFollowSpline(class UObject* WorldContextObject, class AKosmosPlaypalSplinePath* SplinePath)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalFollowSpline");

	Params::KosmosPlaypalCommandsCore_PlaypalFollowSpline Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SplinePath = SplinePath;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalGesture
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToFace                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosGestureOverrideDataAsset*  GestureOverride                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalGesture(class UObject* WorldContextObject, class AActor* ActorToFace, class UKosmosGestureOverrideDataAsset* GestureOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalGesture");

	Params::KosmosPlaypalCommandsCore_PlaypalGesture Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorToFace = ActorToFace;
	Parms.GestureOverride = GestureOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalJump
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToStandOn                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StandLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsShortJump                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalJump(class UObject* WorldContextObject, class AActor* ActorToStandOn, const struct FVector& StandLocation, bool IsShortJump)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalJump");

	Params::KosmosPlaypalCommandsCore_PlaypalJump Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorToStandOn = ActorToStandOn;
	Parms.StandLocation = std::move(StandLocation);
	Parms.IsShortJump = IsShortJump;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalJumpAndGrab
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           JumpFromActor                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StandLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GrabHoldTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    JumpAtEnd                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           EndJumpTargetActor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalJumpAndGrab(class UObject* WorldContextObject, class AActor* JumpFromActor, const struct FVector& StandLocation, class AActor* TargetActor, float GrabHoldTime, bool JumpAtEnd, class AActor* EndJumpTargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalJumpAndGrab");

	Params::KosmosPlaypalCommandsCore_PlaypalJumpAndGrab Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.JumpFromActor = JumpFromActor;
	Parms.StandLocation = std::move(StandLocation);
	Parms.TargetActor = TargetActor;
	Parms.GrabHoldTime = GrabHoldTime;
	Parms.JumpAtEnd = JumpAtEnd;
	Parms.EndJumpTargetActor = EndJumpTargetActor;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalLeadTo
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToReach                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   WaitDistance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   LeadDistance                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeBetweenGestures                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosMovementSettingValueAsset* OverrideMovementSpeeds                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalLeadTo(class UObject* WorldContextObject, class AActor* ActorToReach, float GoalRadius, float WaitDistance, float LeadDistance, float TimeBetweenGestures, class UKosmosMovementSettingValueAsset* OverrideMovementSpeeds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalLeadTo");

	Params::KosmosPlaypalCommandsCore_PlaypalLeadTo Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorToReach = ActorToReach;
	Parms.GoalRadius = GoalRadius;
	Parms.WaitDistance = WaitDistance;
	Parms.LeadDistance = LeadDistance;
	Parms.TimeBetweenGestures = TimeBetweenGestures;
	Parms.OverrideMovementSpeeds = OverrideMovementSpeeds;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalMoveTo
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldAlwaysRun                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToReach                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MoveToLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SuccessRadius                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToFace                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DirectionToFace                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosMovementSettingValueAsset* OverrideMovementSpeeds                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalMoveTo(class UObject* WorldContextObject, bool bShouldAlwaysRun, class AActor* ActorToReach, const struct FVector& MoveToLocation, float SuccessRadius, float GoalRadius, class AActor* ActorToFace, const struct FVector& DirectionToFace, class UKosmosMovementSettingValueAsset* OverrideMovementSpeeds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalMoveTo");

	Params::KosmosPlaypalCommandsCore_PlaypalMoveTo Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bShouldAlwaysRun = bShouldAlwaysRun;
	Parms.ActorToReach = ActorToReach;
	Parms.MoveToLocation = std::move(MoveToLocation);
	Parms.SuccessRadius = SuccessRadius;
	Parms.GoalRadius = GoalRadius;
	Parms.ActorToFace = ActorToFace;
	Parms.DirectionToFace = std::move(DirectionToFace);
	Parms.OverrideMovementSpeeds = OverrideMovementSpeeds;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalMoveToVolume
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldAlwaysRun                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosPlaypalMoveToVolume*       Volume                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalMoveToVolume(class UObject* WorldContextObject, bool bShouldAlwaysRun, class AKosmosPlaypalMoveToVolume* Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalMoveToVolume");

	Params::KosmosPlaypalCommandsCore_PlaypalMoveToVolume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bShouldAlwaysRun = bShouldAlwaysRun;
	Parms.Volume = Volume;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalPIP
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosPlaypalInteractionPoint*   PIP                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalPIP(class UObject* WorldContextObject, class AKosmosPlaypalInteractionPoint* PIP)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalPIP");

	Params::KosmosPlaypalCommandsCore_PlaypalPIP Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PIP = PIP;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalPlayMontage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             SectionName                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   CancelBlendOutTime                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalPlayMontage(class UObject* WorldContextObject, class UAnimMontage* MontageToPlay, class FName SectionName, float CancelBlendOutTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalPlayMontage");

	Params::KosmosPlaypalCommandsCore_PlaypalPlayMontage Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.MontageToPlay = MontageToPlay;
	Parms.SectionName = SectionName;
	Parms.CancelBlendOutTime = CancelBlendOutTime;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCore.PlaypalWait
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeToWait                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldGesture                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector2D&                 TimeBetweenGestures                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldDisableHandholding                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToFace                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UCharacterAnimationSlots*         AnimOverride                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCore*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCore* UKosmosPlaypalCommandsCore::PlaypalWait(class UObject* WorldContextObject, float TimeToWait, bool bShouldGesture, const struct FVector2D& TimeBetweenGestures, bool bShouldDisableHandholding, class AActor* ActorToFace, class UCharacterAnimationSlots* AnimOverride)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCore", "PlaypalWait");

	Params::KosmosPlaypalCommandsCore_PlaypalWait Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TimeToWait = TimeToWait;
	Parms.bShouldGesture = bShouldGesture;
	Parms.TimeBetweenGestures = std::move(TimeBetweenGestures);
	Parms.bShouldDisableHandholding = bShouldDisableHandholding;
	Parms.ActorToFace = ActorToFace;
	Parms.AnimOverride = AnimOverride;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGestureComponent.ClearGestureOverrider
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosGestureOverrideVolume*     Overrider                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGestureComponent::ClearGestureOverrider(class AKosmosGestureOverrideVolume* Overrider)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "ClearGestureOverrider");

	Params::KosmosGestureComponent_ClearGestureOverrider Parms{};

	Parms.Overrider = Overrider;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.Internal_OnGestureTriggered
// (Final, Native, Private)

void UKosmosGestureComponent::Internal_OnGestureTriggered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "Internal_OnGestureTriggered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.Multicast_OnGestureTriggered
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UKosmosGestureComponent::Multicast_OnGestureTriggered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "Multicast_OnGestureTriggered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.OnAnimationStateFinished
// (Native, Public, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosGestureComponent::OnAnimationStateFinished(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "OnAnimationStateFinished");

	Params::KosmosGestureComponent_OnAnimationStateFinished Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.OnGestureChanged
// (Final, Native, Protected)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGestureComponent::OnGestureChanged(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "OnGestureChanged");

	Params::KosmosGestureComponent_OnGestureChanged Parms{};

	Parms.bValue = bValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.OnGestureTriggered
// (Final, Native, Private)

void UKosmosGestureComponent::OnGestureTriggered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "OnGestureTriggered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.Server_OnGestureTriggered
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UKosmosGestureComponent::Server_OnGestureTriggered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "Server_OnGestureTriggered");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.SetGestureOverrider
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosGestureOverrideVolume*     Overrider                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGestureComponent::SetGestureOverrider(class AKosmosGestureOverrideVolume* Overrider)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "SetGestureOverrider");

	Params::KosmosGestureComponent_SetGestureOverrider Parms{};

	Parms.Overrider = Overrider;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.StopGesturing
// (Final, Native, Public, BlueprintCallable)

void UKosmosGestureComponent::StopGesturing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "StopGesturing");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGestureComponent.TryStartGesturing
// (Final, Native, Public, BlueprintCallable)

void UKosmosGestureComponent::TryStartGesturing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGestureComponent", "TryStartGesturing");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.ChangeTargetLocation
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionMoveTo::ChangeTargetLocation(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "ChangeTargetLocation");

	Params::KosmosAIActionMoveTo_ChangeTargetLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.ClearMaxSpeedOverride
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIActionMoveTo::ClearMaxSpeedOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "ClearMaxSpeedOverride");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.IsPlaypalNavLinkActive
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosAIActionMoveTo::IsPlaypalNavLinkActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "IsPlaypalNavLinkActive");

	Params::KosmosAIActionMoveTo_IsPlaypalNavLinkActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIActionMoveTo.OverrideMaxSpeed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   NewMaxSpeed                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSprint                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionMoveTo::OverrideMaxSpeed(float NewMaxSpeed, bool bSprint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "OverrideMaxSpeed");

	Params::KosmosAIActionMoveTo_OverrideMaxSpeed Parms{};

	Parms.NewMaxSpeed = NewMaxSpeed;
	Parms.bSprint = bSprint;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.RefreshNavLinkPoints
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   LinkPointA                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LinkPointB                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionMoveTo::RefreshNavLinkPoints(const struct FVector& LinkPointA, const struct FVector& LinkPointB)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "RefreshNavLinkPoints");

	Params::KosmosAIActionMoveTo_RefreshNavLinkPoints Parms{};

	Parms.LinkPointA = std::move(LinkPointA);
	Parms.LinkPointB = std::move(LinkPointB);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.SetMoveToInteractable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           Interactable                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionMoveTo::SetMoveToInteractable(class AActor* Interactable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "SetMoveToInteractable");

	Params::KosmosAIActionMoveTo_SetMoveToInteractable Parms{};

	Parms.Interactable = Interactable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.SetMoveToVolume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosPlaypalMoveToVolume*       InMoveToVolume                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionMoveTo::SetMoveToVolume(class AKosmosPlaypalMoveToVolume* InMoveToVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "SetMoveToVolume");

	Params::KosmosAIActionMoveTo_SetMoveToVolume Parms{};

	Parms.InMoveToVolume = InMoveToVolume;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionMoveTo.UpdateMoveToTarget
// (Native, Protected, BlueprintCallable)

void UKosmosAIActionMoveTo::UpdateMoveToTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMoveTo", "UpdateMoveToTarget");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionFollowPath.UpdatePath
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FVector>&           Points                                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosAIActionFollowPath::UpdatePath(const TArray<struct FVector>& Points)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionFollowPath", "UpdatePath");

	Params::KosmosAIActionFollowPath_UpdatePath Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForCapstan
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InEndValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InHoldTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    WaitForWeaponEquip                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForCapstan(class AKosmosEnvironmentInteractable* InInteractable, float InEndValue, float InHoldTime, bool WaitForWeaponEquip)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForCapstan");

	Params::KosmosAIActionInteract_InitializeForCapstan Parms{};

	Parms.InInteractable = InInteractable;
	Parms.InEndValue = InEndValue;
	Parms.InHoldTime = InHoldTime;
	Parms.WaitForWeaponEquip = WaitForWeaponEquip;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForConstrainedBox
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgress                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForConstrainedBox(class AKosmosEnvironmentInteractable* InInteractable, float TargetProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForConstrainedBox");

	Params::KosmosAIActionInteract_InitializeForConstrainedBox Parms{};

	Parms.InInteractable = InInteractable;
	Parms.TargetProgress = TargetProgress;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForLargeLever
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InEndValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InHoldTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForLargeLever(class AKosmosEnvironmentInteractable* InInteractable, float InEndValue, float InHoldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForLargeLever");

	Params::KosmosAIActionInteract_InitializeForLargeLever Parms{};

	Parms.InInteractable = InInteractable;
	Parms.InEndValue = InEndValue;
	Parms.InHoldTime = InHoldTime;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForPullObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgress                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForPullObject(class AKosmosEnvironmentInteractable* InInteractable, float TargetProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForPullObject");

	Params::KosmosAIActionInteract_InitializeForPullObject Parms{};

	Parms.InInteractable = InInteractable;
	Parms.TargetProgress = TargetProgress;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForPushObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgress                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForPushObject(class AKosmosEnvironmentInteractable* InInteractable, float TargetProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForPushObject");

	Params::KosmosAIActionInteract_InitializeForPushObject Parms{};

	Parms.InInteractable = InInteractable;
	Parms.TargetProgress = TargetProgress;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForPushPullFreeDraggable
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AKosmosDraggable*                 InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ErrorTolerance                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForPushPullFreeDraggable(class AKosmosDraggable* InInteractable, const struct FVector& TargetLocation, float ErrorTolerance)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForPushPullFreeDraggable");

	Params::KosmosAIActionInteract_InitializeForPushPullFreeDraggable Parms{};

	Parms.InInteractable = InInteractable;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.ErrorTolerance = ErrorTolerance;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.InitializeForPushPullTogather
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InInteractable                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InEndValue                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::InitializeForPushPullTogather(class AKosmosEnvironmentInteractable* InInteractable, float InEndValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "InitializeForPushPullTogather");

	Params::KosmosAIActionInteract_InitializeForPushPullTogather Parms{};

	Parms.InInteractable = InInteractable;
	Parms.InEndValue = InEndValue;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.RequestEndAction
// (Final, Native, Protected, BlueprintCallable)

void UKosmosAIActionInteract::RequestEndAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "RequestEndAction");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.StartAIInteract
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InitialValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   RateOfChange                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::StartAIInteract(float InitialValue, float RateOfChange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "StartAIInteract");

	Params::KosmosAIActionInteract_StartAIInteract Parms{};

	Parms.InitialValue = InitialValue;
	Parms.RateOfChange = RateOfChange;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteract.StartAIInteractConstrainedBox
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// float                                   InitialValue                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxEndLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   BoxStartLocation                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFreeMovement                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAIActionInteract::StartAIInteractConstrainedBox(float InitialValue, const struct FVector& BoxEndLocation, const struct FVector& BoxStartLocation, bool bFreeMovement)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteract", "StartAIInteractConstrainedBox");

	Params::KosmosAIActionInteract_StartAIInteractConstrainedBox Parms{};

	Parms.InitialValue = InitialValue;
	Parms.BoxEndLocation = std::move(BoxEndLocation);
	Parms.BoxStartLocation = std::move(BoxStartLocation);
	Parms.bFreeMovement = bFreeMovement;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerState.OnRep_PauseManagementComponent
// (Final, Native, Protected)

void AKosmosPlayerState::OnRep_PauseManagementComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerState", "OnRep_PauseManagementComponent");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerState.SmgDebugCmd
// (Exec, Native, Protected)
// Parameters:
// const class FString&                    InCmdStr                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerState::SmgDebugCmd(const class FString& InCmdStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerState", "SmgDebugCmd");

	Params::KosmosPlayerState_SmgDebugCmd Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerState.SmgDebugCmdClient
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const class FString&                    InCmdStr                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerState::SmgDebugCmdClient(const class FString& InCmdStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerState", "SmgDebugCmdClient");

	Params::KosmosPlayerState_SmgDebugCmdClient Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerState.SmgDebugCmdLocal
// (Exec, Native, Protected)
// Parameters:
// const class FString&                    InCmdStr                                               (ConstParm, Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerState::SmgDebugCmdLocal(const class FString& InCmdStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerState", "SmgDebugCmdLocal");

	Params::KosmosPlayerState_SmgDebugCmdLocal Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerState.SmgDebugCmdServer
// (Net, NetReliable, Native, Event, Protected, NetServer, NetValidate)
// Parameters:
// const class FString&                    InCmdStr                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerState::SmgDebugCmdServer(const class FString& InCmdStr)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerState", "SmgDebugCmdServer");

	Params::KosmosPlayerState_SmgDebugCmdServer Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionInteractionPoint.PIPEnded
// (Final, Native, Private)

void UKosmosAIActionInteractionPoint::PIPEnded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionInteractionPoint", "PIPEnded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.ActivateControl
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::ActivateControl(class AKosmosBaseCharacter* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "ActivateControl");

	Params::KosmosEnvironmentInteractable_ActivateControl Parms{};

	Parms.InActor = InActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.CanGrab
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::CanGrab(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "CanGrab");

	Params::KosmosEnvironmentInteractable_CanGrab Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.ClearFocus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Char                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::ClearFocus(class AKosmosBaseCharacter* Char)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "ClearFocus");

	Params::KosmosEnvironmentInteractable_ClearFocus Parms{};

	Parms.Char = Char;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.Client_SetEnabled
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::Client_SetEnabled(bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "Client_SetEnabled");

	Params::KosmosEnvironmentInteractable_Client_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.DisableGrabHelpers
// (Final, Native, Public, BlueprintCallable)

void AKosmosEnvironmentInteractable::DisableGrabHelpers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "DisableGrabHelpers");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.DisableObject
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosEnvironmentInteractable::DisableObject()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "DisableObject");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.EnableObject
// (Final, Native, Public, BlueprintCallable)

void AKosmosEnvironmentInteractable::EnableObject()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "EnableObject");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetClosestGrabHelperStandPosition
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   FootLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosEnvironmentInteractable::GetClosestGrabHelperStandPosition(const struct FVector& FootLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetClosestGrabHelperStandPosition");

	Params::KosmosEnvironmentInteractable_GetClosestGrabHelperStandPosition Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetClosestLocationInfo
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outForward                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::GetClosestLocationInfo(const struct FVector& TargetLocation, struct FVector* OutLocation, struct FVector* outForward)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetClosestLocationInfo");

	Params::KosmosEnvironmentInteractable_GetClosestLocationInfo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetCurrentControllingActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* AKosmosEnvironmentInteractable::GetCurrentControllingActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetCurrentControllingActor");

	Params::KosmosEnvironmentInteractable_GetCurrentControllingActor Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetFinalStandDirection
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosEnvironmentInteractable::GetFinalStandDirection(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetFinalStandDirection");

	Params::KosmosEnvironmentInteractable_GetFinalStandDirection Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetFinalStandLocation
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosEnvironmentInteractable::GetFinalStandLocation(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetFinalStandLocation");

	Params::KosmosEnvironmentInteractable_GetFinalStandLocation Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetInteractRepulsion
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             Char                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         Offset                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  Scale                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::GetInteractRepulsion(class AKosmosBaseCharacter* Char, struct FVector* Offset, float* Scale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetInteractRepulsion");

	Params::KosmosEnvironmentInteractable_GetInteractRepulsion Parms{};

	Parms.Char = Char;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetPlaypalAvoidanceInfo
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintEvent)
// Parameters:
// bool*                                   bShouldAvoid                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         AvoidCenter                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   AvoidRadius                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::GetPlaypalAvoidanceInfo(bool* bShouldAvoid, struct FVector* AvoidCenter, float AvoidRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetPlaypalAvoidanceInfo");

	Params::KosmosEnvironmentInteractable_GetPlaypalAvoidanceInfo Parms{};

	Parms.AvoidRadius = AvoidRadius;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.KosmosEnvironmentInteractable.GetPlaypalInteractInfo
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// float*                                  OutProgress                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bOutCompleted                                          (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::GetPlaypalInteractInfo(float* OutProgress, bool* bOutCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetPlaypalInteractInfo");

	Params::KosmosEnvironmentInteractable_GetPlaypalInteractInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.KosmosEnvironmentInteractable.GetPlayPalStandPosition
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosEnvironmentInteractable::GetPlayPalStandPosition(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetPlayPalStandPosition");

	Params::KosmosEnvironmentInteractable_GetPlayPalStandPosition Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetStandPosition
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// const struct FVector&                   CurrentPlayerLocation                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDirection                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::GetStandPosition(const struct FVector& CurrentPlayerLocation, struct FVector* OutLocation, struct FVector* OutDirection, class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetStandPosition");

	Params::KosmosEnvironmentInteractable_GetStandPosition Parms{};

	Parms.CurrentPlayerLocation = std::move(CurrentPlayerLocation);
	Parms.InCharacter = InCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.KosmosEnvironmentInteractable.GetWorldInteractLocation
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   CharacterLocation                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosEnvironmentInteractable::GetWorldInteractLocation(const struct FVector& CharacterLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetWorldInteractLocation");

	Params::KosmosEnvironmentInteractable_GetWorldInteractLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetWorldInteractRotation
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator AKosmosEnvironmentInteractable::GetWorldInteractRotation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetWorldInteractRotation");

	Params::KosmosEnvironmentInteractable_GetWorldInteractRotation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.HandleResume
// (Native, Public)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "HandleResume");

	Params::KosmosEnvironmentInteractable_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.HandleSnapshot
// (Native, Public)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "HandleSnapshot");

	Params::KosmosEnvironmentInteractable_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.IsCharacterValidStandDirection
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::IsCharacterValidStandDirection(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsCharacterValidStandDirection");

	Params::KosmosEnvironmentInteractable_IsCharacterValidStandDirection Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.IsCharacterValidStandPosition
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   FootLocation                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::IsCharacterValidStandPosition(class AKosmosBaseCharacter* Character, const struct FVector& FootLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsCharacterValidStandPosition");

	Params::KosmosEnvironmentInteractable_IsCharacterValidStandPosition Parms{};

	Parms.Character = Character;
	Parms.FootLocation = std::move(FootLocation);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.ReleaseControl
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::ReleaseControl(class AKosmosBaseCharacter* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "ReleaseControl");

	Params::KosmosEnvironmentInteractable_ReleaseControl Parms{};

	Parms.InActor = InActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.RequestControl
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::RequestControl(class AKosmosBaseCharacter* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "RequestControl");

	Params::KosmosEnvironmentInteractable_RequestControl Parms{};

	Parms.InActor = InActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.SetApproachFinished
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::SetApproachFinished(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "SetApproachFinished");

	Params::KosmosEnvironmentInteractable_SetApproachFinished Parms{};

	Parms.InCharacter = InCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.SetEnabled
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::SetEnabled(bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "SetEnabled");

	Params::KosmosEnvironmentInteractable_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.SetFocus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Char                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::SetFocus(class AKosmosBaseCharacter* Char)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "SetFocus");

	Params::KosmosEnvironmentInteractable_SetFocus Parms{};

	Parms.Char = Char;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.TriggerGrabbedAudio
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EGrabEventType                          EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGrabEventProgress                      EventProgress                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APawn*                            SelectedCharacter                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::TriggerGrabbedAudio(EGrabEventType EventType, EGrabEventProgress EventProgress, class APawn* SelectedCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "TriggerGrabbedAudio");

	Params::KosmosEnvironmentInteractable_TriggerGrabbedAudio Parms{};

	Parms.EventType = EventType;
	Parms.EventProgress = EventProgress;
	Parms.SelectedCharacter = SelectedCharacter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.ClearIK
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::ClearIK(const class AKosmosBaseCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "ClearIK");

	Params::KosmosEnvironmentInteractable_ClearIK Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetClosestGrabHelper
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// const TArray<class UGrabHelper*>&       GrabHelpers                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EGrabHelperShape                        typeOfGrabHelper                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bCheckIfAvailable                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* AKosmosEnvironmentInteractable::GetClosestGrabHelper(const TArray<class UGrabHelper*>& GrabHelpers, const struct FVector& Location, EGrabHelperShape typeOfGrabHelper, bool bCheckIfAvailable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetClosestGrabHelper");

	Params::KosmosEnvironmentInteractable_GetClosestGrabHelper Parms{};

	Parms.GrabHelpers = std::move(GrabHelpers);
	Parms.Location = std::move(Location);
	Parms.typeOfGrabHelper = typeOfGrabHelper;
	Parms.bCheckIfAvailable = bCheckIfAvailable;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.GetOwnedGrabHelpers
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// TArray<class UGrabHelper*>              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, ContainsInstancedReference, NativeAccessSpecifierPublic)

TArray<class UGrabHelper*> AKosmosEnvironmentInteractable::GetOwnedGrabHelpers() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "GetOwnedGrabHelpers");

	Params::KosmosEnvironmentInteractable_GetOwnedGrabHelpers Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.HasCurrentControl
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosBaseCharacter*             InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::HasCurrentControl(class AKosmosBaseCharacter* InActor) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "HasCurrentControl");

	Params::KosmosEnvironmentInteractable_HasCurrentControl Parms{};

	Parms.InActor = InActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosEnvironmentInteractable::IsCurrentlyActivated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsCurrentlyActivated");

	Params::KosmosEnvironmentInteractable_IsCurrentlyActivated Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosEnvironmentInteractable::IsCurrentlyControlled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsCurrentlyControlled");

	Params::KosmosEnvironmentInteractable_IsCurrentlyControlled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosEnvironmentInteractable::IsSmbdActivated() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsSmbdActivated");

	Params::KosmosEnvironmentInteractable_IsSmbdActivated Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.IsWithinVerticalGrabRange
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure, Const)
// Parameters:
// float                                   VerticalDelta                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosEnvironmentInteractable::IsWithinVerticalGrabRange(float VerticalDelta) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "IsWithinVerticalGrabRange");

	Params::KosmosEnvironmentInteractable_IsWithinVerticalGrabRange Parms{};

	Parms.VerticalDelta = VerticalDelta;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEnvironmentInteractable.SetupIK
// (Final, Native, Public, BlueprintCallable, Const)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosEnvironmentInteractable::SetupIK(const class AKosmosBaseCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEnvironmentInteractable", "SetupIK");

	Params::KosmosEnvironmentInteractable_SetupIK Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.AttachInsertable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AKosmosCarriable*                 InInsertableItem                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosInsertableSlot::AttachInsertable(class AKosmosCarriable* InInsertableItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "AttachInsertable");

	Params::KosmosInsertableSlot_AttachInsertable Parms{};

	Parms.InInsertableItem = InInsertableItem;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.DetachInsertable
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bIsEjected                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosInsertableSlot::DetachInsertable(bool bIsEjected)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "DetachInsertable");

	Params::KosmosInsertableSlot_DetachInsertable Parms{};

	Parms.bIsEjected = bIsEjected;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.DisableInsertableSlot
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosInsertableSlot::DisableInsertableSlot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "DisableInsertableSlot");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.EjectSlot
// (Final, Native, Public, BlueprintCallable)

void AKosmosInsertableSlot::EjectSlot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "EjectSlot");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.EnableInsertableSlot
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosInsertableSlot::EnableInsertableSlot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "EnableInsertableSlot");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInsertableSlot.IsItemInserted
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosInsertableSlot::IsItemInserted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "IsItemInserted");

	Params::KosmosInsertableSlot_IsItemInserted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInsertableSlot.OnCheckpointResumed
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosInsertableSlot::OnCheckpointResumed(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "OnCheckpointResumed");

	Params::KosmosInsertableSlot_OnCheckpointResumed Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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


// Function Kosmos.KosmosInsertableSlot.OnRep_InsertableItem
// (Final, Native, Private)

void AKosmosInsertableSlot::OnRep_InsertableItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInsertableSlot", "OnRep_InsertableItem");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalBoost
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   Boost                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalBoost(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* Boost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalBoost");

	Params::KosmosPlaypalCommandsInteractions_PlaypalBoost Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Boost = Boost;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalCapstan
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   Capstan                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ProgressToReach                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HoldTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bWrenchCapstan                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalCapstan(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* Capstan, float ProgressToReach, float HoldTime, bool bWrenchCapstan)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalCapstan");

	Params::KosmosPlaypalCommandsInteractions_PlaypalCapstan Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Capstan = Capstan;
	Parms.ProgressToReach = ProgressToReach;
	Parms.HoldTime = HoldTime;
	Parms.bWrenchCapstan = bWrenchCapstan;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalCrank
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCrank*                     Crank                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgrss                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HoldTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalCrank(class UObject* WorldContextObject, class AKosmosCrank* Crank, float TargetProgrss, float HoldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalCrank");

	Params::KosmosPlaypalCommandsInteractions_PlaypalCrank Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Crank = Crank;
	Parms.TargetProgrss = TargetProgrss;
	Parms.HoldTime = HoldTime;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalFreeDraggable
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosDraggable*                 Draggable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetActor                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalFreeDraggable(class UObject* WorldContextObject, class AKosmosDraggable* Draggable, class AActor* TargetActor, const struct FVector& TargetLocation, float GoalRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalFreeDraggable");

	Params::KosmosPlaypalCommandsInteractions_PlaypalFreeDraggable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Draggable = Draggable;
	Parms.TargetActor = TargetActor;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.GoalRadius = GoalRadius;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalLadderWait
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosLadder*                    Ladder                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeoutDelay                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldReleaseOnEnd                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalLadderWait(class UObject* WorldContextObject, class AKosmosLadder* Ladder, float TimeoutDelay, bool ShouldReleaseOnEnd)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalLadderWait");

	Params::KosmosPlaypalCommandsInteractions_PlaypalLadderWait Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Ladder = Ladder;
	Parms.TimeoutDelay = TimeoutDelay;
	Parms.ShouldReleaseOnEnd = ShouldReleaseOnEnd;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalLargeLever
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   Lever                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ProgressToReach                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HoldTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalLargeLever(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* Lever, float ProgressToReach, float HoldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalLargeLever");

	Params::KosmosPlaypalCommandsInteractions_PlaypalLargeLever Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Lever = Lever;
	Parms.ProgressToReach = ProgressToReach;
	Parms.HoldTime = HoldTime;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalMirror
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   Mirror                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalMirror(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* Mirror, float GoalRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalMirror");

	Params::KosmosPlaypalCommandsInteractions_PlaypalMirror Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Mirror = Mirror;
	Parms.GoalRadius = GoalRadius;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalPushPull
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   Interactable                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgress                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosPlaypalInteractionType           MovementType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalPushPull(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* Interactable, float TargetProgress, EKosmosPlaypalInteractionType MovementType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalPushPull");

	Params::KosmosPlaypalCommandsInteractions_PlaypalPushPull Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Interactable = Interactable;
	Parms.TargetProgress = TargetProgress;
	Parms.MovementType = MovementType;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalSwingable
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosSwingable*                 Swingable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           JumpOnTarget                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   JumpOnLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldAutoJumpOff                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           JumpOffTarget                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   JumpOffLocation                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    WaitForRetractable                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReactableTargetProgress                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalSwingable(class UObject* WorldContextObject, class AKosmosSwingable* Swingable, class AActor* JumpOnTarget, const struct FVector& JumpOnLocation, bool ShouldAutoJumpOff, class AActor* JumpOffTarget, const struct FVector& JumpOffLocation, bool WaitForRetractable, float ReactableTargetProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalSwingable");

	Params::KosmosPlaypalCommandsInteractions_PlaypalSwingable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Swingable = Swingable;
	Parms.JumpOnTarget = JumpOnTarget;
	Parms.JumpOnLocation = std::move(JumpOnLocation);
	Parms.ShouldAutoJumpOff = ShouldAutoJumpOff;
	Parms.JumpOffTarget = JumpOffTarget;
	Parms.JumpOffLocation = std::move(JumpOffLocation);
	Parms.WaitForRetractable = WaitForRetractable;
	Parms.ReactableTargetProgress = ReactableTargetProgress;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsInteractions.PlaypalZipline
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosZipline*                   Zipline                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsInteractions*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsInteractions* UKosmosPlaypalCommandsInteractions::PlaypalZipline(class UObject* WorldContextObject, class AKosmosZipline* Zipline)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsInteractions", "PlaypalZipline");

	Params::KosmosPlaypalCommandsInteractions_PlaypalZipline Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Zipline = Zipline;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHandholdingInterface.Multicast_RequestBeginHandholding
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UKosmosHandholdingInterface*      InPartner                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHandholdingInterface::Multicast_RequestBeginHandholding(class UKosmosHandholdingInterface* InPartner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "Multicast_RequestBeginHandholding");

	Params::KosmosHandholdingInterface_Multicast_RequestBeginHandholding Parms{};

	Parms.InPartner = InPartner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHandholdingInterface.Multicast_RequestEndHandholding
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UKosmosHandholdingInterface*      InPartner                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHandholdingInterface::Multicast_RequestEndHandholding(class UKosmosHandholdingInterface* InPartner)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "Multicast_RequestEndHandholding");

	Params::KosmosHandholdingInterface_Multicast_RequestEndHandholding Parms{};

	Parms.InPartner = InPartner;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHandholdingInterface.StopHoldingHands
// (Final, Native, Public, BlueprintCallable)

void UKosmosHandholdingInterface::StopHoldingHands()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "StopHoldingHands");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHandholdingInterface.GetHandTarget
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UKosmosHandholdingInterface::GetHandTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "GetHandTarget");

	Params::KosmosHandholdingInterface_GetHandTarget Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHandholdingInterface.GetHardPullForce
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosHandholdingInterface::GetHardPullForce() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "GetHardPullForce");

	Params::KosmosHandholdingInterface_GetHardPullForce Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHandholdingInterface.GetHeldPartner
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosHandholdingInterface*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosHandholdingInterface* UKosmosHandholdingInterface::GetHeldPartner() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "GetHeldPartner");

	Params::KosmosHandholdingInterface_GetHeldPartner Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHandholdingInterface.GetSoftPullForce
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosHandholdingInterface::GetSoftPullForce() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "GetSoftPullForce");

	Params::KosmosHandholdingInterface_GetSoftPullForce Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosHandholdingInterface::IsBeingPulled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "IsBeingPulled");

	Params::KosmosHandholdingInterface_IsBeingPulled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosHandholdingInterface::IsDriver() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "IsDriver");

	Params::KosmosHandholdingInterface_IsDriver Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosHandholdingInterface::IsHoldingHands() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHandholdingInterface", "IsHoldingHands");

	Params::KosmosHandholdingInterface_IsHoldingHands Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIActionMirror.OnMirrorFinished
// (Final, Native, Public)

void UKosmosAIActionMirror::OnMirrorFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionMirror", "OnMirrorFinished");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionSwing.TriggerJumpOff
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIActionSwing::TriggerJumpOff()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionSwing", "TriggerJumpOff");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.DetectPlayersBeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::DetectPlayersBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "DetectPlayersBeginOverlap");

	Params::KosmosBreakableHatch_DetectPlayersBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.DetectPlayersEndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::DetectPlayersEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "DetectPlayersEndOverlap");

	Params::KosmosBreakableHatch_DetectPlayersEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.DoReturnMovement
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosBreakableHatch::DoReturnMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "DoReturnMovement");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosBreakableHatch.DoSmallMovement
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosBreakableHatch::DoSmallMovement()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "DoSmallMovement");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosBreakableHatch.HandleResume
// (Native, Public)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "HandleResume");

	Params::KosmosBreakableHatch_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.HandleSnapshot
// (Native, Public)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "HandleSnapshot");

	Params::KosmosBreakableHatch_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.Multicast_OnCharacterLandedHit
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AKosmosBreakableHatch::Multicast_OnCharacterLandedHit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "Multicast_OnCharacterLandedHit");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.Multicast_OnMisMatchedCharacterLanding
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AKosmosBreakableHatch::Multicast_OnMisMatchedCharacterLanding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "Multicast_OnMisMatchedCharacterLanding");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.Multicast_UpdateProgress
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const int32                             NewProgress                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromCheckpoint                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::Multicast_UpdateProgress(const int32 NewProgress, bool bFromCheckpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "Multicast_UpdateProgress");

	Params::KosmosBreakableHatch_Multicast_UpdateProgress Parms{};

	Parms.NewProgress = NewProgress;
	Parms.bFromCheckpoint = bFromCheckpoint;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.OnCharacterLanded
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                HitResult                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::OnCharacterLanded(const struct FHitResult& HitResult, class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "OnCharacterLanded");

	Params::KosmosBreakableHatch_OnCharacterLanded Parms{};

	Parms.HitResult = std::move(HitResult);
	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableHatch.OnCharacterLandedHit
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewProgress                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::OnCharacterLandedHit(int32 NewProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "OnCharacterLandedHit");

	Params::KosmosBreakableHatch_OnCharacterLandedHit Parms{};

	Parms.NewProgress = NewProgress;

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


// Function Kosmos.KosmosBreakableHatch.OnMisMatchedCharacterLanding
// (Event, Protected, BlueprintEvent)
// Parameters:
// int32                                   NewProgress                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::OnMisMatchedCharacterLanding(int32 NewProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "OnMisMatchedCharacterLanding");

	Params::KosmosBreakableHatch_OnMisMatchedCharacterLanding Parms{};

	Parms.NewProgress = NewProgress;

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


// Function Kosmos.KosmosBreakableHatch.OnProgressUpdated
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    bFromCheckpoint                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableHatch::OnProgressUpdated(bool bFromCheckpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "OnProgressUpdated");

	Params::KosmosBreakableHatch_OnProgressUpdated Parms{};

	Parms.bFromCheckpoint = bFromCheckpoint;

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


// Function Kosmos.KosmosBreakableHatch.IsCompleted
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBreakableHatch::IsCompleted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableHatch", "IsCompleted");

	Params::KosmosBreakableHatch_IsCompleted Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBreakableDoubleHatch.StoodOnHatch2BeginOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosBreakableDoubleHatch::StoodOnHatch2BeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableDoubleHatch", "StoodOnHatch2BeginOverlap");

	Params::KosmosBreakableDoubleHatch_StoodOnHatch2BeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreakableDoubleHatch.StoodOnHatch2EndOverlap
// (Final, Native, Protected)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBreakableDoubleHatch::StoodOnHatch2EndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreakableDoubleHatch", "StoodOnHatch2EndOverlap");

	Params::KosmosBreakableDoubleHatch_StoodOnHatch2EndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIActionZipeline.TriggerEndAbility
// (Final, Native, Public, BlueprintCallable)

void UKosmosAIActionZipeline::TriggerEndAbility()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIActionZipeline", "TriggerEndAbility");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.AddCommandHistoryLine
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKosmosAICommandHistoryDebugInfo&InInfo                                                 (Parm, NativeAccessSpecifierPublic)

void AKosmosAIController::AddCommandHistoryLine(const struct FKosmosAICommandHistoryDebugInfo& InInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "AddCommandHistoryLine");

	Params::KosmosAIController_AddCommandHistoryLine Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.CalcPlaypalFollowOffset
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// bool                                    bAvoiding                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   DesiredTarget                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosAIController::CalcPlaypalFollowOffset(bool bAvoiding, const struct FVector& DesiredTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "CalcPlaypalFollowOffset");

	Params::KosmosAIController_CalcPlaypalFollowOffset Parms{};

	Parms.bAvoiding = bAvoiding;
	Parms.DesiredTarget = std::move(DesiredTarget);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetMovementInput
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D AKosmosAIController::GetMovementInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetMovementInput");

	Params::KosmosAIController_GetMovementInput Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GrabInput
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bTryGrab                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::GrabInput(const bool bTryGrab)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GrabInput");

	Params::KosmosAIController_GrabInput Parms{};

	Parms.bTryGrab = bTryGrab;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.IsLastMove
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Input                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAIController::IsLastMove(const struct FVector2D& Input)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsLastMove");

	Params::KosmosAIController_IsLastMove Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.MovementInput
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 Input                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::MovementInput(const struct FVector2D& Input)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "MovementInput");

	Params::KosmosAIController_MovementInput Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.OnSetAICommand
// (Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosAIAsyncAction*             NewCmd                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStopAI                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::OnSetAICommand(class UKosmosAIAsyncAction* NewCmd, bool bStopAI)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "OnSetAICommand");

	Params::KosmosAIController_OnSetAICommand Parms{};

	Parms.NewCmd = NewCmd;
	Parms.bStopAI = bStopAI;

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


// Function Kosmos.KosmosAIController.PlaypalRotateTo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     TargetRotation                                         (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SuccessAngle                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAIController::PlaypalRotateTo(const struct FQuat& TargetRotation, float DeltaTime, float SuccessAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "PlaypalRotateTo");

	Params::KosmosAIController_PlaypalRotateTo Parms{};

	Parms.TargetRotation = std::move(TargetRotation);
	Parms.DeltaTime = DeltaTime;
	Parms.SuccessAngle = SuccessAngle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.PlaypalTurnTo
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FQuat&                     TargetRotation                                         (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosAIController::PlaypalTurnTo(const struct FQuat& TargetRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "PlaypalTurnTo");

	Params::KosmosAIController_PlaypalTurnTo Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.SetChaseMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAIPlaypalChaseMode                     Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::SetChaseMode(EAIPlaypalChaseMode Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "SetChaseMode");

	Params::KosmosAIController_SetChaseMode Parms{};

	Parms.Mode = Mode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.SetIgnoreAIAttackObstacle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bIgnore                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::SetIgnoreAIAttackObstacle(bool bIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "SetIgnoreAIAttackObstacle");

	Params::KosmosAIController_SetIgnoreAIAttackObstacle Parms{};

	Parms.bIgnore = bIgnore;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.SetShouldAvoidPlayer
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ShouldAvoid                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::SetShouldAvoidPlayer(bool ShouldAvoid)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "SetShouldAvoidPlayer");

	Params::KosmosAIController_SetShouldAvoidPlayer Parms{};

	Parms.ShouldAvoid = ShouldAvoid;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.SetStopMovementOnFinish
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::SetStopMovementOnFinish(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "SetStopMovementOnFinish");

	Params::KosmosAIController_SetStopMovementOnFinish Parms{};

	Parms.InState = InState;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.ShouldDelayCommandExecute
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAIController::ShouldDelayCommandExecute()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "ShouldDelayCommandExecute");

	Params::KosmosAIController_ShouldDelayCommandExecute Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.StopAICommandAt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAIActionSlot                     Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAIController::StopAICommandAt(EKosmosAIActionSlot Slot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "StopAICommandAt");

	Params::KosmosAIController_StopAICommandAt Parms{};

	Parms.Slot = Slot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.StopAllAICommands
// (Final, Native, Public, BlueprintCallable)

void AKosmosAIController::StopAllAICommands()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "StopAllAICommands");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAIController.GetAiCommand
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosAIAsyncAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIAsyncAction* AKosmosAIController::GetAiCommand() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetAiCommand");

	Params::KosmosAIController_GetAiCommand Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetAiCommandAt
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAIActionSlot                     Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAIAsyncAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIAsyncAction* AKosmosAIController::GetAiCommandAt(EKosmosAIActionSlot Slot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetAiCommandAt");

	Params::KosmosAIController_GetAiCommandAt Parms{};

	Parms.Slot = Slot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetAICommandForContext
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          OuterContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAIAsyncAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIAsyncAction* AKosmosAIController::GetAICommandForContext(class UObject* OuterContext) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetAICommandForContext");

	Params::KosmosAIController_GetAICommandForContext Parms{};

	Parms.OuterContext = OuterContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetAiSideCommand
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosAIAsyncAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIAsyncAction* AKosmosAIController::GetAiSideCommand() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetAiSideCommand");

	Params::KosmosAIController_GetAiSideCommand Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetChaseMode
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAIPlaypalChaseMode                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EAIPlaypalChaseMode AKosmosAIController::GetChaseMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetChaseMode");

	Params::KosmosAIController_GetChaseMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetChaseParams
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPlaypalChaseParams        ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FPlaypalChaseParams AKosmosAIController::GetChaseParams() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetChaseParams");

	Params::KosmosAIController_GetChaseParams Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.GetCommandHistoryDebug
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const TArray<struct FKosmosAICommandHistoryDebugInfo>ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const TArray<struct FKosmosAICommandHistoryDebugInfo> AKosmosAIController::GetCommandHistoryDebug() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetCommandHistoryDebug");

	Params::KosmosAIController_GetCommandHistoryDebug Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::GetShouldAvoidPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "GetShouldAvoidPlayer");

	Params::KosmosAIController_GetShouldAvoidPlayer Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::HasActiveNavLink() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "HasActiveNavLink");

	Params::KosmosAIController_HasActiveNavLink Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.HasAICommandForContext
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          OuterContext                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAIController::HasAICommandForContext(class UObject* OuterContext) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "HasAICommandForContext");

	Params::KosmosAIController_HasAICommandForContext Parms{};

	Parms.OuterContext = OuterContext;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::IsAiCommand() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsAiCommand");

	Params::KosmosAIController_IsAiCommand Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::IsAiSideCommandActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsAiSideCommandActive");

	Params::KosmosAIController_IsAiSideCommandActive Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::IsBehaviouralPIPTopPriority() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsBehaviouralPIPTopPriority");

	Params::KosmosAIController_IsBehaviouralPIPTopPriority Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::IsPlaypalQuickTurning() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsPlaypalQuickTurning");

	Params::KosmosAIController_IsPlaypalQuickTurning Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::IsPlaypalTurningOnSpot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsPlaypalTurningOnSpot");

	Params::KosmosAIController_IsPlaypalTurningOnSpot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAIController.IsSlotTopPriority
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAIActionSlot                     Slot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAIController::IsSlotTopPriority(EKosmosAIActionSlot Slot) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "IsSlotTopPriority");

	Params::KosmosAIController_IsSlotTopPriority Parms{};

	Parms.Slot = Slot;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool AKosmosAIController::ShouldIgnoreAttackObstacle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAIController", "ShouldIgnoreAttackObstacle");

	Params::KosmosAIController_ShouldIgnoreAttackObstacle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPawnTriggerVolume.GetClosestPointToActor
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           Actor                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosPawnTriggerVolume::GetClosestPointToActor(class AActor* Actor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "GetClosestPointToActor");

	Params::KosmosPawnTriggerVolume_GetClosestPointToActor Parms{};

	Parms.Actor = Actor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPawnTriggerVolume.GetClosestPointToLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosPawnTriggerVolume::GetClosestPointToLocation(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "GetClosestPointToLocation");

	Params::KosmosPawnTriggerVolume_GetClosestPointToLocation Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPawnTriggerVolume.OnBeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPawnTriggerVolume::OnBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "OnBeginOverlap");

	Params::KosmosPawnTriggerVolume_OnBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPawnTriggerVolume.OnEndOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPawnTriggerVolume::OnEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "OnEndOverlap");

	Params::KosmosPawnTriggerVolume_OnEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPawnTriggerVolume.OnPawnBeginOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPawnTriggerVolume::OnPawnBeginOverlap_Blueprint(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "OnPawnBeginOverlap_Blueprint");

	Params::KosmosPawnTriggerVolume_OnPawnBeginOverlap_Blueprint Parms{};

	Parms.Pawn = Pawn;

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


// Function Kosmos.KosmosPawnTriggerVolume.OnPawnEndOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPawnTriggerVolume::OnPawnEndOverlap_Blueprint(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "OnPawnEndOverlap_Blueprint");

	Params::KosmosPawnTriggerVolume_OnPawnEndOverlap_Blueprint Parms{};

	Parms.Pawn = Pawn;

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


// Function Kosmos.KosmosPawnTriggerVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPawnTriggerVolume::SetEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "SetEnabled");

	Params::KosmosPawnTriggerVolume_SetEnabled Parms{};

	Parms.Enabled = Enabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPawnTriggerVolume.IsPawnOverlapping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPawnTriggerVolume::IsPawnOverlapping(class APawn* Pawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "IsPawnOverlapping");

	Params::KosmosPawnTriggerVolume_IsPawnOverlapping Parms{};

	Parms.Pawn = Pawn;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

int32 AKosmosPawnTriggerVolume::NumOverlappingPawns() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPawnTriggerVolume", "NumOverlappingPawns");

	Params::KosmosPawnTriggerVolume_NumOverlappingPawns Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDraggable.GetPlaypalAvoidInfo
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector*                         OutAvoidCenter                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float*                                  OutAvoidRadius                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutVelocity                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosDraggable::GetPlaypalAvoidInfo(struct FVector* OutAvoidCenter, float* OutAvoidRadius, struct FVector* OutVelocity)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "GetPlaypalAvoidInfo");

	Params::KosmosDraggable_GetPlaypalAvoidInfo Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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

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

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDraggable.GetStandPosition
// (Native, Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDirection                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDraggable::GetStandPosition(const class AKosmosBaseCharacter* Character, struct FVector* OutLocation, struct FVector* OutDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "GetStandPosition");

	Params::KosmosDraggable_GetStandPosition Parms{};

	Parms.Character = Character;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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

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


// Function Kosmos.KosmosDraggable.HandleKosmosRoomLoaded
// (Final, Native, Private)

void AKosmosDraggable::HandleKosmosRoomLoaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "HandleKosmosRoomLoaded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.HandleKosmosRoomUnloaded
// (Final, Native, Private)

void AKosmosDraggable::HandleKosmosRoomUnloaded()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "HandleKosmosRoomUnloaded");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.HandleResume
// (Final, Native, Private)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDraggable::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "HandleResume");

	Params::KosmosDraggable_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.HandleSnapshot
// (Final, Native, Private)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDraggable::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "HandleSnapshot");

	Params::KosmosDraggable_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.OnRep_ReplicatedDragable
// (Final, Native, Private)

void AKosmosDraggable::OnRep_ReplicatedDragable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "OnRep_ReplicatedDragable");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.OnResume
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDraggable::OnResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "OnResume");

	Params::KosmosDraggable_OnResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.OnSnapshot
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDraggable::OnSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "OnSnapshot");

	Params::KosmosDraggable_OnSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.SendToSleep
// (Final, Native, Private)

void AKosmosDraggable::SendToSleep()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "SendToSleep");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.Suspend
// (Native, Event, Public, BlueprintEvent)

void AKosmosDraggable::Suspend()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "Suspend");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.UpdateState
// (Final, Native, Private)

void AKosmosDraggable::UpdateState()
{
	static class UFunction* Func = nullptr;

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

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDraggable.WakeUp
// (Final, Native, Private)

void AKosmosDraggable::WakeUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDraggable", "WakeUp");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAiCrouchVolume.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAiCrouchVolume::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAiCrouchVolume", "HandleResume");

	Params::KosmosAiCrouchVolume_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAiCrouchVolume.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAiCrouchVolume::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAiCrouchVolume", "HandleSnapshot");

	Params::KosmosAiCrouchVolume_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationSetupComponent.SetDefaultLocomotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             LocomotionName                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationSetupComponent::SetDefaultLocomotion(class FName LocomotionName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationSetupComponent", "SetDefaultLocomotion");

	Params::AnimationSetupComponent_SetDefaultLocomotion Parms{};

	Parms.LocomotionName = LocomotionName;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AnimationSetupComponent.SetupAnimationState_Blueprint
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FCharacterAnimStateSetup&  animStateSetup                                         (Parm, NoDestructor, NativeAccessSpecifierPublic)
// class UAnimationSetupComponent**        setupComponent                                         (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationSetupComponent::SetupAnimationState_Blueprint(const struct FCharacterAnimStateSetup& animStateSetup, class UAnimationSetupComponent** setupComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationSetupComponent", "SetupAnimationState_Blueprint");

	Params::AnimationSetupComponent_SetupAnimationState_Blueprint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Kosmos.AnimationSetupComponent.SetupAnimationStates_Blueprint
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FCharacterAnimStateSetup>&animStates                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// class UAnimationSetupComponent**        setupComponent                                         (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UAnimationSetupComponent::SetupAnimationStates_Blueprint(const TArray<struct FCharacterAnimStateSetup>& animStates, class UAnimationSetupComponent** setupComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AnimationSetupComponent", "SetupAnimationStates_Blueprint");

	Params::AnimationSetupComponent_SetupAnimationStates_Blueprint Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

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


// Function Kosmos.CharacterAnimationSlots.GetAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAnimOverrideType                       animationType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequenceBase* UCharacterAnimationSlots::GetAnimation(EAnimOverrideType animationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterAnimationSlots", "GetAnimation");

	Params::CharacterAnimationSlots_GetAnimation Parms{};

	Parms.animationType = animationType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.CharacterAnimationSlots.GetBlendSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBlendSpaceOverrideType                 animationType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBlendSpaceBase*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBlendSpaceBase* UCharacterAnimationSlots::GetBlendSpace(EBlendSpaceOverrideType animationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterAnimationSlots", "GetBlendSpace");

	Params::CharacterAnimationSlots_GetBlendSpace Parms{};

	Parms.animationType = animationType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.CharacterAnimationSlots.GetWalkStop
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EWalkStopOverrideType                   animationType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   walkCycle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequenceBase* UCharacterAnimationSlots::GetWalkStop(EWalkStopOverrideType animationType, float walkCycle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterAnimationSlots", "GetWalkStop");

	Params::CharacterAnimationSlots_GetWalkStop Parms{};

	Parms.animationType = animationType;
	Parms.walkCycle = walkCycle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.CharacterLookAtBlendspaceSlots.GetBlendSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// ELookAtBlendSpaceOverrideType           animationType                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBlendSpaceBase*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBlendSpaceBase* UCharacterLookAtBlendspaceSlots::GetBlendSpace(ELookAtBlendSpaceOverrideType animationType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("CharacterLookAtBlendspaceSlots", "GetBlendSpace");

	Params::CharacterLookAtBlendspaceSlots_GetBlendSpace Parms{};

	Parms.animationType = animationType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseGrabbableComponent.GetClosestGrabHelper
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* UKosmosBaseGrabbableComponent::GetClosestGrabHelper(const struct FVector& Location) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseGrabbableComponent", "GetClosestGrabHelper");

	Params::KosmosBaseGrabbableComponent_GetClosestGrabHelper Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbableComponent.CalcGrabPoints
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UGrabHelper*>&       InGrabHelpers                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    InIgnoreEnvironmentalCollisionCheck                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FGrabPoint>               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FGrabPoint> UKosmosClimbableComponent::CalcGrabPoints(const TArray<class UGrabHelper*>& InGrabHelpers, bool InIgnoreEnvironmentalCollisionCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosClimbableComponent", "CalcGrabPoints");

	Params::KosmosClimbableComponent_CalcGrabPoints Parms{};

	Parms.InGrabHelpers = std::move(InGrabHelpers);
	Parms.InIgnoreEnvironmentalCollisionCheck = InIgnoreEnvironmentalCollisionCheck;

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbableComponent.GetOnFromTopLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosClimbableComponent::GetOnFromTopLocation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbableComponent", "GetOnFromTopLocation");

	Params::KosmosClimbableComponent_GetOnFromTopLocation Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbableComponent.RefreshClimbableExtremities
// (Final, Native, Public, BlueprintCallable)

void UKosmosClimbableComponent::RefreshClimbableExtremities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbableComponent", "RefreshClimbableExtremities");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosClimbableComponent.RefreshGrabPoints
// (Final, Native, Public, BlueprintCallable)

void UKosmosClimbableComponent::RefreshGrabPoints()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbableComponent", "RefreshGrabPoints");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosClimbableComponent.GetNextGrabHelper
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGrabHelper*                      CurrentGrabHelper                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* UKosmosClimbableComponent::GetNextGrabHelper(class UGrabHelper* CurrentGrabHelper) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbableComponent", "GetNextGrabHelper");

	Params::KosmosClimbableComponent_GetNextGrabHelper Parms{};

	Parms.CurrentGrabHelper = CurrentGrabHelper;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbableComponent.GetPrevGrabHelper
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGrabHelper*                      CurrentGrabHelper                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* UKosmosClimbableComponent::GetPrevGrabHelper(class UGrabHelper* CurrentGrabHelper) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbableComponent", "GetPrevGrabHelper");

	Params::KosmosClimbableComponent_GetPrevGrabHelper Parms{};

	Parms.CurrentGrabHelper = CurrentGrabHelper;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.AddRootmotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    Invoker                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::AddRootmotion(const class UObject* Invoker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "AddRootmotion");

	Params::PlayerAnimInstance_AddRootmotion Parms{};

	Parms.Invoker = Invoker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.AI_OnFinishMoveCleanUp
// (Final, Native, Public)

void UPlayerAnimInstance::AI_OnFinishMoveCleanUp()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "AI_OnFinishMoveCleanUp");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.IsLocomotionSetEqual
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const int32                             locomotionCandidate                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsLocomotionSetEqual(const int32 locomotionCandidate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsLocomotionSetEqual");

	Params::PlayerAnimInstance_IsLocomotionSetEqual Parms{};

	Parms.locomotionCandidate = locomotionCandidate;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.OnAnimationOverrideStarted
// (Native, Protected)
// Parameters:
// class UAnimationControlComponent*       animComp                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimationAsset*                  AnimAsset                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnAnimationOverrideStarted(class UAnimationControlComponent* animComp, class UAnimationAsset* AnimAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnAnimationOverrideStarted");

	Params::PlayerAnimInstance_OnAnimationOverrideStarted Parms{};

	Parms.animComp = animComp;
	Parms.AnimAsset = AnimAsset;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnAnimNotify
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnAnimNotify(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnAnimNotify");

	Params::PlayerAnimInstance_OnAnimNotify Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnBounceOffWall
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// const struct FVector&                   bounceVector                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    belowWaist                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnBounceOffWall(const struct FVector& bounceVector, bool belowWaist)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnBounceOffWall");

	Params::PlayerAnimInstance_OnBounceOffWall Parms{};

	Parms.bounceVector = std::move(bounceVector);
	Parms.belowWaist = belowWaist;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnJumpStart
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// const struct FVector&                   jumpVec                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnJumpStart(const struct FVector& jumpVec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnJumpStart");

	Params::PlayerAnimInstance_OnJumpStart Parms{};

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

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnLanded
// (Final, Native, Public, HasOutParams)
// Parameters:
// class AKosmosBaseCharacter*             Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnLanded(class AKosmosBaseCharacter* Pawn, const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnLanded");

	Params::PlayerAnimInstance_OnLanded Parms{};

	Parms.Pawn = Pawn;
	Parms.FallData = std::move(FallData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnPlayerAnimNotify
// (Final, Native, Public, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnPlayerAnimNotify(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnPlayerAnimNotify");

	Params::PlayerAnimInstance_OnPlayerAnimNotify Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.OnWalkStartBegin
// (Final, Native, Protected)
// Parameters:
// EWalkTransitionType                     Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::OnWalkStartBegin(EWalkTransitionType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "OnWalkStartBegin");

	Params::PlayerAnimInstance_OnWalkStartBegin Parms{};

	Parms.Type = Type;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.RemoveRootmotion
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    Invoker                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UPlayerAnimInstance::RemoveRootmotion(const class UObject* Invoker)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "RemoveRootmotion");

	Params::PlayerAnimInstance_RemoveRootmotion Parms{};

	Parms.Invoker = Invoker;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PlayerAnimInstance.GetAnimBlendSpaceForSlot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBlendSpaceOverrideType                 overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UBlendSpaceBase*                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UBlendSpaceBase* UPlayerAnimInstance::GetAnimBlendSpaceForSlot(EBlendSpaceOverrideType overrideType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetAnimBlendSpaceForSlot");

	Params::PlayerAnimInstance_GetAnimBlendSpaceForSlot Parms{};

	Parms.overrideType = overrideType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.GetAnimSequenceOverrideForName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequenceBase* UPlayerAnimInstance::GetAnimSequenceOverrideForName(class FName overrideType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetAnimSequenceOverrideForName");

	Params::PlayerAnimInstance_GetAnimSequenceOverrideForName Parms{};

	Parms.overrideType = overrideType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.GetAnimSequenceOverrideForType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAnimOverrideType                       overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequenceBase* UPlayerAnimInstance::GetAnimSequenceOverrideForType(EAnimOverrideType overrideType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetAnimSequenceOverrideForType");

	Params::PlayerAnimInstance_GetAnimSequenceOverrideForType Parms{};

	Parms.overrideType = overrideType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.GetAnimWalkStopOverrideForType
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EWalkStopOverrideType                   overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   walkCycle                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimSequenceBase*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequenceBase* UPlayerAnimInstance::GetAnimWalkStopOverrideForType(EWalkStopOverrideType overrideType, float walkCycle) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetAnimWalkStopOverrideForType");

	Params::PlayerAnimInstance_GetAnimWalkStopOverrideForType Parms{};

	Parms.overrideType = overrideType;
	Parms.walkCycle = walkCycle;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.GetFlowControlComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosFlowControlComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosFlowControlComponent* UPlayerAnimInstance::GetFlowControlComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetFlowControlComponent");

	Params::PlayerAnimInstance_GetFlowControlComponent Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.GetWalkCycleFoot
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EWalkCycleFoot                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWalkCycleFoot UPlayerAnimInstance::GetWalkCycleFoot() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "GetWalkCycleFoot");

	Params::PlayerAnimInstance_GetWalkCycleFoot Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.HasBlendSpace
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBlendSpaceOverrideType                 blendspaceSlot                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ignoreDefaultOverride                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::HasBlendSpace(EBlendSpaceOverrideType blendspaceSlot, bool ignoreDefaultOverride) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "HasBlendSpace");

	Params::PlayerAnimInstance_HasBlendSpace Parms{};

	Parms.blendspaceSlot = blendspaceSlot;
	Parms.ignoreDefaultOverride = ignoreDefaultOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UPlayerAnimInstance::HasRootmotionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "HasRootmotionEnabled");

	Params::PlayerAnimInstance_HasRootmotionEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.HasSequenceOverride
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAnimOverrideType                       overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ignoreDefaultOverride                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::HasSequenceOverride(EAnimOverrideType overrideType, bool ignoreDefaultOverride) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "HasSequenceOverride");

	Params::PlayerAnimInstance_HasSequenceOverride Parms{};

	Parms.overrideType = overrideType;
	Parms.ignoreDefaultOverride = ignoreDefaultOverride;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsAnimationSlotDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EAnimOverrideType                       overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsAnimationSlotDisabled(EAnimOverrideType overrideType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsAnimationSlotDisabled");

	Params::PlayerAnimInstance_IsAnimationSlotDisabled Parms{};

	Parms.overrideType = overrideType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsBlendSpaceSlotDisabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBlendSpaceOverrideType                 overrideType                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsBlendSpaceSlotDisabled(EBlendSpaceOverrideType overrideType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsBlendSpaceSlotDisabled");

	Params::PlayerAnimInstance_IsBlendSpaceSlotDisabled Parms{};

	Parms.overrideType = overrideType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsGrabInterfaceActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TSubclassOf<class UKosmosBaseGrabberInterface>grabClass                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsGrabInterfaceActive(TSubclassOf<class UKosmosBaseGrabberInterface> grabClass) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsGrabInterfaceActive");

	Params::PlayerAnimInstance_IsGrabInterfaceActive Parms{};

	Parms.grabClass = grabClass;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsInWalkingMovementMode
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsInWalkingMovementMode() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsInWalkingMovementMode");

	Params::PlayerAnimInstance_IsInWalkingMovementMode Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsLocomotionSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EAnimLocomotionType               locomotionType                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsLocomotionSet(const EAnimLocomotionType locomotionType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsLocomotionSet");

	Params::PlayerAnimInstance_IsLocomotionSet Parms{};

	Parms.locomotionType = locomotionType;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.IsQuickturnAllowed
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::IsQuickturnAllowed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "IsQuickturnAllowed");

	Params::PlayerAnimInstance_IsQuickturnAllowed Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.ShouldExitWalk
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::ShouldExitWalk() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "ShouldExitWalk");

	Params::PlayerAnimInstance_ShouldExitWalk Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.ShouldIdle
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::ShouldIdle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "ShouldIdle");

	Params::PlayerAnimInstance_ShouldIdle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.ShouldStrafeStandTurn
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::ShouldStrafeStandTurn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "ShouldStrafeStandTurn");

	Params::PlayerAnimInstance_ShouldStrafeStandTurn Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PlayerAnimInstance.ShouldWalkOrIdle
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UPlayerAnimInstance::ShouldWalkOrIdle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PlayerAnimInstance", "ShouldWalkOrIdle");

	Params::PlayerAnimInstance_ShouldWalkOrIdle Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDirectionalWindVolume.CalculateWindDirection
// (Final, Native, Public, BlueprintCallable)

void AKosmosDirectionalWindVolume::CalculateWindDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "CalculateWindDirection");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDirectionalWindVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDirectionalWindVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "SetBounds");

	Params::KosmosDirectionalWindVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDirectionalWindVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDirectionalWindVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "SetBoxExtent");

	Params::KosmosDirectionalWindVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDirectionalWindVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDirectionalWindVolume::SetEnabled(bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "SetEnabled");

	Params::KosmosDirectionalWindVolume_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDirectionalWindVolume.UpdateInternalBoxes
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosDirectionalWindVolume::UpdateInternalBoxes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "UpdateInternalBoxes");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


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

bool AKosmosDirectionalWindVolume::GetIsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDirectionalWindVolume", "GetIsEnabled");

	Params::KosmosDirectionalWindVolume_GetIsEnabled Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


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

bool UKosmosAnimInstance::IsClimbingFinished() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAnimInstance", "IsClimbingFinished");

	Params::KosmosAnimInstance_IsClimbingFinished Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAnimInstance.ShouldExitWalkingState
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosAnimInstance::ShouldExitWalkingState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAnimInstance", "ShouldExitWalkingState");

	Params::KosmosAnimInstance_ShouldExitWalkingState Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAnimOverrideVolume.ApplyAnimOverride_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             KosmosCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAnimOverrideVolume::ApplyAnimOverride_Blueprint(class AKosmosBaseCharacter* KosmosCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAnimOverrideVolume", "ApplyAnimOverride_Blueprint");

	Params::KosmosAnimOverrideVolume_ApplyAnimOverride_Blueprint Parms{};

	Parms.KosmosCharacter = KosmosCharacter;

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


// Function Kosmos.KosmosAnimOverrideVolume.ClearAnimOverride_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             KosmosCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAnimOverrideVolume::ClearAnimOverride_Blueprint(class AKosmosBaseCharacter* KosmosCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAnimOverrideVolume", "ClearAnimOverride_Blueprint");

	Params::KosmosAnimOverrideVolume_ClearAnimOverride_Blueprint Parms{};

	Parms.KosmosCharacter = KosmosCharacter;

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


// Function Kosmos.KosmosAntagonistAudioComponent.OnVisibilityChanged
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    NewVisibility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAntagonistAudioComponent::OnVisibilityChanged(bool NewVisibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistAudioComponent", "OnVisibilityChanged");

	Params::KosmosAntagonistAudioComponent_OnVisibilityChanged Parms{};

	Parms.NewVisibility = NewVisibility;

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


// Function Kosmos.KosmosAntagonistCharacter.GetAllAntagonist
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// TArray<class AKosmosAntagonistCharacter*>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AKosmosAntagonistCharacter*> AKosmosAntagonistCharacter::GetAllAntagonist()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAntagonistCharacter", "GetAllAntagonist");

	Params::KosmosAntagonistCharacter_GetAllAntagonist Parms{};

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

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

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_HandleResume
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AKosmosAntagonistCharacter::Client_HandleResume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_HandleResume");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_KillAntagonist
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AKosmosAntagonistCharacter::Client_KillAntagonist()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_KillAntagonist");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_KillPlayer
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::Client_KillPlayer(class AKosmosBaseCharacter* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_KillPlayer");

	Params::KosmosAntagonistCharacter_Client_KillPlayer Parms{};

	Parms.InPlayer = InPlayer;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_SetCollisionState
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    IsEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::Client_SetCollisionState(bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_SetCollisionState");

	Params::KosmosAntagonistCharacter_Client_SetCollisionState Parms{};

	Parms.IsEnabled = IsEnabled;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_SetMontageMode
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::Client_SetMontageMode(bool InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_SetMontageMode");

	Params::KosmosAntagonistCharacter_Client_SetMontageMode Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_SetMovementMode
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// EMovementMode                           InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::Client_SetMovementMode(EMovementMode InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_SetMovementMode");

	Params::KosmosAntagonistCharacter_Client_SetMovementMode Parms{};

	Parms.InMode = InMode;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_SetVisibility
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    InVisibility                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::Client_SetVisibility(bool InVisibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_SetVisibility");

	Params::KosmosAntagonistCharacter_Client_SetVisibility Parms{};

	Parms.InVisibility = InVisibility;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Client_StopMontage
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AKosmosAntagonistCharacter::Client_StopMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Client_StopMontage");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.GetAntagonistController
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosMonsterController*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosMonsterController* AKosmosAntagonistCharacter::GetAntagonistController()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "GetAntagonistController");

	Params::KosmosAntagonistCharacter_GetAntagonistController Parms{};

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAntagonistCharacter.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "HandleResume");

	Params::KosmosAntagonistCharacter_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "HandleSnapshot");

	Params::KosmosAntagonistCharacter_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

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

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.Init
// (Final, Native, Public, BlueprintCallable)

void AKosmosAntagonistCharacter::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "Init");

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

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.KillAntagonist
// (Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosAntagonistCharacter::KillAntagonist()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "KillAntagonist");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAntagonistCharacter.KillPlayer
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::KillPlayer(class AKosmosBaseCharacter* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "KillPlayer");

	Params::KosmosAntagonistCharacter_KillPlayer Parms{};

	Parms.InPlayer = InPlayer;

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


// Function Kosmos.KosmosAntagonistCharacter.NotifyMoveBlockedByKosmosCharacter
// (Event, Protected, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             KosmosCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::NotifyMoveBlockedByKosmosCharacter(class AKosmosBaseCharacter* KosmosCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "NotifyMoveBlockedByKosmosCharacter");

	Params::KosmosAntagonistCharacter_NotifyMoveBlockedByKosmosCharacter Parms{};

	Parms.KosmosCharacter = KosmosCharacter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosAntagonistCharacter.OnCheckpointResume
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::OnCheckpointResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "OnCheckpointResume");

	Params::KosmosAntagonistCharacter_OnCheckpointResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosAntagonistCharacter.OnCheckpointResumed
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosAntagonistCharacter::OnCheckpointResumed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "OnCheckpointResumed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosAntagonistCharacter.SetCollisionState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    IsEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::SetCollisionState(bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "SetCollisionState");

	Params::KosmosAntagonistCharacter_SetCollisionState Parms{};

	Parms.IsEnabled = IsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.SetMontageMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::SetMontageMode(bool InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "SetMontageMode");

	Params::KosmosAntagonistCharacter_SetMontageMode Parms{};

	Parms.InMode = InMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.SetMovementMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EMovementMode                           InMode                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::SetMovementMode(EMovementMode InMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "SetMovementMode");

	Params::KosmosAntagonistCharacter_SetMovementMode Parms{};

	Parms.InMode = InMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.SetVisibility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InVisibility                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::SetVisibility(bool InVisibility)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "SetVisibility");

	Params::KosmosAntagonistCharacter_SetVisibility Parms{};

	Parms.InVisibility = InVisibility;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.StopMontage
// (Final, Native, Public, BlueprintCallable)

void AKosmosAntagonistCharacter::StopMontage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "StopMontage");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.SwitchPathFollowingToAccelerationBased
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bAccelerationBased                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAntagonistCharacter::SwitchPathFollowingToAccelerationBased(bool bAccelerationBased)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "SwitchPathFollowingToAccelerationBased");

	Params::KosmosAntagonistCharacter_SwitchPathFollowingToAccelerationBased Parms{};

	Parms.bAccelerationBased = bAccelerationBased;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAntagonistCharacter.GetIsCollisionEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosAntagonistCharacter::GetIsCollisionEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAntagonistCharacter", "GetIsCollisionEnabled");

	Params::KosmosAntagonistCharacter_GetIsCollisionEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAssignableKeyWidget.IsBindingLocked
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosAssignableKeyWidget::IsBindingLocked()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAssignableKeyWidget", "IsBindingLocked");

	Params::KosmosAssignableKeyWidget_IsBindingLocked Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAssignableKeyWidget.RefreshAssignableKey
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FSMGMappingReference&      InMappingReferenceBinding                              (Parm, NativeAccessSpecifierPublic)

void UKosmosAssignableKeyWidget::RefreshAssignableKey(const struct FSMGMappingReference& InMappingReferenceBinding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAssignableKeyWidget", "RefreshAssignableKey");

	Params::KosmosAssignableKeyWidget_RefreshAssignableKey Parms{};

	Parms.InMappingReferenceBinding = std::move(InMappingReferenceBinding);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosAsyncWaitForCharacterReady.WaitForCharacterReady
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             KosmosCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAsyncWaitForCharacterReady*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAsyncWaitForCharacterReady* UKosmosAsyncWaitForCharacterReady::WaitForCharacterReady(class UObject* WorldContextObject, class AKosmosBaseCharacter* KosmosCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAsyncWaitForCharacterReady", "WaitForCharacterReady");

	Params::KosmosAsyncWaitForCharacterReady_WaitForCharacterReady Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.KosmosCharacter = KosmosCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAtmosphereVolume.ForceSetThisVolume
// (Final, Native, Public, BlueprintCallable)

void AKosmosAtmosphereVolume::ForceSetThisVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolume", "ForceSetThisVolume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAtmosphereVolume.ImmediatelyCompleteBlending
// (Final, Native, Public, BlueprintCallable)

void AKosmosAtmosphereVolume::ImmediatelyCompleteBlending()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolume", "ImmediatelyCompleteBlending");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAtmosphereVolume.SetBehaviour
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosAtmosphereVolumeBehaviour        Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAtmosphereVolume::SetBehaviour(EKosmosAtmosphereVolumeBehaviour Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolume", "SetBehaviour");

	Params::KosmosAtmosphereVolume_SetBehaviour Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAtmosphereVolume.GetBehaviour
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosAtmosphereVolumeBehaviour        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosAtmosphereVolumeBehaviour AKosmosAtmosphereVolume::GetBehaviour() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolume", "GetBehaviour");

	Params::KosmosAtmosphereVolume_GetBehaviour Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAtmosphereVolumeManager.ApplyTemporaryTargetOverride
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DurationSeconds                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ImmediatelyCompleteBlend                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosAtmosphereVolumeManager::ApplyTemporaryTargetOverride(const struct FVector& TargetLocation, float DurationSeconds, bool ImmediatelyCompleteBlend)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAtmosphereVolumeManager", "ApplyTemporaryTargetOverride");

	Params::KosmosAtmosphereVolumeManager_ApplyTemporaryTargetOverride Parms{};

	Parms.TargetLocation = std::move(TargetLocation);
	Parms.DurationSeconds = DurationSeconds;
	Parms.ImmediatelyCompleteBlend = ImmediatelyCompleteBlend;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.ApplyOutputDeviceEffect
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// int32                                   SharesetID                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::ApplyOutputDeviceEffect(int32 SharesetID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "ApplyOutputDeviceEffect");

	Params::KosmosAudioBlueprintLibrary_ApplyOutputDeviceEffect Parms{};

	Parms.SharesetID = SharesetID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.AreAntagonistsInLinkedRooms
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosAudioBlueprintLibrary::AreAntagonistsInLinkedRooms(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "AreAntagonistsInLinkedRooms");

	Params::KosmosAudioBlueprintLibrary_AreAntagonistsInLinkedRooms Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.BindAudioVolumeGroupEvents
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class FName groupName, const EKosmosAudioVolumeGroupEventType EventType)>&audioVolumeGroupEvents                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::BindAudioVolumeGroupEvents(class UObject* WorldContextObject, const TDelegate<void(const class FName groupName, const EKosmosAudioVolumeGroupEventType EventType)>& audioVolumeGroupEvents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "BindAudioVolumeGroupEvents");

	Params::KosmosAudioBlueprintLibrary_BindAudioVolumeGroupEvents Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.audioVolumeGroupEvents = audioVolumeGroupEvents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.BindAudioVolumeTransitionEvents
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class AKosmosAudioVolume* activeAudioVolume, const EKosmosAudioVolumeGroupEventType EventType)>&audioVolumeTransitionEvents                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::BindAudioVolumeTransitionEvents(class UObject* WorldContextObject, const TDelegate<void(const class AKosmosAudioVolume* activeAudioVolume, const EKosmosAudioVolumeGroupEventType EventType)>& audioVolumeTransitionEvents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "BindAudioVolumeTransitionEvents");

	Params::KosmosAudioBlueprintLibrary_BindAudioVolumeTransitionEvents Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.audioVolumeTransitionEvents = audioVolumeTransitionEvents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.BindGlobalAudioEvent
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class FName EventName, const class FString& instigatorName)>&globalAudioEvent                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::BindGlobalAudioEvent(class UObject* WorldContextObject, const TDelegate<void(const class FName EventName, const class FString& instigatorName)>& globalAudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "BindGlobalAudioEvent");

	Params::KosmosAudioBlueprintLibrary_BindGlobalAudioEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.globalAudioEvent = globalAudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.BindMusicSyncCallback
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(EKosmosAkMusicCallbackType CallbackType, class UAkMusicSyncCallbackInfo* CallbackInfo)>&Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::BindMusicSyncCallback(class UObject* WorldContextObject, const TDelegate<void(EKosmosAkMusicCallbackType CallbackType, class UAkMusicSyncCallbackInfo* CallbackInfo)>& Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "BindMusicSyncCallback");

	Params::KosmosAudioBlueprintLibrary_BindMusicSyncCallback Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Callback = Callback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.GetActiveAudioVolume
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAudioVolume*               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosAudioVolume* UKosmosAudioBlueprintLibrary::GetActiveAudioVolume(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "GetActiveAudioVolume");

	Params::KosmosAudioBlueprintLibrary_GetActiveAudioVolume Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.GetAudioVolumeAmbienceComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UKosmosAudioBlueprintLibrary::GetAudioVolumeAmbienceComponent(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "GetAudioVolumeAmbienceComponent");

	Params::KosmosAudioBlueprintLibrary_GetAudioVolumeAmbienceComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.GetAudioVolumesOfGroup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             audioVolumeGroup                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class AKosmosAudioVolume*>       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class AKosmosAudioVolume*> UKosmosAudioBlueprintLibrary::GetAudioVolumesOfGroup(class UObject* WorldContextObject, class FName audioVolumeGroup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "GetAudioVolumesOfGroup");

	Params::KosmosAudioBlueprintLibrary_GetAudioVolumesOfGroup Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.audioVolumeGroup = audioVolumeGroup;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.GetGlobalAmbienceComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UKosmosAudioBlueprintLibrary::GetGlobalAmbienceComponent(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "GetGlobalAmbienceComponent");

	Params::KosmosAudioBlueprintLibrary_GetGlobalAmbienceComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.GetMusicPlaybackComponent
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UKosmosAudioBlueprintLibrary::GetMusicPlaybackComponent(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "GetMusicPlaybackComponent");

	Params::KosmosAudioBlueprintLibrary_GetMusicPlaybackComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.InitWiseMotion
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::InitWiseMotion(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "InitWiseMotion");

	Params::KosmosAudioBlueprintLibrary_InitWiseMotion Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.OverridePlayerAudioComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UAkComponent*                     Target                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::OverridePlayerAudioComponent(class UAkComponent* Target)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "OverridePlayerAudioComponent");

	Params::KosmosAudioBlueprintLibrary_OverridePlayerAudioComponent Parms{};

	Parms.Target = Target;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PlayQuitGameEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PlayQuitGameEvent(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PlayQuitGameEvent");

	Params::KosmosAudioBlueprintLibrary_PlayQuitGameEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PlaySoundAtLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    Sound                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PlaySoundAtLocation(const class UObject* WorldContextObject, class UAkAudioEvent* Sound, const struct FVector& Location, const struct FRotator& Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PlaySoundAtLocation");

	Params::KosmosAudioBlueprintLibrary_PlaySoundAtLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Sound = Sound;
	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PostGlobalAmbience
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    AudioEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PostGlobalAmbience(class UObject* WorldContextObject, class UAkAudioEvent* AudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PostGlobalAmbience");

	Params::KosmosAudioBlueprintLibrary_PostGlobalAmbience Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AudioEvent = AudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PostGlobalEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    AudioEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PostGlobalEvent(class UObject* WorldContextObject, class UAkAudioEvent* AudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PostGlobalEvent");

	Params::KosmosAudioBlueprintLibrary_PostGlobalEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AudioEvent = AudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PostGlobalMusic
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    AudioEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PostGlobalMusic(class UObject* WorldContextObject, class UAkAudioEvent* AudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PostGlobalMusic");

	Params::KosmosAudioBlueprintLibrary_PostGlobalMusic Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AudioEvent = AudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.PostMusicPlayback
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    AudioEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::PostMusicPlayback(class UObject* WorldContextObject, class UAkAudioEvent* AudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "PostMusicPlayback");

	Params::KosmosAudioBlueprintLibrary_PostMusicPlayback Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AudioEvent = AudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.RegisterDefaultListener
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           attachment                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::RegisterDefaultListener(class UObject* WorldContextObject, class AActor* attachment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "RegisterDefaultListener");

	Params::KosmosAudioBlueprintLibrary_RegisterDefaultListener Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.attachment = attachment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.SendGlobalAudioEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AudioEvent                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::SendGlobalAudioEvent(class UObject* WorldContextObject, class FName AudioEvent, class UObject* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "SendGlobalAudioEvent");

	Params::KosmosAudioBlueprintLibrary_SendGlobalAudioEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.AudioEvent = AudioEvent;
	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.SetGlobalAudioSettings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAudioEvent*                    inAudioEvent                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkAuxBus*                        inReverb                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inReverbSend                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             inDefaultSurfaceMaterial                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::SetGlobalAudioSettings(class UObject* WorldContextObject, class UAkAudioEvent* inAudioEvent, class UAkAuxBus* inReverb, float inReverbSend, class FName inDefaultSurfaceMaterial)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "SetGlobalAudioSettings");

	Params::KosmosAudioBlueprintLibrary_SetGlobalAudioSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inAudioEvent = inAudioEvent;
	Parms.inReverb = inReverb;
	Parms.inReverbSend = inReverbSend;
	Parms.inDefaultSurfaceMaterial = inDefaultSurfaceMaterial;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.SpawnAudioComponent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UActorComponent*                  ComponentToSpawnOn                                     (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkComponent*                     ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAkComponent* UKosmosAudioBlueprintLibrary::SpawnAudioComponent(const class UObject* WorldContextObject, class UActorComponent* ComponentToSpawnOn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "SpawnAudioComponent");

	Params::KosmosAudioBlueprintLibrary_SpawnAudioComponent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ComponentToSpawnOn = ComponentToSpawnOn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.StartGlobalMusic
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::StartGlobalMusic(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "StartGlobalMusic");

	Params::KosmosAudioBlueprintLibrary_StartGlobalMusic Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.StopGlobalMusic
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::StopGlobalMusic(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "StopGlobalMusic");

	Params::KosmosAudioBlueprintLibrary_StopGlobalMusic Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.UnbindAudioVolumeGroupEvents
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class FName groupName, const EKosmosAudioVolumeGroupEventType EventType)>&audioVolumeGroupEvents                                 (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::UnbindAudioVolumeGroupEvents(class UObject* WorldContextObject, const TDelegate<void(const class FName groupName, const EKosmosAudioVolumeGroupEventType EventType)>& audioVolumeGroupEvents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "UnbindAudioVolumeGroupEvents");

	Params::KosmosAudioBlueprintLibrary_UnbindAudioVolumeGroupEvents Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.audioVolumeGroupEvents = audioVolumeGroupEvents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.UnbindAudioVolumeTransitionEvents
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class AKosmosAudioVolume* activeAudioVolume, const EKosmosAudioVolumeGroupEventType EventType)>&audioVolumeTransitionEvents                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::UnbindAudioVolumeTransitionEvents(class UObject* WorldContextObject, const TDelegate<void(const class AKosmosAudioVolume* activeAudioVolume, const EKosmosAudioVolumeGroupEventType EventType)>& audioVolumeTransitionEvents)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "UnbindAudioVolumeTransitionEvents");

	Params::KosmosAudioBlueprintLibrary_UnbindAudioVolumeTransitionEvents Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.audioVolumeTransitionEvents = audioVolumeTransitionEvents;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.UnbindGlobalAudioEvent
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(const class FName EventName, const class FString& instigatorName)>&globalAudioEvent                                       (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::UnbindGlobalAudioEvent(class UObject* WorldContextObject, const TDelegate<void(const class FName EventName, const class FString& instigatorName)>& globalAudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "UnbindGlobalAudioEvent");

	Params::KosmosAudioBlueprintLibrary_UnbindGlobalAudioEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.globalAudioEvent = globalAudioEvent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioBlueprintLibrary.UnbindMusicSyncCallback
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TDelegate<void(EKosmosAkMusicCallbackType CallbackType, class UAkMusicSyncCallbackInfo* CallbackInfo)>&Callback                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosAudioBlueprintLibrary::UnbindMusicSyncCallback(class UObject* WorldContextObject, const TDelegate<void(EKosmosAkMusicCallbackType CallbackType, class UAkMusicSyncCallbackInfo* CallbackInfo)>& Callback)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAudioBlueprintLibrary", "UnbindMusicSyncCallback");

	Params::KosmosAudioBlueprintLibrary_UnbindMusicSyncCallback Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Callback = Callback;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioLevelInterface.AudioLevel_PostEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioLevelAudioEvent&Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void IKosmosAudioLevelInterface::AudioLevel_PostEvent(const struct FKosmosAudioLevelAudioEvent& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosAudioLevelInterface", "AudioLevel_PostEvent");

	Params::KosmosAudioLevelInterface_AudioLevel_PostEvent Parms{};

	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioLevelInterface.AudioLevel_PostGenericEvent
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioLevelGenericEvent&Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void IKosmosAudioLevelInterface::AudioLevel_PostGenericEvent(const struct FKosmosAudioLevelGenericEvent& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosAudioLevelInterface", "AudioLevel_PostGenericEvent");

	Params::KosmosAudioLevelInterface_AudioLevel_PostGenericEvent Parms{};

	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioLevelInterface.AudioLevel_SetRTPCValue
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioLevelRTPC&     Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void IKosmosAudioLevelInterface::AudioLevel_SetRTPCValue(const struct FKosmosAudioLevelRTPC& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosAudioLevelInterface", "AudioLevel_SetRTPCValue");

	Params::KosmosAudioLevelInterface_AudioLevel_SetRTPCValue Parms{};

	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioLevelInterface.AudioLevel_SetState
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioLevelState&    Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void IKosmosAudioLevelInterface::AudioLevel_SetState(const struct FKosmosAudioLevelState& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosAudioLevelInterface", "AudioLevel_SetState");

	Params::KosmosAudioLevelInterface_AudioLevel_SetState Parms{};

	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAudioLevelInterface.AudioLevel_SetSwitch
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioLevelSwitch&   Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void IKosmosAudioLevelInterface::AudioLevel_SetSwitch(const struct FKosmosAudioLevelSwitch& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosAudioLevelInterface", "AudioLevel_SetSwitch");

	Params::KosmosAudioLevelInterface_AudioLevel_SetSwitch Parms{};

	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmoAudioLevelLibrary.TriggerAudioLevel_PostEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAudioLevelAudioEvent&Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void UKosmoAudioLevelLibrary::TriggerAudioLevel_PostEvent(class UObject* WorldContextObject, const struct FKosmosAudioLevelAudioEvent& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmoAudioLevelLibrary", "TriggerAudioLevel_PostEvent");

	Params::KosmoAudioLevelLibrary_TriggerAudioLevel_PostEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmoAudioLevelLibrary.TriggerAudioLevel_PostGenericEvent
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAudioLevelGenericEvent&Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void UKosmoAudioLevelLibrary::TriggerAudioLevel_PostGenericEvent(class UObject* WorldContextObject, const struct FKosmosAudioLevelGenericEvent& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmoAudioLevelLibrary", "TriggerAudioLevel_PostGenericEvent");

	Params::KosmoAudioLevelLibrary_TriggerAudioLevel_PostGenericEvent Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmoAudioLevelLibrary.TriggerAudioLevel_SetRTPCValue
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAudioLevelRTPC&     Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void UKosmoAudioLevelLibrary::TriggerAudioLevel_SetRTPCValue(class UObject* WorldContextObject, const struct FKosmosAudioLevelRTPC& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmoAudioLevelLibrary", "TriggerAudioLevel_SetRTPCValue");

	Params::KosmoAudioLevelLibrary_TriggerAudioLevel_SetRTPCValue Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmoAudioLevelLibrary.TriggerAudioLevel_SetState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAudioLevelState&    Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void UKosmoAudioLevelLibrary::TriggerAudioLevel_SetState(class UObject* WorldContextObject, const struct FKosmosAudioLevelState& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmoAudioLevelLibrary", "TriggerAudioLevel_SetState");

	Params::KosmoAudioLevelLibrary_TriggerAudioLevel_SetState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmoAudioLevelLibrary.TriggerAudioLevel_SetSwitch
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosAudioLevelSwitch&   Payload                                                (ConstParm, Parm, NativeAccessSpecifierPublic)

void UKosmoAudioLevelLibrary::TriggerAudioLevel_SetSwitch(class UObject* WorldContextObject, const struct FKosmosAudioLevelSwitch& Payload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmoAudioLevelLibrary", "TriggerAudioLevel_SetSwitch");

	Params::KosmoAudioLevelLibrary_TriggerAudioLevel_SetSwitch Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Payload = std::move(Payload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAkEventsProxy.MusicCallback
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EAkCallbackType                         inCallbackType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAkCallbackInfo*                  inCallbackInfo                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAkEventsProxy::MusicCallback(EAkCallbackType inCallbackType, class UAkCallbackInfo* inCallbackInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAkEventsProxy", "MusicCallback");

	Params::KosmosAkEventsProxy_MusicCallback Parms{};

	Parms.inCallbackType = inCallbackType;
	Parms.inCallbackInfo = inCallbackInfo;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAkEventsProxy.SendAudioVolumeGroupEvent
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      groupName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosAudioVolumeGroupEventType  EventType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAkEventsProxy::SendAudioVolumeGroupEvent(const class FName& groupName, const EKosmosAudioVolumeGroupEventType EventType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAkEventsProxy", "SendAudioVolumeGroupEvent");

	Params::KosmosAkEventsProxy_SendAudioVolumeGroupEvent Parms{};

	Parms.groupName = groupName;
	Parms.EventType = EventType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAkEventsProxy.SendAudioVolumeTransitionEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AKosmosAudioVolume*         AudioVolume                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosAudioVolumeGroupEventType  EventType                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAkEventsProxy::SendAudioVolumeTransitionEvent(const class AKosmosAudioVolume* AudioVolume, const EKosmosAudioVolumeGroupEventType EventType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAkEventsProxy", "SendAudioVolumeTransitionEvent");

	Params::KosmosAkEventsProxy_SendAudioVolumeTransitionEvent Parms{};

	Parms.AudioVolume = AudioVolume;
	Parms.EventType = EventType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAkEventsProxy.SendGlobalAudioEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             EventName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Instigator                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAkEventsProxy::SendGlobalAudioEvent(class FName EventName, class UObject* Instigator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAkEventsProxy", "SendGlobalAudioEvent");

	Params::KosmosAkEventsProxy_SendGlobalAudioEvent Parms{};

	Parms.EventName = EventName;
	Parms.Instigator = Instigator;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAkEventsProxy.SendThreatLevelEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKosmosThreatData&         threatData                                             (Parm, NativeAccessSpecifierPublic)

void UKosmosAkEventsProxy::SendThreatLevelEvent(const struct FKosmosThreatData& threatData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosAkEventsProxy", "SendThreatLevelEvent");

	Params::KosmosAkEventsProxy_SendThreatLevelEvent Parms{};

	Parms.threatData = std::move(threatData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosAutomationLibrary.SkipToNextNode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosAutomationLibrary::SkipToNextNode(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosAutomationLibrary", "SkipToNextNode");

	Params::KosmosAutomationLibrary_SkipToNextNode Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBalancingComponent.IsIdle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBalancingComponent::IsIdle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBalancingComponent", "IsIdle");

	Params::KosmosBalancingComponent_IsIdle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.AddAbilityRestriction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::AddAbilityRestriction(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "AddAbilityRestriction");

	Params::KosmosBaseCharacter_AddAbilityRestriction Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.AI_SetRawInput
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InRawInput                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::AI_SetRawInput(const struct FVector& InRawInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "AI_SetRawInput");

	Params::KosmosBaseCharacter_AI_SetRawInput Parms{};

	Parms.InRawInput = std::move(InRawInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.AI_SetRawLookInput
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InRawInput                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::AI_SetRawLookInput(const struct FVector& InRawInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "AI_SetRawLookInput");

	Params::KosmosBaseCharacter_AI_SetRawLookInput Parms{};

	Parms.InRawInput = std::move(InRawInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.AI_SetRawPressedInteract
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              InRawPressedInteract                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::AI_SetRawPressedInteract(const bool InRawPressedInteract)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "AI_SetRawPressedInteract");

	Params::KosmosBaseCharacter_AI_SetRawPressedInteract Parms{};

	Parms.InRawPressedInteract = InRawPressedInteract;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ApplyAnimationOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAnimationOverridePriority              Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ApplyAnimationOverride(class UCharacterAnimationSlots* Animations, EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ApplyAnimationOverride");

	Params::KosmosBaseCharacter_ApplyAnimationOverride Parms{};

	Parms.Animations = Animations;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ApplyAnimationOverrideLocal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAnimationOverridePriority              Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ApplyAnimationOverrideLocal(class UCharacterAnimationSlots* Animations, EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ApplyAnimationOverrideLocal");

	Params::KosmosBaseCharacter_ApplyAnimationOverrideLocal Parms{};

	Parms.Animations = Animations;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ApplyEffects
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class UGameplayEffect>>&EffectsToApply                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ApplyEffects(const TArray<TSubclassOf<class UGameplayEffect>>& EffectsToApply)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ApplyEffects");

	Params::KosmosBaseCharacter_ApplyEffects Parms{};

	Parms.EffectsToApply = std::move(EffectsToApply);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CallFromPlayPalAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::CallFromPlayPalAction(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CallFromPlayPalAction");

	Params::KosmosBaseCharacter_CallFromPlayPalAction Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CancelAbilityByTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EExecutionStrategy                      ExecutionStrategy                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::CancelAbilityByTag(const struct FGameplayTag& TriggerTag, EExecutionStrategy ExecutionStrategy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CancelAbilityByTag");

	Params::KosmosBaseCharacter_CancelAbilityByTag Parms{};

	Parms.TriggerTag = std::move(TriggerTag);
	Parms.ExecutionStrategy = ExecutionStrategy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CancelAbilityByTag_Internal
// (Final, Native, Public)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::CancelAbilityByTag_Internal(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CancelAbilityByTag_Internal");

	Params::KosmosBaseCharacter_CancelAbilityByTag_Internal Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CancelAbilityByTag_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::CancelAbilityByTag_Multicast(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CancelAbilityByTag_Multicast");

	Params::KosmosBaseCharacter_CancelAbilityByTag_Multicast Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CancelAbilityByTag_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ExecuteOnAll                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::CancelAbilityByTag_Server(const struct FGameplayTag& TriggerTag, bool ExecuteOnAll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CancelAbilityByTag_Server");

	Params::KosmosBaseCharacter_CancelAbilityByTag_Server Parms{};

	Parms.TriggerTag = std::move(TriggerTag);
	Parms.ExecuteOnAll = ExecuteOnAll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CheckHoldingItemOfType
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TSubclassOf<class AActor>               InActorClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::CheckHoldingItemOfType(TSubclassOf<class AActor> InActorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CheckHoldingItemOfType");

	Params::KosmosBaseCharacter_CheckHoldingItemOfType Parms{};

	Parms.InActorClass = InActorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.CheckIfCrouchPressedByToggle
// (Final, Native, Private)

void AKosmosBaseCharacter::CheckIfCrouchPressedByToggle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CheckIfCrouchPressedByToggle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CheckIfGrabPressedByToggle
// (Final, Native, Private)

void AKosmosBaseCharacter::CheckIfGrabPressedByToggle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CheckIfGrabPressedByToggle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CheckIfSprintPressedByToggle
// (Final, Native, Private)

void AKosmosBaseCharacter::CheckIfSprintPressedByToggle()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CheckIfSprintPressedByToggle");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ClearAnimationOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ClearAnimationOverride(class UCharacterAnimationSlots* Animations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ClearAnimationOverride");

	Params::KosmosBaseCharacter_ClearAnimationOverride Parms{};

	Parms.Animations = Animations;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ClearAnimationOverrideLocal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ClearAnimationOverrideLocal(class UCharacterAnimationSlots* Animations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ClearAnimationOverrideLocal");

	Params::KosmosBaseCharacter_ClearAnimationOverrideLocal Parms{};

	Parms.Animations = Animations;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Client_IgnoreActorWhenMoving
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldIgnore                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Client_IgnoreActorWhenMoving(class AActor* InActor, bool bShouldIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Client_IgnoreActorWhenMoving");

	Params::KosmosBaseCharacter_Client_IgnoreActorWhenMoving Parms{};

	Parms.InActor = InActor;
	Parms.bShouldIgnore = bShouldIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Client_IgnoreComponentWhenMoving
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              InComponent                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldIgnore                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Client_IgnoreComponentWhenMoving(class UPrimitiveComponent* InComponent, bool bShouldIgnore)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Client_IgnoreComponentWhenMoving");

	Params::KosmosBaseCharacter_Client_IgnoreComponentWhenMoving Parms{};

	Parms.InComponent = InComponent;
	Parms.bShouldIgnore = bShouldIgnore;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.EndSimpleControlledJump
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::EndSimpleControlledJump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "EndSimpleControlledJump");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ForceReleaseGrab
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EGrabReleaseOptions                     releaseOption                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::ForceReleaseGrab(EGrabReleaseOptions releaseOption)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ForceReleaseGrab");

	Params::KosmosBaseCharacter_ForceReleaseGrab Parms{};

	Parms.releaseOption = releaseOption;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ForceResetPhysics
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::ForceResetPhysics()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ForceResetPhysics");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.GetDummyValueAttribute
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosBaseCharacter::GetDummyValueAttribute()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetDummyValueAttribute");

	Params::KosmosBaseCharacter_GetDummyValueAttribute Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetGetUpAnimation
// (Event, Public, BlueprintEvent)
// Parameters:
// bool                                    bRagdollFaceUpState                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimMontage* AKosmosBaseCharacter::GetGetUpAnimation(bool bRagdollFaceUpState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetGetUpAnimation");

	Params::KosmosBaseCharacter_GetGetUpAnimation Parms{};

	Parms.bRagdollFaceUpState = bRagdollFaceUpState;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetHeldItemOfType
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TSubclassOf<class AActor>               InActorClass                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosBaseCharacter::GetHeldItemOfType(TSubclassOf<class AActor> InActorClass)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetHeldItemOfType");

	Params::KosmosBaseCharacter_GetHeldItemOfType Parms{};

	Parms.InActorClass = InActorClass;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetStartingAbilities
// (Event, Public, BlueprintEvent)
// Parameters:
// TMap<int32, TSubclassOf<class UGameplayAbility>>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, NativeAccessSpecifierPublic)

TMap<int32, TSubclassOf<class UGameplayAbility>> AKosmosBaseCharacter::GetStartingAbilities()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetStartingAbilities");

	Params::KosmosBaseCharacter_GetStartingAbilities Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GrantAbilities
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TMap<int32, TSubclassOf<class UGameplayAbility>>&AbilitiesToGrant                                       (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::GrantAbilities(const TMap<int32, TSubclassOf<class UGameplayAbility>>& AbilitiesToGrant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GrantAbilities");

	Params::KosmosBaseCharacter_GrantAbilities Parms{};

	Parms.AbilitiesToGrant = std::move(AbilitiesToGrant);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.GrantAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UGameplayAbility>     AbilityToGrant                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InputID                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayAbilitySpecHandle       ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayAbilitySpecHandle AKosmosBaseCharacter::GrantAbility(TSubclassOf<class UGameplayAbility> AbilityToGrant, int32 InputID, class UObject* Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GrantAbility");

	Params::KosmosBaseCharacter_GrantAbility Parms{};

	Parms.AbilityToGrant = AbilityToGrant;
	Parms.InputID = InputID;
	Parms.Source = Source;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GrantAbilityAndActivateOnce
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSubclassOf<class UGameplayAbility>     AbilityToGrant                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InputID                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          Source                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGameplayAbilitySpecHandle       ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FGameplayAbilitySpecHandle AKosmosBaseCharacter::GrantAbilityAndActivateOnce(TSubclassOf<class UGameplayAbility> AbilityToGrant, int32 InputID, class UObject* Source)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GrantAbilityAndActivateOnce");

	Params::KosmosBaseCharacter_GrantAbilityAndActivateOnce Parms{};

	Parms.AbilityToGrant = AbilityToGrant;
	Parms.InputID = InputID;
	Parms.Source = Source;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.IsAnimationOverrideActive
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::IsAnimationOverrideActive(class UCharacterAnimationSlots* Animations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "IsAnimationOverrideActive");

	Params::KosmosBaseCharacter_IsAnimationOverrideActive Parms{};

	Parms.Animations = Animations;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.IsCharacterReady
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::IsCharacterReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "IsCharacterReady");

	Params::KosmosBaseCharacter_IsCharacterReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.MakeControlledJump
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Point                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::MakeControlledJump(const struct FVector& Point)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "MakeControlledJump");

	Params::KosmosBaseCharacter_MakeControlledJump Parms{};

	Parms.Point = std::move(Point);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.MakeSimpleControlledJump
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::MakeSimpleControlledJump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "MakeSimpleControlledJump");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.MaxJump
// (Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::MaxJump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "MaxJump");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Multicast_AddMovementSettingsOverride
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UKosmosMovementSettingValueAsset* MovementSettings                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAnimationOverridePriority        Priority                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Multicast_AddMovementSettingsOverride(class UKosmosMovementSettingValueAsset* MovementSettings, const EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Multicast_AddMovementSettingsOverride");

	Params::KosmosBaseCharacter_Multicast_AddMovementSettingsOverride Parms{};

	Parms.MovementSettings = MovementSettings;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Multicast_ClearMovementSettingsOverride
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const class UKosmosMovementSettingValueAsset*MovementSettings                                       (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Multicast_ClearMovementSettingsOverride(const class UKosmosMovementSettingValueAsset* MovementSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Multicast_ClearMovementSettingsOverride");

	Params::KosmosBaseCharacter_Multicast_ClearMovementSettingsOverride Parms{};

	Parms.MovementSettings = MovementSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Multicast_RagdollEnd
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FVector&                   CharacterLocation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Multicast_RagdollEnd(const struct FVector& CharacterLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Multicast_RagdollEnd");

	Params::KosmosBaseCharacter_Multicast_RagdollEnd Parms{};

	Parms.CharacterLocation = std::move(CharacterLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Multicast_RagdollStart
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AKosmosBaseCharacter::Multicast_RagdollStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Multicast_RagdollStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Multicast_SetSprintState
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Multicast_SetSprintState(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Multicast_SetSprintState");

	Params::KosmosBaseCharacter_Multicast_SetSprintState Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.MulticastApplyAnimationOverride
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAnimationOverridePriority              Priority                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::MulticastApplyAnimationOverride(class UCharacterAnimationSlots* Animations, EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "MulticastApplyAnimationOverride");

	Params::KosmosBaseCharacter_MulticastApplyAnimationOverride Parms{};

	Parms.Animations = Animations;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.MulticastClearAnimationOverride
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// class UCharacterAnimationSlots*         Animations                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::MulticastClearAnimationOverride(class UCharacterAnimationSlots* Animations)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "MulticastClearAnimationOverride");

	Params::KosmosBaseCharacter_MulticastClearAnimationOverride Parms{};

	Parms.Animations = Animations;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.NotifyCharacterIsReady
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::NotifyCharacterIsReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "NotifyCharacterIsReady");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OnCapsuleHeightShrinkAmountChanged
// (Final, Native, Protected)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::OnCapsuleHeightShrinkAmountChanged(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OnCapsuleHeightShrinkAmountChanged");

	Params::KosmosBaseCharacter_OnCapsuleHeightShrinkAmountChanged Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OnPawnWidthChanged
// (Final, Native, Protected)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::OnPawnWidthChanged(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OnPawnWidthChanged");

	Params::KosmosBaseCharacter_OnPawnWidthChanged Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OnRep_StartupInfo
// (Final, Native, Public)

void AKosmosBaseCharacter::OnRep_StartupInfo()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OnRep_StartupInfo");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OnStartFromCheckpoint
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             OtherCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::OnStartFromCheckpoint(class AKosmosCheckpoint* InCheckpoint, class AKosmosBaseCharacter* OtherCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OnStartFromCheckpoint");

	Params::KosmosBaseCharacter_OnStartFromCheckpoint Parms{};

	Parms.InCheckpoint = InCheckpoint;
	Parms.OtherCharacter = OtherCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OverrideMovementSetings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosMovementSettingValueAsset* InSettings                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAnimationOverridePriority        Priority                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::OverrideMovementSetings(class UKosmosMovementSettingValueAsset* InSettings, const EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OverrideMovementSetings");

	Params::KosmosBaseCharacter_OverrideMovementSetings Parms{};

	Parms.InSettings = InSettings;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.OverrideMovementSetingsLocal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosMovementSettingValueAsset* InSettings                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EAnimationOverridePriority        Priority                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::OverrideMovementSetingsLocal(class UKosmosMovementSettingValueAsset* InSettings, const EAnimationOverridePriority Priority)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "OverrideMovementSetingsLocal");

	Params::KosmosBaseCharacter_OverrideMovementSetingsLocal Parms{};

	Parms.InSettings = InSettings;
	Parms.Priority = Priority;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.PlaypalGetSprintStatus
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::PlaypalGetSprintStatus()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "PlaypalGetSprintStatus");

	Params::KosmosBaseCharacter_PlaypalGetSprintStatus Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.PlaypalSetSprint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::PlaypalSetSprint(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "PlaypalSetSprint");

	Params::KosmosBaseCharacter_PlaypalSetSprint Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RagdollEnd
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::RagdollEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RagdollEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RagdollStart
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::RagdollStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RagdollStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RemoveAbilityRestriction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RemoveAbilityRestriction(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RemoveAbilityRestriction");

	Params::KosmosBaseCharacter_RemoveAbilityRestriction Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RemoveOverrideMovementSettings
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosMovementSettingValueAsset* InSettings                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RemoveOverrideMovementSettings(class UKosmosMovementSettingValueAsset* InSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RemoveOverrideMovementSettings");

	Params::KosmosBaseCharacter_RemoveOverrideMovementSettings Parms{};

	Parms.InSettings = InSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RemoveOverrideMovementSettingsLocal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosMovementSettingValueAsset* InSettings                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RemoveOverrideMovementSettingsLocal(class UKosmosMovementSettingValueAsset* InSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RemoveOverrideMovementSettingsLocal");

	Params::KosmosBaseCharacter_RemoveOverrideMovementSettingsLocal Parms{};

	Parms.InSettings = InSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RevokeAbilities
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class UGameplayAbility>>&AbilitiesToRevoke                                      (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RevokeAbilities(const TArray<TSubclassOf<class UGameplayAbility>>& AbilitiesToRevoke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RevokeAbilities");

	Params::KosmosBaseCharacter_RevokeAbilities Parms{};

	Parms.AbilitiesToRevoke = std::move(AbilitiesToRevoke);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RevokeAbility
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayAbilitySpecHandle&Handle                                                 (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RevokeAbility(const struct FGameplayAbilitySpecHandle& Handle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RevokeAbility");

	Params::KosmosBaseCharacter_RevokeAbility Parms{};

	Parms.Handle = std::move(Handle);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.RevokeEffects
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<TSubclassOf<class UGameplayEffect>>&EffectsToRevoke                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, UObjectWrapper, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::RevokeEffects(const TArray<TSubclassOf<class UGameplayEffect>>& EffectsToRevoke)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "RevokeEffects");

	Params::KosmosBaseCharacter_RevokeEffects Parms{};

	Parms.EffectsToRevoke = std::move(EffectsToRevoke);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_RagdollEnd
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   CharacterLocation                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Server_RagdollEnd(const struct FVector& CharacterLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_RagdollEnd");

	Params::KosmosBaseCharacter_Server_RagdollEnd Parms{};

	Parms.CharacterLocation = std::move(CharacterLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_RagdollStart
// (Net, NetReliable, Native, Event, Protected, NetServer)

void AKosmosBaseCharacter::Server_RagdollStart()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_RagdollStart");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_SetDesiredGait
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// EKosmosGait                             NewGait                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Server_SetDesiredGait(EKosmosGait NewGait)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_SetDesiredGait");

	Params::KosmosBaseCharacter_Server_SetDesiredGait Parms{};

	Parms.NewGait = NewGait;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_SetMeshLocationDuringRagdoll
// (Net, Native, Event, Protected, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   MeshLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Server_SetMeshLocationDuringRagdoll(const struct FVector& MeshLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_SetMeshLocationDuringRagdoll");

	Params::KosmosBaseCharacter_Server_SetMeshLocationDuringRagdoll Parms{};

	Parms.MeshLocation = std::move(MeshLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_SetReplicatedControlYaw
// (Net, Native, Event, Protected, NetServer)
// Parameters:
// uint16                                  CompressedYaw                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Server_SetReplicatedControlYaw(uint16 CompressedYaw)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_SetReplicatedControlYaw");

	Params::KosmosBaseCharacter_Server_SetReplicatedControlYaw Parms{};

	Parms.CompressedYaw = CompressedYaw;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.Server_SetSprintState
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::Server_SetSprintState(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "Server_SetSprintState");

	Params::KosmosBaseCharacter_Server_SetSprintState Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ServerSetIDoneAnInput
// (Net, NetReliable, Native, Event, Public, NetServer)

void AKosmosBaseCharacter::ServerSetIDoneAnInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ServerSetIDoneAnInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.ServerSetIsReady
// (Net, NetReliable, Native, Event, Public, NetServer)

void AKosmosBaseCharacter::ServerSetIsReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ServerSetIsReady");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetAutoSneaking
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Sneaking                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetAutoSneaking(bool Sneaking)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetAutoSneaking");

	Params::KosmosBaseCharacter_SetAutoSneaking Parms{};

	Parms.Sneaking = Sneaking;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetCrouchEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    IsEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetCrouchEnabled(bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetCrouchEnabled");

	Params::KosmosBaseCharacter_SetCrouchEnabled Parms{};

	Parms.IsEnabled = IsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetDesiredGait
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGait                             NewGait                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetDesiredGait(EKosmosGait NewGait)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetDesiredGait");

	Params::KosmosBaseCharacter_SetDesiredGait Parms{};

	Parms.NewGait = NewGait;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetGait
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGait                             NewGait                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetGait(EKosmosGait NewGait)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetGait");

	Params::KosmosBaseCharacter_SetGait Parms{};

	Parms.NewGait = NewGait;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetJumpingState
// (Final, Native, Protected)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetJumpingState(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetJumpingState");

	Params::KosmosBaseCharacter_SetJumpingState Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetKosmosRoom
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// class UKosmosRoom*                      OldRoom                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      NewRoom                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetKosmosRoom(class UKosmosRoom* OldRoom, class UKosmosRoom* NewRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetKosmosRoom");

	Params::KosmosBaseCharacter_SetKosmosRoom Parms{};

	Parms.OldRoom = OldRoom;
	Parms.NewRoom = NewRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetManualLookAtTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class UKosmosTargetComponent*     TargetComponent                                        (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetManualLookAtTarget(const class UKosmosTargetComponent* TargetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetManualLookAtTarget");

	Params::KosmosBaseCharacter_SetManualLookAtTarget Parms{};

	Parms.TargetComponent = TargetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetMontageMode
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldDisableCollision                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetMontageMode(bool bShouldDisableCollision)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetMontageMode");

	Params::KosmosBaseCharacter_SetMontageMode Parms{};

	Parms.bShouldDisableCollision = bShouldDisableCollision;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetMovementState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosMovementState                    NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetMovementState(EKosmosMovementState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetMovementState");

	Params::KosmosBaseCharacter_SetMovementState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetPlayerInputEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetPlayerInputEnabled(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetPlayerInputEnabled");

	Params::KosmosBaseCharacter_SetPlayerInputEnabled Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetPuzzlePieceDelta
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   Delta                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetPuzzlePieceDelta(float Delta)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetPuzzlePieceDelta");

	Params::KosmosBaseCharacter_SetPuzzlePieceDelta Parms{};

	Parms.Delta = Delta;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetPuzzlePieceValue
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetPuzzlePieceValue(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetPuzzlePieceValue");

	Params::KosmosBaseCharacter_SetPuzzlePieceValue Parms{};

	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.SetSneaking
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Sneaking                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    CanSlide                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::SetSneaking(bool Sneaking, bool CanSlide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "SetSneaking");

	Params::KosmosBaseCharacter_SetSneaking Parms{};

	Parms.Sneaking = Sneaking;
	Parms.CanSlide = CanSlide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.StartupComplete
// (Final, Native, Public, BlueprintCallable)

void AKosmosBaseCharacter::StartupComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "StartupComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.StopCurrentMontage
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   BlendTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::StopCurrentMontage(float BlendTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "StopCurrentMontage");

	Params::KosmosBaseCharacter_StopCurrentMontage Parms{};

	Parms.BlendTime = BlendTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.TriggerAbilityByTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EExecutionStrategy                      ExecutionStrategy                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::TriggerAbilityByTag(const struct FGameplayTag& TriggerTag, EExecutionStrategy ExecutionStrategy)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "TriggerAbilityByTag");

	Params::KosmosBaseCharacter_TriggerAbilityByTag Parms{};

	Parms.TriggerTag = std::move(TriggerTag);
	Parms.ExecutionStrategy = ExecutionStrategy;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.TriggerAbilityByTag_Internal
// (Final, Native, Public)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::TriggerAbilityByTag_Internal(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "TriggerAbilityByTag_Internal");

	Params::KosmosBaseCharacter_TriggerAbilityByTag_Internal Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.TriggerAbilityByTag_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::TriggerAbilityByTag_Multicast(const struct FGameplayTag& TriggerTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "TriggerAbilityByTag_Multicast");

	Params::KosmosBaseCharacter_TriggerAbilityByTag_Multicast Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.TriggerAbilityByTag_Server
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ExecuteOnAll                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBaseCharacter::TriggerAbilityByTag_Server(const struct FGameplayTag& TriggerTag, bool ExecuteOnAll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "TriggerAbilityByTag_Server");

	Params::KosmosBaseCharacter_TriggerAbilityByTag_Server Parms{};

	Parms.TriggerTag = std::move(TriggerTag);
	Parms.ExecuteOnAll = ExecuteOnAll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.CanSprint
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::CanSprint() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CanSprint");

	Params::KosmosBaseCharacter_CanSprint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.CheckPlayerInputEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::CheckPlayerInputEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "CheckPlayerInputEnabled");

	Params::KosmosBaseCharacter_CheckPlayerInputEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetActorFeetLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetActorFeetLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetActorFeetLocation");

	Params::KosmosBaseCharacter_GetActorFeetLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetActualGait
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGait                             AllowedGait                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosGait                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGait AKosmosBaseCharacter::GetActualGait(EKosmosGait AllowedGait) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetActualGait");

	Params::KosmosBaseCharacter_GetActualGait Parms{};

	Parms.AllowedGait = AllowedGait;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetAllowedGait
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGait                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGait AKosmosBaseCharacter::GetAllowedGait() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetAllowedGait");

	Params::KosmosBaseCharacter_GetAllowedGait Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetCharacterLocation
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// EKosmosAtmosphereWorld                  IllusionWorld                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetCharacterLocation(EKosmosAtmosphereWorld IllusionWorld) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetCharacterLocation");

	Params::KosmosBaseCharacter_GetCharacterLocation Parms{};

	Parms.IllusionWorld = IllusionWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetDefaultMovementSettings
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FKosmosMovementSettings          ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FKosmosMovementSettings AKosmosBaseCharacter::GetDefaultMovementSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetDefaultMovementSettings");

	Params::KosmosBaseCharacter_GetDefaultMovementSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetDesiredDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetDesiredDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetDesiredDirection");

	Params::KosmosBaseCharacter_GetDesiredDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetDesiredGait
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGait                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGait AKosmosBaseCharacter::GetDesiredGait() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetDesiredGait");

	Params::KosmosBaseCharacter_GetDesiredGait Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetGait
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosGait                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGait AKosmosBaseCharacter::GetGait() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetGait");

	Params::KosmosBaseCharacter_GetGait Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetInput");

	Params::KosmosBaseCharacter_GetInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetInteractionInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector2D                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector2D AKosmosBaseCharacter::GetInteractionInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetInteractionInput");

	Params::KosmosBaseCharacter_GetInteractionInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetIsCurrentlyBeingKilled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::GetIsCurrentlyBeingKilled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetIsCurrentlyBeingKilled");

	Params::KosmosBaseCharacter_GetIsCurrentlyBeingKilled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetKosmosMovement
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosMovement*                  ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosMovement* AKosmosBaseCharacter::GetKosmosMovement() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetKosmosMovement");

	Params::KosmosBaseCharacter_GetKosmosMovement Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetKosmosRoom
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosRoom*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosRoom* AKosmosBaseCharacter::GetKosmosRoom() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetKosmosRoom");

	Params::KosmosBaseCharacter_GetKosmosRoom Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetLastValidKosmosRoom
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosRoom*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosRoom* AKosmosBaseCharacter::GetLastValidKosmosRoom() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetLastValidKosmosRoom");

	Params::KosmosBaseCharacter_GetLastValidKosmosRoom Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetLookInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetLookInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetLookInput");

	Params::KosmosBaseCharacter_GetLookInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetMovementState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosMovementState                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosMovementState AKosmosBaseCharacter::GetMovementState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetMovementState");

	Params::KosmosBaseCharacter_GetMovementState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetPrevMovementState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosMovementState                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosMovementState AKosmosBaseCharacter::GetPrevMovementState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetPrevMovementState");

	Params::KosmosBaseCharacter_GetPrevMovementState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetRawLookVector
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetRawLookVector() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetRawLookVector");

	Params::KosmosBaseCharacter_GetRawLookVector Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosBaseCharacter::GetSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetSpeed");

	Params::KosmosBaseCharacter_GetSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetUnprocessedInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetUnprocessedInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetUnprocessedInput");

	Params::KosmosBaseCharacter_GetUnprocessedInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.GetUnprocessedLookInput
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosBaseCharacter::GetUnprocessedLookInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "GetUnprocessedLookInput");

	Params::KosmosBaseCharacter_GetUnprocessedLookInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.HasMatchingTag
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGameplayTag&              TriggerTag                                             (Parm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::HasMatchingTag(const struct FGameplayTag& TriggerTag) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "HasMatchingTag");

	Params::KosmosBaseCharacter_HasMatchingTag Parms{};

	Parms.TriggerTag = std::move(TriggerTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.IsLookRestricted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::IsLookRestricted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "IsLookRestricted");

	Params::KosmosBaseCharacter_IsLookRestricted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.IsToolEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::IsToolEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "IsToolEquipped");

	Params::KosmosBaseCharacter_IsToolEquipped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.IsWeaponEquipped
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::IsWeaponEquipped() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "IsWeaponEquipped");

	Params::KosmosBaseCharacter_IsWeaponEquipped Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBaseCharacter.ResetManualLookAtTarget
// (Final, Native, Public, BlueprintCallable, Const)

void AKosmosBaseCharacter::ResetManualLookAtTarget() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "ResetManualLookAtTarget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBaseCharacter.WantsInteraction
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosBaseCharacter::WantsInteraction() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBaseCharacter", "WantsInteraction");

	Params::KosmosBaseCharacter_WantsInteraction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBehaviouralPIPComponent.SetActivationGameplayFlag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bFlag                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBehaviouralPIPComponent::SetActivationGameplayFlag(bool bFlag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBehaviouralPIPComponent", "SetActivationGameplayFlag");

	Params::KosmosBehaviouralPIPComponent_SetActivationGameplayFlag Parms{};

	Parms.bFlag = bFlag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBehaviouralPIPComponent.SetCancelGameplayFlag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bFlag                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBehaviouralPIPComponent::SetCancelGameplayFlag(bool bFlag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBehaviouralPIPComponent", "SetCancelGameplayFlag");

	Params::KosmosBehaviouralPIPComponent_SetCancelGameplayFlag Parms{};

	Parms.bFlag = bFlag;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBehaviouralPIPComponent.IsCurrentlyActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBehaviouralPIPComponent::IsCurrentlyActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBehaviouralPIPComponent", "IsCurrentlyActive");

	Params::KosmosBehaviouralPIPComponent_IsCurrentlyActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBehaviouralPIPComponent.IsMovingToPIP
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBehaviouralPIPComponent::IsMovingToPIP() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBehaviouralPIPComponent", "IsMovingToPIP");

	Params::KosmosBehaviouralPIPComponent_IsMovingToPIP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ApplyTemporaryAtmosphereTargetOverride
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DurationSeconds                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ImmediatelyCompleteBlend                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosAtmosphereWorld                  AtmosWorld                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ApplyTemporaryAtmosphereTargetOverride(class UObject* WorldContextObject, const struct FVector& TargetLocation, float DurationSeconds, bool ImmediatelyCompleteBlend, EKosmosAtmosphereWorld AtmosWorld)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ApplyTemporaryAtmosphereTargetOverride");

	Params::KosmosBlueprintFunctionLibrary_ApplyTemporaryAtmosphereTargetOverride Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.DurationSeconds = DurationSeconds;
	Parms.ImmediatelyCompleteBlend = ImmediatelyCompleteBlend;
	Parms.AtmosWorld = AtmosWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.Automation_ReachedKeyState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    KeyState                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::Automation_ReachedKeyState(class UObject* WorldContextObject, const class FString& KeyState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "Automation_ReachedKeyState");

	Params::KosmosBlueprintFunctionLibrary_Automation_ReachedKeyState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.KeyState = std::move(KeyState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.Automation_RestartState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    RestartState                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::Automation_RestartState(class UObject* WorldContextObject, const class FString& RestartState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "Automation_RestartState");

	Params::KosmosBlueprintFunctionLibrary_Automation_RestartState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.RestartState = std::move(RestartState);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.CanKillPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::CanKillPlayer(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "CanKillPlayer");

	Params::KosmosBlueprintFunctionLibrary_CanKillPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.CheckValidSpawnLocation
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     TestActor                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TestLocation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  TestRotation                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::CheckValidSpawnLocation(class UObject* WorldContextObject, const class AActor* TestActor, const struct FVector& TestLocation, const struct FRotator& TestRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "CheckValidSpawnLocation");

	Params::KosmosBlueprintFunctionLibrary_CheckValidSpawnLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TestActor = TestActor;
	Parms.TestLocation = std::move(TestLocation);
	Parms.TestRotation = std::move(TestRotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.DebugDraw3DArc
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Position                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Forward                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Up                                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Degrees                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             InnerRadius                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             OuterRadius                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Thickness                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FColor&                    ArcColor                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::DebugDraw3DArc(class UObject* WorldContextObject, const struct FVector& Position, const struct FVector& Forward, const struct FVector& Up, const float Degrees, const float InnerRadius, const float OuterRadius, const float Thickness, const struct FColor& ArcColor, float Duration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "DebugDraw3DArc");

	Params::KosmosBlueprintFunctionLibrary_DebugDraw3DArc Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Position = std::move(Position);
	Parms.Forward = std::move(Forward);
	Parms.Up = std::move(Up);
	Parms.Degrees = Degrees;
	Parms.InnerRadius = InnerRadius;
	Parms.OuterRadius = OuterRadius;
	Parms.Thickness = Thickness;
	Parms.ArcColor = std::move(ArcColor);
	Parms.Duration = Duration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.DisableKillPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DurationTime                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::DisableKillPlayer(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn, float DurationTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "DisableKillPlayer");

	Params::KosmosBlueprintFunctionLibrary_DisableKillPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;
	Parms.DurationTime = DurationTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.DoNTimes
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32*                                  OutCount                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Num                                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInitToOne                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::DoNTimes(class UObject* WorldContextObject, const class FString& InKey, int32* OutCount, int32 Num, bool bInitToOne)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "DoNTimes");

	Params::KosmosBlueprintFunctionLibrary_DoNTimes Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.Num = Num;
	Parms.bInitToOne = bInitToOne;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutCount != nullptr)
		*OutCount = Parms.OutCount;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.EnableKillPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::EnableKillPlayer(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "EnableKillPlayer");

	Params::KosmosBlueprintFunctionLibrary_EnableKillPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.FindNextCheckpoint
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCheckpoint*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosCheckpoint* UKosmosBlueprintFunctionLibrary::FindNextCheckpoint(class AKosmosCheckpoint* InCheckpoint)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "FindNextCheckpoint");

	Params::KosmosBlueprintFunctionLibrary_FindNextCheckpoint Parms{};

	Parms.InCheckpoint = InCheckpoint;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ForceInstantAtmosphereBlend
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ForceInstantAtmosphereBlend(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ForceInstantAtmosphereBlend");

	Params::KosmosBlueprintFunctionLibrary_ForceInstantAtmosphereBlend Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ForceStreamingRefresh
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ForceStreamingRefresh(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ForceStreamingRefresh");

	Params::KosmosBlueprintFunctionLibrary_ForceStreamingRefresh Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetAIMovementHelper
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosMoveType                         moveType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosMovementHelper            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FKosmosMovementHelper UKosmosBlueprintFunctionLibrary::GetAIMovementHelper(EKosmosMoveType moveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetAIMovementHelper");

	Params::KosmosBlueprintFunctionLibrary_GetAIMovementHelper Parms{};

	Parms.moveType = moveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetAutoPathInRoom
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      InRoom                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAutomationPathNode*        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosAutomationPathNode* UKosmosBlueprintFunctionLibrary::GetAutoPathInRoom(class UObject* WorldContextObject, class UKosmosRoom* InRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetAutoPathInRoom");

	Params::KosmosBlueprintFunctionLibrary_GetAutoPathInRoom Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRoom = InRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetAutoSkip
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosBlueprintFunctionLibrary::GetAutoSkip()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetAutoSkip");

	Params::KosmosBlueprintFunctionLibrary_GetAutoSkip Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetAutoStory
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosBlueprintFunctionLibrary::GetAutoStory()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetAutoStory");

	Params::KosmosBlueprintFunctionLibrary_GetAutoStory Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetBuildType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosBuildType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosBuildType UKosmosBlueprintFunctionLibrary::GetBuildType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetBuildType");

	Params::KosmosBlueprintFunctionLibrary_GetBuildType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetCheckpointInRoom
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      InRoom                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCheckpoint*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosCheckpoint* UKosmosBlueprintFunctionLibrary::GetCheckpointInRoom(class UObject* WorldContextObject, class UKosmosRoom* InRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetCheckpointInRoom");

	Params::KosmosBlueprintFunctionLibrary_GetCheckpointInRoom Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRoom = InRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetCurrentChapterReachedIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosBlueprintFunctionLibrary::GetCurrentChapterReachedIndex(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetCurrentChapterReachedIndex");

	Params::KosmosBlueprintFunctionLibrary_GetCurrentChapterReachedIndex Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetCurrentLevelName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosLevelNameReference        ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKosmosLevelNameReference UKosmosBlueprintFunctionLibrary::GetCurrentLevelName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetCurrentLevelName");

	Params::KosmosBlueprintFunctionLibrary_GetCurrentLevelName Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetDistanceBetweenKosmosCharacters
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosBlueprintFunctionLibrary::GetDistanceBetweenKosmosCharacters(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetDistanceBetweenKosmosCharacters");

	Params::KosmosBlueprintFunctionLibrary_GetDistanceBetweenKosmosCharacters Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetExposedFloatCurveValueAtTime
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FRuntimeFloatCurve&        Curve                                                  (Parm, NativeAccessSpecifierPublic)
// float                                   Time                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosBlueprintFunctionLibrary::GetExposedFloatCurveValueAtTime(const struct FRuntimeFloatCurve& Curve, float Time)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetExposedFloatCurveValueAtTime");

	Params::KosmosBlueprintFunctionLibrary_GetExposedFloatCurveValueAtTime Parms{};

	Parms.Curve = std::move(Curve);
	Parms.Time = Time;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetGlobalGravityDirection
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosBlueprintFunctionLibrary::GetGlobalGravityDirection(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetGlobalGravityDirection");

	Params::KosmosBlueprintFunctionLibrary_GetGlobalGravityDirection Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetKosmosGameState
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosGameFlowState                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGameFlowState UKosmosBlueprintFunctionLibrary::GetKosmosGameState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetKosmosGameState");

	Params::KosmosBlueprintFunctionLibrary_GetKosmosGameState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetKosmosNavigationSystem
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosNavigationSystem*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosNavigationSystem* UKosmosBlueprintFunctionLibrary::GetKosmosNavigationSystem(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetKosmosNavigationSystem");

	Params::KosmosBlueprintFunctionLibrary_GetKosmosNavigationSystem Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetLevelLocalizedName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    LevelName                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText UKosmosBlueprintFunctionLibrary::GetLevelLocalizedName(class UObject* WorldContextObject, const class FString& LevelName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetLevelLocalizedName");

	Params::KosmosBlueprintFunctionLibrary_GetLevelLocalizedName Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LevelName = std::move(LevelName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetLocalKosmosCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetLocalKosmosCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetLocalKosmosCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetLocalKosmosCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetNonPlayPalCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetNonPlayPalCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetNonPlayPalCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetNonPlayPalCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetOtherKosmosCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetOtherKosmosCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetOtherKosmosCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetOtherKosmosCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetPathBetweenRooms
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosRoom*                      FromRoom                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      ToRoom                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class UKosmosRoom*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UKosmosRoom*> UKosmosBlueprintFunctionLibrary::GetPathBetweenRooms(class UKosmosRoom* FromRoom, class UKosmosRoom* ToRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetPathBetweenRooms");

	Params::KosmosBlueprintFunctionLibrary_GetPathBetweenRooms Parms{};

	Parms.FromRoom = FromRoom;
	Parms.ToRoom = ToRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetPlatform
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosPlatform                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosPlatform UKosmosBlueprintFunctionLibrary::GetPlatform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetPlatform");

	Params::KosmosBlueprintFunctionLibrary_GetPlatform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetPlayPalCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetPlayPalCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetPlayPalCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetPlayPalCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetPrimaryCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetPrimaryCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetPrimaryCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetPrimaryCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetRoomAtLocation
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InPos                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosRoom* UKosmosBlueprintFunctionLibrary::GetRoomAtLocation(class UObject* WorldContextObject, const struct FVector& InPos)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetRoomAtLocation");

	Params::KosmosBlueprintFunctionLibrary_GetRoomAtLocation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InPos = std::move(InPos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetRoomFromLevel
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ALevelScriptActor*          InLevelScript                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosRoom* UKosmosBlueprintFunctionLibrary::GetRoomFromLevel(class UObject* WorldContextObject, const class ALevelScriptActor* InLevelScript)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetRoomFromLevel");

	Params::KosmosBlueprintFunctionLibrary_GetRoomFromLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLevelScript = InLevelScript;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetRoomNameForLocalCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosBlueprintFunctionLibrary::GetRoomNameForLocalCharacter(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetRoomNameForLocalCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetRoomNameForLocalCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.GetSecondaryCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* UKosmosBlueprintFunctionLibrary::GetSecondaryCharacter(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "GetSecondaryCharacter");

	Params::KosmosBlueprintFunctionLibrary_GetSecondaryCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorKosmosCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorKosmosCharacter(const class UObject* WorldContextObject, const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorKosmosCharacter");

	Params::KosmosBlueprintFunctionLibrary_IsActorKosmosCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorLocalCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorLocalCharacter(const class UObject* WorldContextObject, const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorLocalCharacter");

	Params::KosmosBlueprintFunctionLibrary_IsActorLocalCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorPlayer(const class UObject* WorldContextObject, const class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorPlayer");

	Params::KosmosBlueprintFunctionLibrary_IsActorPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorPlaypal
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorPlaypal(const class UObject* WorldContextObject, const class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorPlaypal");

	Params::KosmosBlueprintFunctionLibrary_IsActorPlaypal Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorPrimaryCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorPrimaryCharacter(const class UObject* WorldContextObject, const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorPrimaryCharacter");

	Params::KosmosBlueprintFunctionLibrary_IsActorPrimaryCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsActorSecondaryCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     InActor                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsActorSecondaryCharacter(const class UObject* WorldContextObject, const class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsActorSecondaryCharacter");

	Params::KosmosBlueprintFunctionLibrary_IsActorSecondaryCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsAutoPlay
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsAutoPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsAutoPlay");

	Params::KosmosBlueprintFunctionLibrary_IsAutoPlay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsCharacterPlayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosBaseCharacter*       InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsCharacterPlayer(const class UObject* WorldContextObject, const class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsCharacterPlayer");

	Params::KosmosBlueprintFunctionLibrary_IsCharacterPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsCharacterPlayPal
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosBaseCharacter*       InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsCharacterPlayPal(const class UObject* WorldContextObject, const class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsCharacterPlayPal");

	Params::KosmosBlueprintFunctionLibrary_IsCharacterPlayPal Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsClientActorReady
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// TSoftObjectPtr<class AActor>            ServerActor                                            (Parm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   ClientIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsReady                                                (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   IsRelevant                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bDebug                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsClientActorReady(TSoftObjectPtr<class AActor> ServerActor, uint8 ClientIndex, bool* IsReady, bool* IsRelevant, const bool bDebug)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsClientActorReady");

	Params::KosmosBlueprintFunctionLibrary_IsClientActorReady Parms{};

	Parms.ServerActor = ServerActor;
	Parms.ClientIndex = ClientIndex;
	Parms.bDebug = bDebug;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (IsReady != nullptr)
		*IsReady = Parms.IsReady;

	if (IsRelevant != nullptr)
		*IsRelevant = Parms.IsRelevant;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsDLC01Enabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsDLC01Enabled(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsDLC01Enabled");

	Params::KosmosBlueprintFunctionLibrary_IsDLC01Enabled Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsDLC01Released
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsDLC01Released(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsDLC01Released");

	Params::KosmosBlueprintFunctionLibrary_IsDLC01Released Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsDLC02Enabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsDLC02Enabled(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsDLC02Enabled");

	Params::KosmosBlueprintFunctionLibrary_IsDLC02Enabled Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsDLC02Released
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsDLC02Released(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsDLC02Released");

	Params::KosmosBlueprintFunctionLibrary_IsDLC02Released Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsInEditor
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsInEditor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsInEditor");

	Params::KosmosBlueprintFunctionLibrary_IsInEditor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.IsInFrontend
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::IsInFrontend(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "IsInFrontend");

	Params::KosmosBlueprintFunctionLibrary_IsInFrontend Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.KillAndAttachPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosDeathSettingsAsset*        DeathSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachPoint                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             JointName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         LocationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         RotationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         ScaleRule                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::KillAndAttachPlayerCharacter(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn, class UKosmosDeathSettingsAsset* DeathSettings, class USceneComponent* AttachPoint, class FName JointName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "KillAndAttachPlayerCharacter");

	Params::KosmosBlueprintFunctionLibrary_KillAndAttachPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;
	Parms.DeathSettings = DeathSettings;
	Parms.AttachPoint = AttachPoint;
	Parms.JointName = JointName;
	Parms.LocationRule = LocationRule;
	Parms.RotationRule = RotationRule;
	Parms.ScaleRule = ScaleRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.KillPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FDeathSettings&            DeathSettings                                          (Parm, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::KillPlayer(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn, const struct FDeathSettings& DeathSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "KillPlayer");

	Params::KosmosBlueprintFunctionLibrary_KillPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;
	Parms.DeathSettings = std::move(DeathSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.KillPlayerCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             PlayerPawn                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosDeathSettingsAsset*        DeathSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::KillPlayerCharacter(class UObject* WorldContextObject, class AKosmosBaseCharacter* PlayerPawn, class UKosmosDeathSettingsAsset* DeathSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "KillPlayerCharacter");

	Params::KosmosBlueprintFunctionLibrary_KillPlayerCharacter Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.PlayerPawn = PlayerPawn;
	Parms.DeathSettings = DeathSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.PathIntersectCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UNavigationPath*                  Path                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Radius                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosBlueprintFunctionLibrary::PathIntersectCharacter(class UNavigationPath* Path, class AKosmosBaseCharacter* Character, float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "PathIntersectCharacter");

	Params::KosmosBlueprintFunctionLibrary_PathIntersectCharacter Parms{};

	Parms.Path = Path;
	Parms.Character = Character;
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.PreventMultipleGameInstanceLaunching
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsEnabled                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::PreventMultipleGameInstanceLaunching(class UObject* WorldContextObject, bool bIsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "PreventMultipleGameInstanceLaunching");

	Params::KosmosBlueprintFunctionLibrary_PreventMultipleGameInstanceLaunching Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bIsEnabled = bIsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ReadTexelsFromRenderTarget
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTextureRenderTarget2D*           SourceRenderTarget                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   X                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Y                                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Width                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Height                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FLinearColor>             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FLinearColor> UKosmosBlueprintFunctionLibrary::ReadTexelsFromRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* SourceRenderTarget, int32 X, int32 Y, int32 Width, int32 Height)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ReadTexelsFromRenderTarget");

	Params::KosmosBlueprintFunctionLibrary_ReadTexelsFromRenderTarget Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SourceRenderTarget = SourceRenderTarget;
	Parms.X = X;
	Parms.Y = Y;
	Parms.Width = Width;
	Parms.Height = Height;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.RenderTargetUpdateStaticTexture2DEditorOnly
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UTexture2D*                       DestTexure                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTextureRenderTarget2D*           SrcRenderTarget                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETextureCompressionSettings             CompressionSettings                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ETextureMipGenSettings                  MipSettings                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::RenderTargetUpdateStaticTexture2DEditorOnly(class UTexture2D* DestTexure, class UTextureRenderTarget2D* SrcRenderTarget, ETextureCompressionSettings CompressionSettings, ETextureMipGenSettings MipSettings)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "RenderTargetUpdateStaticTexture2DEditorOnly");

	Params::KosmosBlueprintFunctionLibrary_RenderTargetUpdateStaticTexture2DEditorOnly Parms{};

	Parms.DestTexure = DestTexure;
	Parms.SrcRenderTarget = SrcRenderTarget;
	Parms.CompressionSettings = CompressionSettings;
	Parms.MipSettings = MipSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ResetComponentVelocity_EngineersOnly
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  SceneComponent                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ResetComponentVelocity_EngineersOnly(class UObject* WorldContextObject, class USceneComponent* SceneComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ResetComponentVelocity_EngineersOnly");

	Params::KosmosBlueprintFunctionLibrary_ResetComponentVelocity_EngineersOnly Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SceneComponent = SceneComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ResetDoNTimes
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ResetDoNTimes(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ResetDoNTimes");

	Params::KosmosBlueprintFunctionLibrary_ResetDoNTimes Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.SetAllowedToPause
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InAllowPausing                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::SetAllowedToPause(class UObject* WorldContextObject, bool InAllowPausing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "SetAllowedToPause");

	Params::KosmosBlueprintFunctionLibrary_SetAllowedToPause Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InAllowPausing = InAllowPausing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.SetGlobalGravityDirection
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InGravity                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::SetGlobalGravityDirection(const struct FVector& InGravity, class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "SetGlobalGravityDirection");

	Params::KosmosBlueprintFunctionLibrary_SetGlobalGravityDirection Parms{};

	Parms.InGravity = std::move(InGravity);
	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.SetKosmosGameState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosGameFlowState                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::SetKosmosGameState(class UObject* WorldContextObject, EKosmosGameFlowState InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "SetKosmosGameState");

	Params::KosmosBlueprintFunctionLibrary_SetKosmosGameState Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.SwitchOnBuildType
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EKosmosBuildType*                       Build                                                  (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::SwitchOnBuildType(EKosmosBuildType* Build)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "SwitchOnBuildType");

	Params::KosmosBlueprintFunctionLibrary_SwitchOnBuildType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Build != nullptr)
		*Build = Parms.Build;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.SwitchOnPlatform
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// EKosmosPlatform*                        Platform                                               (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::SwitchOnPlatform(EKosmosPlatform* Platform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "SwitchOnPlatform");

	Params::KosmosBlueprintFunctionLibrary_SwitchOnPlatform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Platform != nullptr)
		*Platform = Parms.Platform;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.ToggleMarketingCameraState
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::ToggleMarketingCameraState(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "ToggleMarketingCameraState");

	Params::KosmosBlueprintFunctionLibrary_ToggleMarketingCameraState Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.TryPauseGame
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InShouldToggle                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InShouldPause                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::TryPauseGame(class UObject* WorldContextObject, bool InShouldToggle, bool InShouldPause)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "TryPauseGame");

	Params::KosmosBlueprintFunctionLibrary_TryPauseGame Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InShouldToggle = InShouldToggle;
	Parms.InShouldPause = InShouldPause;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.TryStumbleCharacter
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StumbleDuration                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::TryStumbleCharacter(class AKosmosBaseCharacter* InCharacter, float StumbleDuration)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "TryStumbleCharacter");

	Params::KosmosBlueprintFunctionLibrary_TryStumbleCharacter Parms{};

	Parms.InCharacter = InCharacter;
	Parms.StumbleDuration = StumbleDuration;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBlueprintFunctionLibrary.UnToggleGrab
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBlueprintFunctionLibrary::UnToggleGrab(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosBlueprintFunctionLibrary", "UnToggleGrab");

	Params::KosmosBlueprintFunctionLibrary_UnToggleGrab Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.AI_StashPending
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::AI_StashPending(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "AI_StashPending");

	Params::KosmosWeaponAndToolBase_AI_StashPending Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.ApplyAnimationOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         InAnimationSlot                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::ApplyAnimationOverride(class UCharacterAnimationSlots* InAnimationSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "ApplyAnimationOverride");

	Params::KosmosWeaponAndToolBase_ApplyAnimationOverride Parms{};

	Parms.InAnimationSlot = InAnimationSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.ClearAnimationOverride
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UCharacterAnimationSlots*         InAnimationSlot                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::ClearAnimationOverride(class UCharacterAnimationSlots* InAnimationSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "ClearAnimationOverride");

	Params::KosmosWeaponAndToolBase_ClearAnimationOverride Parms{};

	Parms.InAnimationSlot = InAnimationSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.GetMainTarget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class UKosmosTargetComponent>ReturnValue                                            (ExportObject, Parm, OutParm, ReturnParm, InstancedReference, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class UKosmosTargetComponent> AKosmosWeaponAndToolBase::GetMainTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "GetMainTarget");

	Params::KosmosWeaponAndToolBase_GetMainTarget Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWeaponAndToolBase.Multicast_EquipItem
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// bool                                    bEquip                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::Multicast_EquipItem(bool bEquip, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "Multicast_EquipItem");

	Params::KosmosWeaponAndToolBase_Multicast_EquipItem Parms{};

	Parms.bEquip = bEquip;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.Multicast_UseItem
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// bool                                    bUse                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::Multicast_UseItem(bool bUse, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "Multicast_UseItem");

	Params::KosmosWeaponAndToolBase_Multicast_UseItem Parms{};

	Parms.bUse = bUse;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.NotifyStashFinished
// (Final, Native, Protected, BlueprintCallable)

void AKosmosWeaponAndToolBase::NotifyStashFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "NotifyStashFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.NotifyTakeoutFinished
// (Native, Protected, BlueprintCallable)

void AKosmosWeaponAndToolBase::NotifyTakeoutFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "NotifyTakeoutFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.NotifyTurnOffFinished
// (Native, Protected, BlueprintCallable)

void AKosmosWeaponAndToolBase::NotifyTurnOffFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "NotifyTurnOffFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.NotifyTurnOnFinished
// (Native, Protected, BlueprintCallable)

void AKosmosWeaponAndToolBase::NotifyTurnOnFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "NotifyTurnOnFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.ReleaseItem
// (Final, Native, Public, BlueprintCallable)

void AKosmosWeaponAndToolBase::ReleaseItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "ReleaseItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.RequestItem
// (Final, Native, Public, BlueprintCallable)

void AKosmosWeaponAndToolBase::RequestItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "RequestItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.SetToolHidden
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::SetToolHidden(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "SetToolHidden");

	Params::KosmosWeaponAndToolBase_SetToolHidden Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.SetupDropItem
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UStaticMeshComponent*             DropItemComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::SetupDropItem(class UStaticMeshComponent* DropItemComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "SetupDropItem");

	Params::KosmosWeaponAndToolBase_SetupDropItem Parms{};

	Parms.DropItemComponent = DropItemComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.StoreCustomMovementTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FTransform&                InTransform                                            (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::StoreCustomMovementTransform(const struct FTransform& InTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "StoreCustomMovementTransform");

	Params::KosmosWeaponAndToolBase_StoreCustomMovementTransform Parms{};

	Parms.InTransform = std::move(InTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.StoreCustomMovementTransform_Multicast
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FTransform&                InTransform                                            (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::StoreCustomMovementTransform_Multicast(const struct FTransform& InTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "StoreCustomMovementTransform_Multicast");

	Params::KosmosWeaponAndToolBase_StoreCustomMovementTransform_Multicast Parms{};

	Parms.InTransform = std::move(InTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.StoreCustomMovementTransform_Server
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults)
// Parameters:
// const struct FTransform&                InTransform                                            (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::StoreCustomMovementTransform_Server(const struct FTransform& InTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "StoreCustomMovementTransform_Server");

	Params::KosmosWeaponAndToolBase_StoreCustomMovementTransform_Server Parms{};

	Parms.InTransform = std::move(InTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.UseItem
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bUse                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bForce                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWeaponAndToolBase::UseItem(bool bUse, bool bForce)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "UseItem");

	Params::KosmosWeaponAndToolBase_UseItem Parms{};

	Parms.bUse = bUse;
	Parms.bForce = bForce;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponAndToolBase.GetSprintingWhenStarted
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWeaponAndToolBase::GetSprintingWhenStarted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "GetSprintingWhenStarted");

	Params::KosmosWeaponAndToolBase_GetSprintingWhenStarted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWeaponAndToolBase.GetToolHidden
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWeaponAndToolBase::GetToolHidden() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "GetToolHidden");

	Params::KosmosWeaponAndToolBase_GetToolHidden Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWeaponAndToolBase.GetWantsToStash
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWeaponAndToolBase::GetWantsToStash() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "GetWantsToStash");

	Params::KosmosWeaponAndToolBase_GetWantsToStash Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWeaponAndToolBase.IsInUse
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWeaponAndToolBase::IsInUse() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "IsInUse");

	Params::KosmosWeaponAndToolBase_IsInUse Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWeaponAndToolBase.ShouldStashEarly
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWeaponAndToolBase::ShouldStashEarly() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWeaponAndToolBase", "ShouldStashEarly");

	Params::KosmosWeaponAndToolBase_ShouldStashEarly Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBow.Client_SetShouldStrafe
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Client_SetShouldStrafe(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Client_SetShouldStrafe");

	Params::KosmosBow_Client_SetShouldStrafe Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Fire
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   FireVelocity                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosTargetComponent*           TargetComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Fire(const struct FVector& FireVelocity, class UKosmosTargetComponent* TargetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Fire");

	Params::KosmosBow_Fire Parms{};

	Parms.FireVelocity = std::move(FireVelocity);
	Parms.TargetComponent = TargetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Multicast_Fire
// (Net, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FVector&                   FireVelocity                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosTargetComponent*           TargetComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Multicast_Fire(const struct FVector& FireVelocity, class UKosmosTargetComponent* TargetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Multicast_Fire");

	Params::KosmosBow_Multicast_Fire Parms{};

	Parms.FireVelocity = std::move(FireVelocity);
	Parms.TargetComponent = TargetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Multicast_SetBowUsageState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// EKosmosBowUsage                         InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Multicast_SetBowUsageState(EKosmosBowUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Multicast_SetBowUsageState");

	Params::KosmosBow_Multicast_SetBowUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Server_Fire
// (Net, NetReliable, Native, Event, Protected, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   FireVelocity                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosTargetComponent*           TargetComponent                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Server_Fire(const struct FVector& FireVelocity, class UKosmosTargetComponent* TargetComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Server_Fire");

	Params::KosmosBow_Server_Fire Parms{};

	Parms.FireVelocity = std::move(FireVelocity);
	Parms.TargetComponent = TargetComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Server_SetBowhUsageState
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// EKosmosBowUsage                         InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Server_SetBowhUsageState(EKosmosBowUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Server_SetBowhUsageState");

	Params::KosmosBow_Server_SetBowhUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Server_SetShouldStrafe
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Server_SetShouldStrafe(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Server_SetShouldStrafe");

	Params::KosmosBow_Server_SetShouldStrafe Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.Server_UpdateTarget
// (Net, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// class UKosmosTargetComponent*           NewTarget                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::Server_UpdateTarget(class UKosmosTargetComponent* NewTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "Server_UpdateTarget");

	Params::KosmosBow_Server_UpdateTarget Parms{};

	Parms.NewTarget = NewTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBow.SetBowUsageState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosBowUsage                         InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBow::SetBowUsageState(EKosmosBowUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBow", "SetBowUsageState");

	Params::KosmosBow_SetBowUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBowProjectile.OnArrowHit
// (Event, Public, BlueprintEvent)

void AKosmosBowProjectile::OnArrowHit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "OnArrowHit");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosBowProjectile.OnArrowOverlap
// (Event, Public, BlueprintEvent)

void AKosmosBowProjectile::OnArrowOverlap()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "OnArrowOverlap");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosBowProjectile.OnHit
// (Final, Native, Protected, HasOutParams, HasDefaults)
// Parameters:
// class AActor*                           SelfActor                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosBowProjectile::OnHit(class AActor* SelfActor, class AActor* OtherActor, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "OnHit");

	Params::KosmosBowProjectile_OnHit Parms{};

	Parms.SelfActor = SelfActor;
	Parms.OtherActor = OtherActor;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBowProjectile.OnOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosBowProjectile::OnOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "OnOverlap");

	Params::KosmosBowProjectile_OnOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBowProjectile.SetCurrentState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EBowProjectileState                     InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosBowProjectile::SetCurrentState(EBowProjectileState InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "SetCurrentState");

	Params::KosmosBowProjectile_SetCurrentState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBowProjectile.GetCurrentState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EBowProjectileState                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EBowProjectileState AKosmosBowProjectile::GetCurrentState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBowProjectile", "GetCurrentState");

	Params::KosmosBowProjectile_GetCurrentState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosBreathingComponent.KillPlayer
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosDeathSettingsAsset*        deathType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBreathingComponent::KillPlayer(class UKosmosDeathSettingsAsset* deathType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreathingComponent", "KillPlayer");

	Params::KosmosBreathingComponent_KillPlayer Parms{};

	Parms.deathType = deathType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreathingComponent.SetUnderWater
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBreathingComponent::SetUnderWater(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreathingComponent", "SetUnderWater");

	Params::KosmosBreathingComponent_SetUnderWater Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBreathingComponent.TakeBreath
// (Final, Native, Public, BlueprintCallable)

void UKosmosBreathingComponent::TakeBreath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBreathingComponent", "TakeBreath");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBuoyancyComponent.OnBeginOverlap
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UKosmosBuoyancyComponent::OnBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBuoyancyComponent", "OnBeginOverlap");

	Params::KosmosBuoyancyComponent_OnBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosBuoyancyComponent.OnEndOverlap
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              OverlappedComp                                         (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosBuoyancyComponent::OnEndOverlap(class UPrimitiveComponent* OverlappedComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosBuoyancyComponent", "OnEndOverlap");

	Params::KosmosBuoyancyComponent_OnEndOverlap Parms{};

	Parms.OverlappedComp = OverlappedComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterCarriablePickup
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosCarriable*           Carriable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterCarriablePickup(const class AActor* InCharacter, const class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterCarriablePickup");

	Params::KosmosCharacterActionInterface_OnCharacterCarriablePickup Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterCarriableReleased
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosCarriable*           Carriable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterCarriableReleased(const class AActor* InCharacter, const class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterCarriableReleased");

	Params::KosmosCharacterActionInterface_OnCharacterCarriableReleased Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterCarriableThrown
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosCarriable*           Carriable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterCarriableThrown(const class AActor* InCharacter, const class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterCarriableThrown");

	Params::KosmosCharacterActionInterface_OnCharacterCarriableThrown Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterClimbOverTopLadder
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosLadder*              Ladder                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterClimbOverTopLadder(const class AKosmosBaseCharacter* Character, const class AKosmosLadder* Ladder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterClimbOverTopLadder");

	Params::KosmosCharacterActionInterface_OnCharacterClimbOverTopLadder Parms{};

	Parms.Character = Character;
	Parms.Ladder = Ladder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterCrouched
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterCrouched(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterCrouched");

	Params::KosmosCharacterActionInterface_OnCharacterCrouched Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterDeath
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterDeath(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterDeath");

	Params::KosmosCharacterActionInterface_OnCharacterDeath Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterFinishStandFromSpawning
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterFinishStandFromSpawning(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterFinishStandFromSpawning");

	Params::KosmosCharacterActionInterface_OnCharacterFinishStandFromSpawning Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterGestured
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    gestureID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterGestured(const class AKosmosBaseCharacter* Character, const class FString& gestureID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterGestured");

	Params::KosmosCharacterActionInterface_OnCharacterGestured Parms{};

	Parms.Character = Character;
	Parms.gestureID = std::move(gestureID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterGrabbedFreeDraggable
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosDraggable*           Draggable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterGrabbedFreeDraggable(const class AActor* InCharacter, const class AKosmosDraggable* Draggable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterGrabbedFreeDraggable");

	Params::KosmosCharacterActionInterface_OnCharacterGrabbedFreeDraggable Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Draggable = Draggable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterHandholdGrabbed
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       grabber                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterHandholdGrabbed(const class AKosmosBaseCharacter* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterHandholdGrabbed");

	Params::KosmosCharacterActionInterface_OnCharacterHandholdGrabbed Parms{};

	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterHandholdReleased
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       grabber                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterHandholdReleased(const class AKosmosBaseCharacter* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterHandholdReleased");

	Params::KosmosCharacterActionInterface_OnCharacterHandholdReleased Parms{};

	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterJumped
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterJumped(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterJumped");

	Params::KosmosCharacterActionInterface_OnCharacterJumped Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterLanded
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosFallType                         FallType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterLanded(const class AKosmosBaseCharacter* Character, EKosmosFallType FallType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterLanded");

	Params::KosmosCharacterActionInterface_OnCharacterLanded Parms{};

	Parms.Character = Character;
	Parms.FallType = FallType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterReleasedFreeDraggable
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AActor*                     InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosDraggable*           Draggable                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterReleasedFreeDraggable(const class AActor* InCharacter, const class AKosmosDraggable* Draggable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterReleasedFreeDraggable");

	Params::KosmosCharacterActionInterface_OnCharacterReleasedFreeDraggable Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Draggable = Draggable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterRoomChanged
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      OldRoom                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      NewRoom                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterRoomChanged(const class AKosmosBaseCharacter* Character, class UKosmosRoom* OldRoom, class UKosmosRoom* NewRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterRoomChanged");

	Params::KosmosCharacterActionInterface_OnCharacterRoomChanged Parms{};

	Parms.Character = Character;
	Parms.OldRoom = OldRoom;
	Parms.NewRoom = NewRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterSpawned
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterSpawned(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterSpawned");

	Params::KosmosCharacterActionInterface_OnCharacterSpawned Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterStartMovement
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterStartMovement(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterStartMovement");

	Params::KosmosCharacterActionInterface_OnCharacterStartMovement Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnCharacterUncrouched
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnCharacterUncrouched(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnCharacterUncrouched");

	Params::KosmosCharacterActionInterface_OnCharacterUncrouched Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnInventoryItemCollected
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosInventoryItemNameReference&Item                                                   (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnInventoryItemCollected(const class AKosmosBaseCharacter* Character, const struct FKosmosInventoryItemNameReference& Item)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnInventoryItemCollected");

	Params::KosmosCharacterActionInterface_OnInventoryItemCollected Parms{};

	Parms.Character = Character;
	Parms.Item = std::move(Item);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnToolEquipped
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         Tool                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnToolEquipped(const class AKosmosBaseCharacter* Character, class AKosmosWeaponAndToolBase* Tool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnToolEquipped");

	Params::KosmosCharacterActionInterface_OnToolEquipped Parms{};

	Parms.Character = Character;
	Parms.Tool = Tool;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnToolStashed
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         Tool                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnToolStashed(const class AKosmosBaseCharacter* Character, class AKosmosWeaponAndToolBase* Tool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnToolStashed");

	Params::KosmosCharacterActionInterface_OnToolStashed Parms{};

	Parms.Character = Character;
	Parms.Tool = Tool;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnWeaponEquipped
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnWeaponEquipped(const class AKosmosBaseCharacter* Character, class AKosmosWeaponAndToolBase* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnWeaponEquipped");

	Params::KosmosCharacterActionInterface_OnWeaponEquipped Parms{};

	Parms.Character = Character;
	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterActionInterface.OnWeaponStashed
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         Weapon                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosCharacterActionInterface::OnWeaponStashed(const class AKosmosBaseCharacter* Character, class AKosmosWeaponAndToolBase* Weapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosCharacterActionInterface", "OnWeaponStashed");

	Params::KosmosCharacterActionInterface_OnWeaponStashed Parms{};

	Parms.Character = Character;
	Parms.Weapon = Weapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterCarriablePickup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCarriable*                 Carriable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterCarriablePickup(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterCarriablePickup");

	Params::KosmosCharaterActionLibrary_TriggerCharacterCarriablePickup Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterCarriableReleased
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCarriable*                 Carriable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterCarriableReleased(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterCarriableReleased");

	Params::KosmosCharaterActionLibrary_TriggerCharacterCarriableReleased Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterCarriableThrown
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCarriable*                 Carriable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterCarriableThrown(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterCarriableThrown");

	Params::KosmosCharaterActionLibrary_TriggerCharacterCarriableThrown Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterClimbOverTopLadder
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosLadder*                    Ladder                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterClimbOverTopLadder(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosLadder* Ladder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterClimbOverTopLadder");

	Params::KosmosCharaterActionLibrary_TriggerCharacterClimbOverTopLadder Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Ladder = Ladder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterCrouched
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterCrouched(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterCrouched");

	Params::KosmosCharaterActionLibrary_TriggerCharacterCrouched Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterDeath
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterDeath(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterDeath");

	Params::KosmosCharaterActionLibrary_TriggerCharacterDeath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterFinishStandingFromSpawning
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterFinishStandingFromSpawning(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterFinishStandingFromSpawning");

	Params::KosmosCharaterActionLibrary_TriggerCharacterFinishStandingFromSpawning Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterGestered
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    gestureID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterGestered(class UObject* WorldContextObject, class AActor* InCharacter, const class FString& gestureID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterGestered");

	Params::KosmosCharaterActionLibrary_TriggerCharacterGestered Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.gestureID = std::move(gestureID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterGrabbedFreeDraggable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosDraggable*                 Draggable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterGrabbedFreeDraggable(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosDraggable* Draggable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterGrabbedFreeDraggable");

	Params::KosmosCharaterActionLibrary_TriggerCharacterGrabbedFreeDraggable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Draggable = Draggable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterHandholdGrabbed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InGrabber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterHandholdGrabbed(class UObject* WorldContextObject, class AActor* InGrabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterHandholdGrabbed");

	Params::KosmosCharaterActionLibrary_TriggerCharacterHandholdGrabbed Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InGrabber = InGrabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterHandholdReleased
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InGrabber                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterHandholdReleased(class UObject* WorldContextObject, class AActor* InGrabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterHandholdReleased");

	Params::KosmosCharaterActionLibrary_TriggerCharacterHandholdReleased Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InGrabber = InGrabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterJumpped
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterJumpped(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterJumpped");

	Params::KosmosCharaterActionLibrary_TriggerCharacterJumpped Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterLanded
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosFallType                         inFallType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterLanded(class UObject* WorldContextObject, class AActor* InCharacter, EKosmosFallType inFallType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterLanded");

	Params::KosmosCharaterActionLibrary_TriggerCharacterLanded Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.inFallType = inFallType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterReleasedFreeDraggable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosDraggable*                 Draggable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterReleasedFreeDraggable(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosDraggable* Draggable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterReleasedFreeDraggable");

	Params::KosmosCharaterActionLibrary_TriggerCharacterReleasedFreeDraggable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.Draggable = Draggable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterRoomChange
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      InNewRoom                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosRoom*                      InOldRoom                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterRoomChange(class UObject* WorldContextObject, class AActor* InCharacter, class UKosmosRoom* InNewRoom, class UKosmosRoom* InOldRoom)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterRoomChange");

	Params::KosmosCharaterActionLibrary_TriggerCharacterRoomChange Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InNewRoom = InNewRoom;
	Parms.InOldRoom = InOldRoom;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterSpawned
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterSpawned(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterSpawned");

	Params::KosmosCharaterActionLibrary_TriggerCharacterSpawned Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterStartMovement
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterStartMovement(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterStartMovement");

	Params::KosmosCharaterActionLibrary_TriggerCharacterStartMovement Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerCharacterUncrouched
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerCharacterUncrouched(class UObject* WorldContextObject, class AActor* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerCharacterUncrouched");

	Params::KosmosCharaterActionLibrary_TriggerCharacterUncrouched Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerInventoryItemCollected
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerInventoryItemCollected(class UObject* WorldContextObject, class AActor* InCharacter, const struct FKosmosInventoryItemNameReference& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerInventoryItemCollected");

	Params::KosmosCharaterActionLibrary_TriggerInventoryItemCollected Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InItem = std::move(InItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerToolEquipped
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         InTool                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerToolEquipped(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosWeaponAndToolBase* InTool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerToolEquipped");

	Params::KosmosCharaterActionLibrary_TriggerToolEquipped Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InTool = InTool;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerToolStashed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         InTool                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerToolStashed(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosWeaponAndToolBase* InTool)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerToolStashed");

	Params::KosmosCharaterActionLibrary_TriggerToolStashed Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InTool = InTool;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerWeaponEquipped
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         InWeapon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerWeaponEquipped(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosWeaponAndToolBase* InWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerWeaponEquipped");

	Params::KosmosCharaterActionLibrary_TriggerWeaponEquipped Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InWeapon = InWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharaterActionLibrary.TriggerWeaponStashed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosWeaponAndToolBase*         InWeapon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharaterActionLibrary::TriggerWeaponStashed(class UObject* WorldContextObject, class AActor* InCharacter, class AKosmosWeaponAndToolBase* InWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharaterActionLibrary", "TriggerWeaponStashed");

	Params::KosmosCharaterActionLibrary_TriggerWeaponStashed Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCharacter = InCharacter;
	Parms.InWeapon = InWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterToAntagonist.OnAnimationAudioNotify
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName&                      EventName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnAnimationAudioNotify(const class FName& EventName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnAnimationAudioNotify");

	Params::KosmosCharacterToAntagonist_OnAnimationAudioNotify Parms{};

	Parms.EventName = EventName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.OnPawnGestureEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName&                      Event                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsOverriden                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DistanceToTarget                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnPawnGestureEvent(const class FName& Event, bool bIsOverriden, float DistanceToTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnPawnGestureEvent");

	Params::KosmosCharacterToAntagonist_OnPawnGestureEvent Parms{};

	Parms.Event = Event;
	Parms.bIsOverriden = bIsOverriden;
	Parms.DistanceToTarget = DistanceToTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.OnPawnJumpEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnPawnJumpEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnPawnJumpEvent");

	Params::KosmosCharacterToAntagonist_OnPawnJumpEvent Parms{};

	Parms.FallData = std::move(FallData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.OnPawnLandEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnPawnLandEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnPawnLandEvent");

	Params::KosmosCharacterToAntagonist_OnPawnLandEvent Parms{};

	Parms.FallData = std::move(FallData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.OnWeaponToolEquipEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosCharacterAntagonistoWeaponToolEquipEvent&EventInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnWeaponToolEquipEvent(const struct FKosmosCharacterAntagonistoWeaponToolEquipEvent& EventInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnWeaponToolEquipEvent");

	Params::KosmosCharacterToAntagonist_OnWeaponToolEquipEvent Parms{};

	Parms.EventInfo = std::move(EventInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.OnWeaponToolUsageEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosCharacterAntagonistoWeaponToolUsageEvent&EventInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::OnWeaponToolUsageEvent(const struct FKosmosCharacterAntagonistoWeaponToolUsageEvent& EventInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "OnWeaponToolUsageEvent");

	Params::KosmosCharacterToAntagonist_OnWeaponToolUsageEvent Parms{};

	Parms.EventInfo = std::move(EventInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterToAntagonist.UpdateFloorMaterial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             forwardOffset                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             traceLength                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterToAntagonist::UpdateFloorMaterial(const float forwardOffset, const float traceLength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "UpdateFloorMaterial");

	Params::KosmosCharacterToAntagonist_UpdateFloorMaterial Parms{};

	Parms.forwardOffset = forwardOffset;
	Parms.traceLength = traceLength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterToAntagonist.GetCharacterMovementSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosCharacterToAntagonist::GetCharacterMovementSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "GetCharacterMovementSpeed");

	Params::KosmosCharacterToAntagonist_GetCharacterMovementSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterToAntagonist.IsCrouching
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosCharacterToAntagonist::IsCrouching() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "IsCrouching");

	Params::KosmosCharacterToAntagonist_IsCrouching Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterToAntagonist.IsHiddenToAntagonist
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosCharacterToAntagonist::IsHiddenToAntagonist() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterToAntagonist", "IsHiddenToAntagonist");

	Params::KosmosCharacterToAntagonist_IsHiddenToAntagonist Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterAudioComponent.GetSurfaceName
// (Final, Native, Static, Protected, BlueprintCallable)
// Parameters:
// EPhysicalSurface                        Surface                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UKosmosCharacterAudioComponent::GetSurfaceName(EPhysicalSurface Surface)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharacterAudioComponent", "GetSurfaceName");

	Params::KosmosCharacterAudioComponent_GetSurfaceName Parms{};

	Parms.Surface = Surface;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterAudioComponent.AnimationAudioNotify
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName&                      EventName                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UAkAudioEvent*              AudioEvent                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::AnimationAudioNotify(const class FName& EventName, const class UAkAudioEvent* AudioEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "AnimationAudioNotify");

	Params::KosmosCharacterAudioComponent_AnimationAudioNotify Parms{};

	Parms.EventName = EventName;
	Parms.AudioEvent = AudioEvent;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.CharacterAudioEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// EKosmosCharacterAudioEventSource        eventSource                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosCharacterAudioEventType          EventType                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             customType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::CharacterAudioEvent(EKosmosCharacterAudioEventSource eventSource, EKosmosCharacterAudioEventType EventType, class FName customType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "CharacterAudioEvent");

	Params::KosmosCharacterAudioComponent_CharacterAudioEvent Parms{};

	Parms.eventSource = eventSource;
	Parms.EventType = EventType;
	Parms.customType = customType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.FindVertexPaintData
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// bool*                                   hasPaintData                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FColor*                          paintData                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::FindVertexPaintData(bool* hasPaintData, struct FColor* paintData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "FindVertexPaintData");

	Params::KosmosCharacterAudioComponent_FindVertexPaintData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (hasPaintData != nullptr)
		*hasPaintData = Parms.hasPaintData;

	if (paintData != nullptr)
		*paintData = std::move(Parms.paintData);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnAudioVolumeTransition
// (Final, Native, Protected)
// Parameters:
// class AKosmosAudioVolume*               AudioVolume                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnAudioVolumeTransition(class AKosmosAudioVolume* AudioVolume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnAudioVolumeTransition");

	Params::KosmosCharacterAudioComponent_OnAudioVolumeTransition Parms{};

	Parms.AudioVolume = AudioVolume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterAudioComponent.OnCapsuleBeginOverlap
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnCapsuleBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnCapsuleBeginOverlap");

	Params::KosmosCharacterAudioComponent_OnCapsuleBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnCapsuleEndOverlap
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnCapsuleEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnCapsuleEndOverlap");

	Params::KosmosCharacterAudioComponent_OnCapsuleEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnGrabHangableEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosCharacterAudioComponent::OnGrabHangableEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnGrabHangableEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnHangTraversalEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioHangTraversalEvent&EventInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnHangTraversalEvent(const struct FKosmosAudioHangTraversalEvent& EventInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnHangTraversalEvent");

	Params::KosmosCharacterAudioComponent_OnHangTraversalEvent Parms{};

	Parms.EventInfo = std::move(EventInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnCrouchEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bIsCrouching                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnCrouchEvent(const bool bIsCrouching)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnCrouchEvent");

	Params::KosmosCharacterAudioComponent_OnPawnCrouchEvent Parms{};

	Parms.bIsCrouching = bIsCrouching;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnGestureEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName&                      Event                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsOverriden                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DistanceToTarget                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnGestureEvent(const class FName& Event, bool bIsOverriden, float DistanceToTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnGestureEvent");

	Params::KosmosCharacterAudioComponent_OnPawnGestureEvent Parms{};

	Parms.Event = Event;
	Parms.bIsOverriden = bIsOverriden;
	Parms.DistanceToTarget = DistanceToTarget;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnGrabEndEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EGrabEventType                    grabType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnGrabEndEvent(const EGrabEventType grabType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnGrabEndEvent");

	Params::KosmosCharacterAudioComponent_OnPawnGrabEndEvent Parms{};

	Parms.grabType = grabType;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnGrabStartEvent
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EGrabEventType                    grabType                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    Material                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   grabLocation                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AActor*                     grabbedActor                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnGrabStartEvent(const EGrabEventType grabType, const class FString& Material, const struct FVector& grabLocation, const class AActor* grabbedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnGrabStartEvent");

	Params::KosmosCharacterAudioComponent_OnPawnGrabStartEvent Parms{};

	Parms.grabType = grabType;
	Parms.Material = std::move(Material);
	Parms.grabLocation = std::move(grabLocation);
	Parms.grabbedActor = grabbedActor;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnJumpEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnJumpEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnJumpEvent");

	Params::KosmosCharacterAudioComponent_OnPawnJumpEvent Parms{};

	Parms.FallData = std::move(FallData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnLandEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnLandEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnLandEvent");

	Params::KosmosCharacterAudioComponent_OnPawnLandEvent Parms{};

	Parms.FallData = std::move(FallData);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnPickupHeldEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UKosmosPickupComponent*           Pickup                                                 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnPickupHeldEvent(class UKosmosPickupComponent* Pickup)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnPickupHeldEvent");

	Params::KosmosCharacterAudioComponent_OnPawnPickupHeldEvent Parms{};

	Parms.Pickup = Pickup;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnSlideEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bIsSliding                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPawnSlideEvent(const bool bIsSliding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnSlideEvent");

	Params::KosmosCharacterAudioComponent_OnPawnSlideEvent Parms{};

	Parms.bIsSliding = bIsSliding;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnSpawnEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosCharacterAudioComponent::OnPawnSpawnEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnSpawnEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnTurnOnSpotEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosCharacterAudioComponent::OnPawnTurnOnSpotEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnTurnOnSpotEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPawnWalkStartEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosCharacterAudioComponent::OnPawnWalkStartEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPawnWalkStartEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnPhysicaMaterialChanged
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// const class FName                       Surface                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bSurfaceAdded                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnPhysicaMaterialChanged(const class FName Surface, const bool bSurfaceAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnPhysicaMaterialChanged");

	Params::KosmosCharacterAudioComponent_OnPhysicaMaterialChanged Parms{};

	Parms.Surface = Surface;
	Parms.bSurfaceAdded = bSurfaceAdded;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnReleaseHangableEvent
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosCharacterAudioComponent::OnReleaseHangableEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnReleaseHangableEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnWeaponToolEquipEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioWeaponToolEquipEvent&EventInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnWeaponToolEquipEvent(const struct FKosmosAudioWeaponToolEquipEvent& EventInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnWeaponToolEquipEvent");

	Params::KosmosCharacterAudioComponent_OnWeaponToolEquipEvent Parms{};

	Parms.EventInfo = std::move(EventInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.OnWeaponToolUsageEvent
// (Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosAudioWeaponToolUsageEvent&EventInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::OnWeaponToolUsageEvent(const struct FKosmosAudioWeaponToolUsageEvent& EventInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "OnWeaponToolUsageEvent");

	Params::KosmosCharacterAudioComponent_OnWeaponToolUsageEvent Parms{};

	Parms.EventInfo = std::move(EventInfo);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCharacterAudioComponent.UpdateFloorMaterial
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const float                             forwardOffset                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             traceLength                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::UpdateFloorMaterial(const float forwardOffset, const float traceLength)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "UpdateFloorMaterial");

	Params::KosmosCharacterAudioComponent_UpdateFloorMaterial Parms{};

	Parms.forwardOffset = forwardOffset;
	Parms.traceLength = traceLength;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterAudioComponent.UpdateOverlappingSurfaces
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const TArray<EPhysicalSurface>&         surfaceTypesToFind                                     (Parm, ZeroConstructor, NativeAccessSpecifierPublic)
// float                                   SphereRadius                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECollisionChannel                       CollisionChannel                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterAudioComponent::UpdateOverlappingSurfaces(const TArray<EPhysicalSurface>& surfaceTypesToFind, float SphereRadius, ECollisionChannel CollisionChannel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "UpdateOverlappingSurfaces");

	Params::KosmosCharacterAudioComponent_UpdateOverlappingSurfaces Parms{};

	Parms.surfaceTypesToFind = std::move(surfaceTypesToFind);
	Parms.SphereRadius = SphereRadius;
	Parms.CollisionChannel = CollisionChannel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterAudioComponent.FindGrabMaterial
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   TraceStart                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TraceEnd                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EPhysicalSurface                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EPhysicalSurface UKosmosCharacterAudioComponent::FindGrabMaterial(const struct FVector& TraceStart, const struct FVector& TraceEnd) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterAudioComponent", "FindGrabMaterial");

	Params::KosmosCharacterAudioComponent_FindGrabMaterial Parms{};

	Parms.TraceStart = std::move(TraceStart);
	Parms.TraceEnd = std::move(TraceEnd);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterDeathComponent.CompleteKill
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDeathInfo&                DeathInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::CompleteKill(const struct FDeathInfo& DeathInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "CompleteKill");

	Params::KosmosCharacterDeathComponent_CompleteKill Parms{};

	Parms.DeathInfo = std::move(DeathInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.DisableKill
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   TimeoutInSec                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosCharacterDeathComponent::DisableKill(float TimeoutInSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "DisableKill");

	Params::KosmosCharacterDeathComponent_DisableKill Parms{};

	Parms.TimeoutInSec = TimeoutInSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterDeathComponent.EnableKill
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// int32                                   KillHandle                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::EnableKill(int32 KillHandle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "EnableKill");

	Params::KosmosCharacterDeathComponent_EnableKill Parms{};

	Parms.KillHandle = KillHandle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.Kill_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FDeathInfo&                DeathInfo                                              (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachPoint                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             JointName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         LocationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         RotationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         ScaleRule                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::Kill_Multicast(const struct FDeathInfo& DeathInfo, class USceneComponent* AttachPoint, class FName JointName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "Kill_Multicast");

	Params::KosmosCharacterDeathComponent_Kill_Multicast Parms{};

	Parms.DeathInfo = std::move(DeathInfo);
	Parms.AttachPoint = AttachPoint;
	Parms.JointName = JointName;
	Parms.LocationRule = LocationRule;
	Parms.RotationRule = RotationRule;
	Parms.ScaleRule = ScaleRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.Kill_Server
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// class UKosmosDeathSettingsAsset*        DeathSettings                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachPoint                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             JointName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         LocationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         RotationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         ScaleRule                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::Kill_Server(class UKosmosDeathSettingsAsset* DeathSettings, class USceneComponent* AttachPoint, class FName JointName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "Kill_Server");

	Params::KosmosCharacterDeathComponent_Kill_Server Parms{};

	Parms.DeathSettings = DeathSettings;
	Parms.AttachPoint = AttachPoint;
	Parms.JointName = JointName;
	Parms.LocationRule = LocationRule;
	Parms.RotationRule = RotationRule;
	Parms.ScaleRule = ScaleRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.OnKill
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FDeathInfo&                DeathInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::OnKill(const struct FDeathInfo& DeathInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "OnKill");

	Params::KosmosCharacterDeathComponent_OnKill Parms{};

	Parms.DeathInfo = std::move(DeathInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.RespawnPlayers
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FDeathInfo&                DeathInfo                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::RespawnPlayers(const struct FDeathInfo& DeathInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "RespawnPlayers");

	Params::KosmosCharacterDeathComponent_RespawnPlayers Parms{};

	Parms.DeathInfo = std::move(DeathInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterDeathComponent.SecondaryKill_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FDeathInfo&                DeathInfo                                              (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class USceneComponent*                  AttachPoint                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             JointName                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         LocationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         RotationRule                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAttachmentRule                         ScaleRule                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterDeathComponent::SecondaryKill_Multicast(const struct FDeathInfo& DeathInfo, class USceneComponent* AttachPoint, class FName JointName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterDeathComponent", "SecondaryKill_Multicast");

	Params::KosmosCharacterDeathComponent_SecondaryKill_Multicast Parms{};

	Parms.DeathInfo = std::move(DeathInfo);
	Parms.AttachPoint = AttachPoint;
	Parms.JointName = JointName;
	Parms.LocationRule = LocationRule;
	Parms.RotationRule = RotationRule;
	Parms.ScaleRule = ScaleRule;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterFootstepsComponent.GetSurfaceName
// (Final, Native, Static, Protected, BlueprintCallable)
// Parameters:
// EPhysicalSurface                        Surface                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UKosmosCharacterFootstepsComponent::GetSurfaceName(EPhysicalSurface Surface)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosCharacterFootstepsComponent", "GetSurfaceName");

	Params::KosmosCharacterFootstepsComponent_GetSurfaceName Parms{};

	Parms.Surface = Surface;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharacterFootstepsComponent.OnPawnJumpEvent
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterFootstepsComponent::OnPawnJumpEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterFootstepsComponent", "OnPawnJumpEvent");

	Params::KosmosCharacterFootstepsComponent_OnPawnJumpEvent Parms{};

	Parms.FallData = std::move(FallData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterFootstepsComponent.OnPawnLandEvent
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosFallData&           FallData                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCharacterFootstepsComponent::OnPawnLandEvent(const struct FKosmosFallData& FallData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterFootstepsComponent", "OnPawnLandEvent");

	Params::KosmosCharacterFootstepsComponent_OnPawnLandEvent Parms{};

	Parms.FallData = std::move(FallData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterFootstepsComponent.SetUpdateTrails
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    ShouldUpdate                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterFootstepsComponent::SetUpdateTrails(bool ShouldUpdate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterFootstepsComponent", "SetUpdateTrails");

	Params::KosmosCharacterFootstepsComponent_SetUpdateTrails Parms{};

	Parms.ShouldUpdate = ShouldUpdate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharacterFootstepsComponent.TriggerFootStep
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosFootstep_Type                    StepType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosFootstep_Foot                    Foot                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCharacterFootstepsComponent::TriggerFootStep(EKosmosFootstep_Type StepType, EKosmosFootstep_Foot Foot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharacterFootstepsComponent", "TriggerFootStep");

	Params::KosmosCharacterFootstepsComponent_TriggerFootStep Parms{};

	Parms.StepType = StepType;
	Parms.Foot = Foot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCharactersSubsystem.GetActivePuppetEncounter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosPuppetEncounterVolume*     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosPuppetEncounterVolume* UKosmosCharactersSubsystem::GetActivePuppetEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharactersSubsystem", "GetActivePuppetEncounter");

	Params::KosmosCharactersSubsystem_GetActivePuppetEncounter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCharactersSubsystem.GetPIPManager
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosPIPManager*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPIPManager* UKosmosCharactersSubsystem::GetPIPManager()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCharactersSubsystem", "GetPIPManager");

	Params::KosmosCharactersSubsystem_GetPIPManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheatManager.CheckpointResume
// (Final, Exec, Native, Public)

void UKosmosCheatManager::CheckpointResume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "CheckpointResume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.CheckpointSnapshot
// (Final, Exec, Native, Public)

void UKosmosCheatManager::CheckpointSnapshot()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "CheckpointSnapshot");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.IncrementAchievementProgress
// (Final, Exec, Native, Public)
// Parameters:
// const class FString&                    AchievementName                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Increment                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheatManager::IncrementAchievementProgress(const class FString& AchievementName, int32 Increment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "IncrementAchievementProgress");

	Params::KosmosCheatManager_IncrementAchievementProgress Parms{};

	Parms.AchievementName = std::move(AchievementName);
	Parms.Increment = Increment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KillAllPlayers
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KillAllPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KillAllPlayers");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KillPlayer
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KillPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KillPlayer");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KillPrimaryCharacter
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KillPrimaryCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KillPrimaryCharacter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KillSecondaryCharacter
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KillSecondaryCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KillSecondaryCharacter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KosmosTeleportPlayer
// (Final, Native, Public)
// Parameters:
// class APawn*                            PawnToTeleport                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bToggleDebugCamera                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheatManager::KosmosTeleportPlayer(class APawn* PawnToTeleport, bool bToggleDebugCamera)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KosmosTeleportPlayer");

	Params::KosmosCheatManager_KosmosTeleportPlayer Parms{};

	Parms.PawnToTeleport = PawnToTeleport;
	Parms.bToggleDebugCamera = bToggleDebugCamera;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KosmosTeleportPlaypal
// (Final, Native, Public)

void UKosmosCheatManager::KosmosTeleportPlaypal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KosmosTeleportPlaypal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KosmosToggleDebugCamera
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KosmosToggleDebugCamera()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KosmosToggleDebugCamera");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KosmosToggleDebugMenu
// (Final, Native, Public)

void UKosmosCheatManager::KosmosToggleDebugMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KosmosToggleDebugMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.KosmosToggleMarketingCamera
// (Final, Exec, Native, Public)

void UKosmosCheatManager::KosmosToggleMarketingCamera()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "KosmosToggleMarketingCamera");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheatManager.ShowOnlyNavLinks
// (Final, Exec, Native, Public)

void UKosmosCheatManager::ShowOnlyNavLinks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheatManager", "ShowOnlyNavLinks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.OnResume
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCheckpoint::OnResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "OnResume");

	Params::KosmosCheckpoint_OnResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.OnSnapshot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCheckpoint::OnSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "OnSnapshot");

	Params::KosmosCheckpoint_OnSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.ResetCheckpoint
// (Final, Native, Public, BlueprintCallable)

void AKosmosCheckpoint::ResetCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "ResetCheckpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCheckpoint::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "SetBounds");

	Params::KosmosCheckpoint_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCheckpoint::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "SetBoxExtent");

	Params::KosmosCheckpoint_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpoint.GetPrimaryCharacterStartTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AKosmosCheckpoint::GetPrimaryCharacterStartTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "GetPrimaryCharacterStartTransform");

	Params::KosmosCheckpoint_GetPrimaryCharacterStartTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpoint.GetPrimaryCharacterTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AKosmosCheckpoint::GetPrimaryCharacterTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "GetPrimaryCharacterTransform");

	Params::KosmosCheckpoint_GetPrimaryCharacterTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpoint.GetSecondaryCharacterStartTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AKosmosCheckpoint::GetSecondaryCharacterStartTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "GetSecondaryCharacterStartTransform");

	Params::KosmosCheckpoint_GetSecondaryCharacterStartTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpoint.GetSecondaryCharacterTransform
// (Native, Event, Public, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform AKosmosCheckpoint::GetSecondaryCharacterTransform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpoint", "GetSecondaryCharacterTransform");

	Params::KosmosCheckpoint_GetSecondaryCharacterTransform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetBool
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InDefault                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosCheckpointReader::GetBool(const class FString& InKey, bool InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetBool");

	Params::KosmosCheckpointReader_GetBool Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetByte
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   InDefault                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

uint8 UKosmosCheckpointReader::GetByte(const class FString& InKey, uint8 InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetByte");

	Params::KosmosCheckpointReader_GetByte Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetFloat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InDefault                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosCheckpointReader::GetFloat(const class FString& InKey, float InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetFloat");

	Params::KosmosCheckpointReader_GetFloat Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetInt
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   InDefault                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosCheckpointReader::GetInt(const class FString& InKey, int32 InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetInt");

	Params::KosmosCheckpointReader_GetInt Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetInt64
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   InDefault                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int64 UKosmosCheckpointReader::GetInt64(const class FString& InKey, int64 InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetInt64");

	Params::KosmosCheckpointReader_GetInt64 Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetName
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InDefault                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UKosmosCheckpointReader::GetName(const class FString& InKey, const class FName& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetName");

	Params::KosmosCheckpointReader_GetName Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = InDefault;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetName2
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UKosmosCheckpointReader::GetName2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetName2");

	Params::KosmosCheckpointReader_GetName2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetRotator
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  InDefault                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UKosmosCheckpointReader::GetRotator(const class FString& InKey, const struct FRotator& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetRotator");

	Params::KosmosCheckpointReader_GetRotator Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = std::move(InDefault);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetRotator2
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UKosmosCheckpointReader::GetRotator2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetRotator2");

	Params::KosmosCheckpointReader_GetRotator2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetSoftObjectPtr
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSoftObjectPtr<class AActor>            ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AActor> UKosmosCheckpointReader::GetSoftObjectPtr(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetSoftObjectPtr");

	Params::KosmosCheckpointReader_GetSoftObjectPtr Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetString
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InDefault                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosCheckpointReader::GetString(const class FString& InKey, const class FString& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetString");

	Params::KosmosCheckpointReader_GetString Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = std::move(InDefault);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetString2
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosCheckpointReader::GetString2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetString2");

	Params::KosmosCheckpointReader_GetString2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetStringArray
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            InDefault                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UKosmosCheckpointReader::GetStringArray(const class FString& InKey, const TArray<class FString>& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetStringArray");

	Params::KosmosCheckpointReader_GetStringArray Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = std::move(InDefault);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetStringArray2
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UKosmosCheckpointReader::GetStringArray2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetStringArray2");

	Params::KosmosCheckpointReader_GetStringArray2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetTransform
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                InDefault                                              (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UKosmosCheckpointReader::GetTransform(const class FString& InKey, const struct FTransform& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetTransform");

	Params::KosmosCheckpointReader_GetTransform Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = std::move(InDefault);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetTransform2
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UKosmosCheckpointReader::GetTransform2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetTransform2");

	Params::KosmosCheckpointReader_GetTransform2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetVector
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InDefault                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosCheckpointReader::GetVector(const class FString& InKey, const struct FVector& InDefault)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetVector");

	Params::KosmosCheckpointReader_GetVector Parms{};

	Parms.InKey = std::move(InKey);
	Parms.InDefault = std::move(InDefault);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointReader.GetVector2
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosCheckpointReader::GetVector2(const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointReader", "GetVector2");

	Params::KosmosCheckpointReader_GetVector2 Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCheckpointWriter.SetBool
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetBool(const class FString& InKey, bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetBool");

	Params::KosmosCheckpointWriter_SetBool Parms{};

	Parms.InKey = std::move(InKey);
	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetByte
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetByte(const class FString& InKey, uint8 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetByte");

	Params::KosmosCheckpointWriter_SetByte Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetFloat
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetFloat(const class FString& InKey, float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetFloat");

	Params::KosmosCheckpointWriter_SetFloat Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetInt
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetInt(const class FString& InKey, int32 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetInt");

	Params::KosmosCheckpointWriter_SetInt Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetInt64
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int64                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetInt64(const class FString& InKey, int64 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetInt64");

	Params::KosmosCheckpointWriter_SetInt64 Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetName
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      inValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetName(const class FString& InKey, const class FName& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetName");

	Params::KosmosCheckpointWriter_SetName Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetRotator
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  inValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetRotator(const class FString& InKey, const struct FRotator& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetRotator");

	Params::KosmosCheckpointWriter_SetRotator Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetSoftObjectPtr
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TSoftObjectPtr<class AActor>&     inValue                                                (ConstParm, Parm, OutParm, ReferenceParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetSoftObjectPtr(const class FString& InKey, const TSoftObjectPtr<class AActor>& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetSoftObjectPtr");

	Params::KosmosCheckpointWriter_SetSoftObjectPtr Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetString
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    inValue                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetString(const class FString& InKey, const class FString& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetString");

	Params::KosmosCheckpointWriter_SetString Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetStringArray
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class FString>&            inValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetStringArray(const class FString& InKey, const TArray<class FString>& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetStringArray");

	Params::KosmosCheckpointWriter_SetStringArray Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetTransform
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                inValue                                                (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetTransform(const class FString& InKey, const struct FTransform& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetTransform");

	Params::KosmosCheckpointWriter_SetTransform Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointWriter.SetVector
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   inValue                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCheckpointWriter::SetVector(const class FString& InKey, const struct FVector& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointWriter", "SetVector");

	Params::KosmosCheckpointWriter_SetVector Parms{};

	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCheckpointComponent.SetCheckpointResumeComplete
// (Final, Native, Public, BlueprintCallable)

void UKosmosCheckpointComponent::SetCheckpointResumeComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCheckpointComponent", "SetCheckpointResumeComplete");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.ClimbableBaseComponent.GetClosestLocationInfo
// (Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    mustBeClimbable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   minimumDistanceFromEdge                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outForward                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UClimbableBaseComponent::GetClosestLocationInfo(const struct FVector& TargetLocation, bool mustBeClimbable, float minimumDistanceFromEdge, struct FVector* OutLocation, struct FVector* outForward) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("ClimbableBaseComponent", "GetClosestLocationInfo");

	Params::ClimbableBaseComponent_GetClosestLocationInfo Parms{};

	Parms.TargetLocation = std::move(TargetLocation);
	Parms.mustBeClimbable = mustBeClimbable;
	Parms.minimumDistanceFromEdge = minimumDistanceFromEdge;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLocation != nullptr)
		*OutLocation = std::move(Parms.OutLocation);

	if (outForward != nullptr)
		*outForward = std::move(Parms.outForward);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.FreezeOnClimbable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosClimbingInterface::FreezeOnClimbable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "FreezeOnClimbable");

	Params::KosmosClimbingInterface_FreezeOnClimbable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.Multicast_GrabEndError
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults)
// Parameters:
// const struct FVector&                   CorrectLocation                                        (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosClimbingInterface::Multicast_GrabEndError(const struct FVector& CorrectLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "Multicast_GrabEndError");

	Params::KosmosClimbingInterface_Multicast_GrabEndError Parms{};

	Parms.CorrectLocation = std::move(CorrectLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosClimbingInterface.NotifyOnLanded
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosClimbingInterface::NotifyOnLanded(const struct FHitResult& Hit, class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "NotifyOnLanded");

	Params::KosmosClimbingInterface_NotifyOnLanded Parms{};

	Parms.Hit = std::move(Hit);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosClimbingInterface.OnJumpChanged
// (Final, Native, Private)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosClimbingInterface::OnJumpChanged(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "OnJumpChanged");

	Params::KosmosClimbingInterface_OnJumpChanged Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosClimbingInterface.UnfreezeOnClimbable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosClimbingInterface::UnfreezeOnClimbable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "UnfreezeOnClimbable");

	Params::KosmosClimbingInterface_UnfreezeOnClimbable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetAIClimbDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   InTo                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIgnorePlayer                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EClimbMoveDirection                     CurrentDirection                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EClimbMoveDirection                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EClimbMoveDirection UKosmosClimbingInterface::GetAIClimbDirection(const struct FVector& InTo, bool bIgnorePlayer, EClimbMoveDirection CurrentDirection) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetAIClimbDirection");

	Params::KosmosClimbingInterface_GetAIClimbDirection Parms{};

	Parms.InTo = std::move(InTo);
	Parms.bIgnorePlayer = bIgnorePlayer;
	Parms.CurrentDirection = CurrentDirection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetBodyOffset
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosClimbingInterface::GetBodyOffset() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetBodyOffset");

	Params::KosmosClimbingInterface_GetBodyOffset Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetClimbDirectionFromInput
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EClimbMoveDirection                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EClimbMoveDirection UKosmosClimbingInterface::GetClimbDirectionFromInput() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetClimbDirectionFromInput");

	Params::KosmosClimbingInterface_GetClimbDirectionFromInput Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetClimbState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EClimbState                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EClimbState UKosmosClimbingInterface::GetClimbState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetClimbState");

	Params::KosmosClimbingInterface_GetClimbState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetCurrentClimbableComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosClimbableComponent*        ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosClimbableComponent* UKosmosClimbingInterface::GetCurrentClimbableComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetCurrentClimbableComponent");

	Params::KosmosClimbingInterface_GetCurrentClimbableComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetDesiredClimbAccelration
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FGrabPoint&                GrabPoint                                              (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosClimbingInterface::GetDesiredClimbAccelration(const struct FGrabPoint& GrabPoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetDesiredClimbAccelration");

	Params::KosmosClimbingInterface_GetDesiredClimbAccelration Parms{};

	Parms.GrabPoint = std::move(GrabPoint);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.GetLastMoveDirection
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EClimbMoveDirection                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EClimbMoveDirection UKosmosClimbingInterface::GetLastMoveDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "GetLastMoveDirection");

	Params::KosmosClimbingInterface_GetLastMoveDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosClimbingInterface.JumpOffTurnRight
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosClimbingInterface::JumpOffTurnRight() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosClimbingInterface", "JumpOffTurnRight");

	Params::KosmosClimbingInterface_JumpOffTurnRight Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCollectableComponent.Client_AchievementCollect
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void UKosmosCollectableComponent::Client_AchievementCollect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCollectableComponent", "Client_AchievementCollect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCollectableComponent.CollectItem
// (Final, Native, Public, BlueprintCallable)

void UKosmosCollectableComponent::CollectItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCollectableComponent", "CollectItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCollectableComponent.CollectItemLocally
// (Final, Native, Public, BlueprintCallable)

void UKosmosCollectableComponent::CollectItemLocally()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCollectableComponent", "CollectItemLocally");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCollectableComponent.CollectStatusAndCheckCollectableList
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FKosmosCollectableNameReference>&CollectableList                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosCollectableComponent::CollectStatusAndCheckCollectableList(const TArray<struct FKosmosCollectableNameReference>& CollectableList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCollectableComponent", "CollectStatusAndCheckCollectableList");

	Params::KosmosCollectableComponent_CollectStatusAndCheckCollectableList Parms{};

	Parms.CollectableList = std::move(CollectableList);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosComplianceLayerNinSwitch.IsUsingSwitchProController
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   PlayerIndex                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosComplianceLayerNinSwitch::IsUsingSwitchProController(int32 PlayerIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosComplianceLayerNinSwitch", "IsUsingSwitchProController");

	Params::KosmosComplianceLayerNinSwitch_IsUsingSwitchProController Parms{};

	Parms.PlayerIndex = PlayerIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUIWidget.StartSmoothUpdateBackgroundColour
// (Final, Native, Protected)

void UKosmosUIWidget::StartSmoothUpdateBackgroundColour()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUIWidget", "StartSmoothUpdateBackgroundColour");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUIWidget.SynchronizeAccessibilityOptions
// (Native, Protected, BlueprintCallable)

void UKosmosUIWidget::SynchronizeAccessibilityOptions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUIWidget", "SynchronizeAccessibilityOptions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUIWidget.UpdateAccessibilityColour
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void UKosmosUIWidget::UpdateAccessibilityColour()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUIWidget", "UpdateAccessibilityColour");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosControllerDetectionWidget.AllowMouseOrKeyboardToContinue
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosControllerDetectionWidget::AllowMouseOrKeyboardToContinue()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "AllowMouseOrKeyboardToContinue");

	Params::KosmosControllerDetectionWidget_AllowMouseOrKeyboardToContinue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosControllerDetectionWidget.ClearLocalUserID
// (Final, Native, Public, BlueprintCallable)

void UKosmosControllerDetectionWidget::ClearLocalUserID()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "ClearLocalUserID");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosControllerDetectionWidget.HandleKeyDown
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKeyEvent&                 KeyEvent                                               (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FEventReply                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FEventReply UKosmosControllerDetectionWidget::HandleKeyDown(const struct FKeyEvent& KeyEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "HandleKeyDown");

	Params::KosmosControllerDetectionWidget_HandleKeyDown Parms{};

	Parms.KeyEvent = std::move(KeyEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosControllerDetectionWidget.InitializeWidget
// (Final, Native, Public, BlueprintCallable)

void UKosmosControllerDetectionWidget::InitializeWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "InitializeWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosControllerDetectionWidget.OnButtonDetectedEvent
// (Event, Protected, BlueprintEvent)

void UKosmosControllerDetectionWidget::OnButtonDetectedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "OnButtonDetectedEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosControllerDetectionWidget.OnCancelButtonDetectedEvent
// (Event, Protected, BlueprintEvent)

void UKosmosControllerDetectionWidget::OnCancelButtonDetectedEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "OnCancelButtonDetectedEvent");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosControllerDetectionWidget.OnTryingToSignInWithADifferentAccount
// (Event, Protected, BlueprintEvent)

void UKosmosControllerDetectionWidget::OnTryingToSignInWithADifferentAccount()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "OnTryingToSignInWithADifferentAccount");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosControllerDetectionWidget.ShutdownWidget
// (Final, Native, Public, BlueprintCallable)

void UKosmosControllerDetectionWidget::ShutdownWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosControllerDetectionWidget", "ShutdownWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.EndGrab
// (Final, Native, Protected, BlueprintCallable)

void AKosmosCrank::EndGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "EndGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.FixPushCollsionPostResume
// (Event, Protected, BlueprintEvent)
// Parameters:
// float                                   NewProgress                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCrank::FixPushCollsionPostResume(float NewProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "FixPushCollsionPostResume");

	Params::KosmosCrank_FixPushCollsionPostResume Parms{};

	Parms.NewProgress = NewProgress;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosCrank.Multicast_InitCrank
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// float                                   NewProgress                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCrank::Multicast_InitCrank(float NewProgress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "Multicast_InitCrank");

	Params::KosmosCrank_Multicast_InitCrank Parms{};

	Parms.NewProgress = NewProgress;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.OnRep_IsRollingBack
// (Final, Native, Private)

void AKosmosCrank::OnRep_IsRollingBack()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "OnRep_IsRollingBack");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.Server_UpdateClientInput
// (Net, Native, Event, Protected, NetServer)
// Parameters:
// float                                   InputDeltaAngle                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCrank::Server_UpdateClientInput(float InputDeltaAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "Server_UpdateClientInput");

	Params::KosmosCrank_Server_UpdateClientInput Parms{};

	Parms.InputDeltaAngle = InputDeltaAngle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.SetAIControl
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   EndValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCrank::SetAIControl(float EndValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "SetAIControl");

	Params::KosmosCrank_SetAIControl Parms{};

	Parms.EndValue = EndValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.StartGrab
// (Final, Native, Protected, BlueprintCallable)

void AKosmosCrank::StartGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "StartGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCrank.GetCrankApproachPos
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   CharPos                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutPos                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutDir                                                 (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosCrank::GetCrankApproachPos(const struct FVector& CharPos, struct FVector* OutPos, struct FVector* OutDir) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "GetCrankApproachPos");

	Params::KosmosCrank_GetCrankApproachPos Parms{};

	Parms.CharPos = std::move(CharPos);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPos != nullptr)
		*OutPos = std::move(Parms.OutPos);

	if (OutDir != nullptr)
		*OutDir = std::move(Parms.OutDir);
}


// Function Kosmos.KosmosCrank.GetCurrentAngle
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosCrank::GetCurrentAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "GetCurrentAngle");

	Params::KosmosCrank_GetCurrentAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCrank.GetMaxAngle
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosCrank::GetMaxAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "GetMaxAngle");

	Params::KosmosCrank_GetMaxAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCrank.GetMinAngle
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosCrank::GetMinAngle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "GetMinAngle");

	Params::KosmosCrank_GetMinAngle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCrank.GetProgress
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosCrank::GetProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCrank", "GetProgress");

	Params::KosmosCrank_GetProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCreditsScroller.Finish
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCreditsScroller::Finish(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCreditsScroller", "Finish");

	Params::KosmosCreditsScroller_Finish Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosCreditsScroller.GetCurrentScrollValue
// (Final, Native, Private, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosCreditsScroller::GetCurrentScrollValue(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCreditsScroller", "GetCurrentScrollValue");

	Params::KosmosCreditsScroller_GetCurrentScrollValue Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosCreditsScroller.Init
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosCreditsScroller::Init(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosCreditsScroller", "Init");

	Params::KosmosCreditsScroller_Init Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDelusionSizeComponent.NotifyForceRegularSize
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Override                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosDelusionSizeComponent::NotifyForceRegularSize(bool Override)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDelusionSizeComponent", "NotifyForceRegularSize");

	Params::KosmosDelusionSizeComponent_NotifyForceRegularSize Parms{};

	Parms.Override = Override;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDelusionSizeComponent.NotifyItemStateChange
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosCarriableUsage                   State                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosDelusionSizeComponent::NotifyItemStateChange(EKosmosCarriableUsage State)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDelusionSizeComponent", "NotifyItemStateChange");

	Params::KosmosDelusionSizeComponent_NotifyItemStateChange Parms{};

	Parms.State = State;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDelusionSizeComponent.NotifyVolumeEnter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AKosmosDelusionSizeVolume*  Volume                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosDelusionSizeComponent::NotifyVolumeEnter(const class AKosmosDelusionSizeVolume* Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDelusionSizeComponent", "NotifyVolumeEnter");

	Params::KosmosDelusionSizeComponent_NotifyVolumeEnter Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDelusionSizeComponent.NotifyVolumeLeave
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AKosmosDelusionSizeVolume*  Volume                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosDelusionSizeComponent::NotifyVolumeLeave(const class AKosmosDelusionSizeVolume* Volume)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDelusionSizeComponent", "NotifyVolumeLeave");

	Params::KosmosDelusionSizeComponent_NotifyVolumeLeave Parms{};

	Parms.Volume = Volume;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDelusionSizeComponent.GetCurrentSize
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosDelusionSizeComponent::GetCurrentSize() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDelusionSizeComponent", "GetCurrentSize");

	Params::KosmosDelusionSizeComponent_GetCurrentSize Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDoor.ApplyForce
// (Native, Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FVector&                   InputVector                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDoor::ApplyForce(const struct FVector& InputVector, class ACharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "ApplyForce");

	Params::KosmosDoor_ApplyForce Parms{};

	Parms.InputVector = std::move(InputVector);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.EndGrab
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosDoor::EndGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "EndGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.LockDoor
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosDoor::LockDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "LockDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.Multicast_ResumeCheckpoint
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const float                             InDoorAngle                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              InIsLocked                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             InSEQDoorAngle                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDoor::Multicast_ResumeCheckpoint(const float InDoorAngle, const bool InIsLocked, const float InSEQDoorAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "Multicast_ResumeCheckpoint");

	Params::KosmosDoor_Multicast_ResumeCheckpoint Parms{};

	Parms.InDoorAngle = InDoorAngle;
	Parms.InIsLocked = InIsLocked;
	Parms.InSEQDoorAngle = InSEQDoorAngle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.OnDoorHit
// (Final, Native, Public, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosDoor::OnDoorHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "OnDoorHit");

	Params::KosmosDoor_OnDoorHit Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.SetHingeRotationByAngle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             InDoorAngle                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDoor::SetHingeRotationByAngle(const float InDoorAngle)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "SetHingeRotationByAngle");

	Params::KosmosDoor_SetHingeRotationByAngle Parms{};

	Parms.InDoorAngle = InDoorAngle;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.StartGrab
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class UGrabHelper*                      GrabHelper                                             (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosDoor::StartGrab(class UGrabHelper* GrabHelper)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "StartGrab");

	Params::KosmosDoor_StartGrab Parms{};

	Parms.GrabHelper = GrabHelper;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDoor.UnlockDoor
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosDoor::UnlockDoor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDoor", "UnlockDoor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.GrabHelper.SetIsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              inEnabled                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabHelper::SetIsEnabled(const bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "SetIsEnabled");

	Params::GrabHelper_SetIsEnabled Parms{};

	Parms.inEnabled = inEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.GrabHelper.SetIsOccupied
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              InOccupied                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabHelper::SetIsOccupied(const bool InOccupied)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "SetIsOccupied");

	Params::GrabHelper_SetIsOccupied Parms{};

	Parms.InOccupied = InOccupied;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.GrabHelper.CanContinueGrab
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelper::CanContinueGrab() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "CanContinueGrab");

	Params::GrabHelper_CanContinueGrab Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.CanStartGrab
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelper::CanStartGrab() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "CanStartGrab");

	Params::GrabHelper_CanStartGrab Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetClosestLocalLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   sideMargin                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGrabHelper::GetClosestLocalLocation(const struct FVector& Location, float sideMargin) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetClosestLocalLocation");

	Params::GrabHelper_GetClosestLocalLocation Parms{};

	Parms.Location = std::move(Location);
	Parms.sideMargin = sideMargin;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetClosestWorldLocation
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   sideMargin                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGrabHelper::GetClosestWorldLocation(const struct FVector& Location, float sideMargin) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetClosestWorldLocation");

	Params::GrabHelper_GetClosestWorldLocation Parms{};

	Parms.Location = std::move(Location);
	Parms.sideMargin = sideMargin;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetLocalGrabDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   referencePointLocal                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGrabHelper::GetLocalGrabDirection(const struct FVector& referencePointLocal) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetLocalGrabDirection");

	Params::GrabHelper_GetLocalGrabDirection Parms{};

	Parms.referencePointLocal = std::move(referencePointLocal);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetLocalGrabExtents
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         leftLocal                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         rightLocal                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabHelper::GetLocalGrabExtents(struct FVector* leftLocal, struct FVector* rightLocal) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetLocalGrabExtents");

	Params::GrabHelper_GetLocalGrabExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (leftLocal != nullptr)
		*leftLocal = std::move(Parms.leftLocal);

	if (rightLocal != nullptr)
		*rightLocal = std::move(Parms.rightLocal);
}


// Function Kosmos.GrabHelper.GetWidth
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UGrabHelper::GetWidth() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetWidth");

	Params::GrabHelper_GetWidth Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetWorldGrabDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UGrabHelper::GetWorldGrabDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetWorldGrabDirection");

	Params::GrabHelper_GetWorldGrabDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.GetWorldGrabExtents
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector*                         leftWorld                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         rightWorld                                             (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabHelper::GetWorldGrabExtents(struct FVector* leftWorld, struct FVector* rightWorld) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetWorldGrabExtents");

	Params::GrabHelper_GetWorldGrabExtents Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (leftWorld != nullptr)
		*leftWorld = std::move(Parms.leftWorld);

	if (rightWorld != nullptr)
		*rightWorld = std::move(Parms.rightWorld);
}


// Function Kosmos.GrabHelper.GetWorldIntersectWithPlane
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FPlane&                    Plane                                                  (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outIntersectPoint                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelper::GetWorldIntersectWithPlane(const struct FPlane& Plane, struct FVector* outIntersectPoint) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "GetWorldIntersectWithPlane");

	Params::GrabHelper_GetWorldIntersectWithPlane Parms{};

	Parms.Plane = std::move(Plane);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outIntersectPoint != nullptr)
		*outIntersectPoint = std::move(Parms.outIntersectPoint);

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelper::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "IsEnabled");

	Params::GrabHelper_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.GrabHelper.IsOccupied
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabHelper::IsOccupied() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabHelper", "IsOccupied");

	Params::GrabHelper_IsOccupied Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDragInterface.Multicast_GrabEnd
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UKosmosDragInterface::Multicast_GrabEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "Multicast_GrabEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDragInterface.Multicast_GrabEndError
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, HasDefaults)
// Parameters:
// const struct FVector&                   CorrectLocation                                        (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosDragInterface::Multicast_GrabEndError(const struct FVector& CorrectLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "Multicast_GrabEndError");

	Params::KosmosDragInterface_Multicast_GrabEndError Parms{};

	Parms.CorrectLocation = std::move(CorrectLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDragInterface.OnCancelledTransition
// (Final, Native, Private)

void UKosmosDragInterface::OnCancelledTransition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "OnCancelledTransition");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDragInterface.OnReachedGrabPosition
// (Final, Native, Private)

void UKosmosDragInterface::OnReachedGrabPosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "OnReachedGrabPosition");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosDragInterface.GetGrabbedDraggable
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosDraggable*                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosDraggable* UKosmosDragInterface::GetGrabbedDraggable() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "GetGrabbedDraggable");

	Params::KosmosDragInterface_GetGrabbedDraggable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosDragInterface.GetGrabbedGrabHelper
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* UKosmosDragInterface::GetGrabbedGrabHelper() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosDragInterface", "GetGrabbedGrabHelper");

	Params::KosmosDragInterface_GetGrabbedGrabHelper Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEntitlementDataAsset.GetIdForCurrentPlatform
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosEntitlementDataAsset::GetIdForCurrentPlatform() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementDataAsset", "GetIdForCurrentPlatform");

	Params::KosmosEntitlementDataAsset_GetIdForCurrentPlatform Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEntitlementDataAsset.ShowStoreUI
// (Final, Native, Public, BlueprintCallable, Const)

void UKosmosEntitlementDataAsset::ShowStoreUI() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosEntitlementDataAsset", "ShowStoreUI");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.DeleteGameData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::DeleteGameData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "DeleteGameData");

	Params::KosmosSaveGameBlueprintLibrary_DeleteGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.DeleteOptionsData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::DeleteOptionsData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "DeleteOptionsData");

	Params::KosmosSaveGameBlueprintLibrary_DeleteOptionsData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetHasFullGameSaves
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::GetHasFullGameSaves(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetHasFullGameSaves");

	Params::KosmosSaveGameBlueprintLibrary_GetHasFullGameSaves Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetIsTrialGameSave
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::GetIsTrialGameSave(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetIsTrialGameSave");

	Params::KosmosSaveGameBlueprintLibrary_GetIsTrialGameSave Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetOptionsSave_Bool
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::GetOptionsSave_Bool(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetOptionsSave_Bool");

	Params::KosmosSaveGameBlueprintLibrary_GetOptionsSave_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetOptionsSave_Float
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSaveGameBlueprintLibrary::GetOptionsSave_Float(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetOptionsSave_Float");

	Params::KosmosSaveGameBlueprintLibrary_GetOptionsSave_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetOptionsSave_Int
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosSaveGameBlueprintLibrary::GetOptionsSave_Int(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetOptionsSave_Int");

	Params::KosmosSaveGameBlueprintLibrary_GetOptionsSave_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetOptionsSave_Keys
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::GetOptionsSave_Keys(class UObject* WorldContextObject, TArray<class FString>* OutKeys)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetOptionsSave_Keys");

	Params::KosmosSaveGameBlueprintLibrary_GetOptionsSave_Keys Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutKeys != nullptr)
		*OutKeys = std::move(Parms.OutKeys);
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetOptionsSave_String
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveGameBlueprintLibrary::GetOptionsSave_String(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetOptionsSave_String");

	Params::KosmosSaveGameBlueprintLibrary_GetOptionsSave_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetSaveSlotData_Bool
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::GetSaveSlotData_Bool(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetSaveSlotData_Bool");

	Params::KosmosSaveGameBlueprintLibrary_GetSaveSlotData_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetSaveSlotData_Float
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSaveGameBlueprintLibrary::GetSaveSlotData_Float(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetSaveSlotData_Float");

	Params::KosmosSaveGameBlueprintLibrary_GetSaveSlotData_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetSaveSlotData_Int
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosSaveGameBlueprintLibrary::GetSaveSlotData_Int(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetSaveSlotData_Int");

	Params::KosmosSaveGameBlueprintLibrary_GetSaveSlotData_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetSaveSlotData_Keys
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::GetSaveSlotData_Keys(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, TArray<class FString>* OutKeys)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetSaveSlotData_Keys");

	Params::KosmosSaveGameBlueprintLibrary_GetSaveSlotData_Keys Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutKeys != nullptr)
		*OutKeys = std::move(Parms.OutKeys);
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetSaveSlotData_String
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveGameBlueprintLibrary::GetSaveSlotData_String(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetSaveSlotData_String");

	Params::KosmosSaveGameBlueprintLibrary_GetSaveSlotData_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetTransientData_Bool
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::GetTransientData_Bool(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetTransientData_Bool");

	Params::KosmosSaveGameBlueprintLibrary_GetTransientData_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetTransientData_Float
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSaveGameBlueprintLibrary::GetTransientData_Float(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetTransientData_Float");

	Params::KosmosSaveGameBlueprintLibrary_GetTransientData_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetTransientData_Int
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosSaveGameBlueprintLibrary::GetTransientData_Int(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetTransientData_Int");

	Params::KosmosSaveGameBlueprintLibrary_GetTransientData_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetTransientData_String
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveGameBlueprintLibrary::GetTransientData_String(class UObject* WorldContextObject, const class FString& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetTransientData_String");

	Params::KosmosSaveGameBlueprintLibrary_GetTransientData_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.GetTransientSave_Keys
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutKeys                                                (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::GetTransientSave_Keys(class UObject* WorldContextObject, TArray<class FString>* OutKeys)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "GetTransientSave_Keys");

	Params::KosmosSaveGameBlueprintLibrary_GetTransientSave_Keys Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutKeys != nullptr)
		*OutKeys = std::move(Parms.OutKeys);
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.HasOptionDataBeenCorrupted
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::HasOptionDataBeenCorrupted(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "HasOptionDataBeenCorrupted");

	Params::KosmosSaveGameBlueprintLibrary_HasOptionDataBeenCorrupted Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.HasSaveGameData
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::HasSaveGameData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "HasSaveGameData");

	Params::KosmosSaveGameBlueprintLibrary_HasSaveGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.HasSaveGameDataBeenCorrupted
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::HasSaveGameDataBeenCorrupted(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "HasSaveGameDataBeenCorrupted");

	Params::KosmosSaveGameBlueprintLibrary_HasSaveGameDataBeenCorrupted Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsChapterSelectAvailable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsChapterSelectAvailable(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsChapterSelectAvailable");

	Params::KosmosSaveGameBlueprintLibrary_IsChapterSelectAvailable Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsContinueGameAvailable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsContinueGameAvailable(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsContinueGameAvailable");

	Params::KosmosSaveGameBlueprintLibrary_IsContinueGameAvailable Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsLoadGameAvailable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IgnoreCurrentLoadedSlot                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsLoadGameAvailable(class UObject* WorldContextObject, bool IgnoreCurrentLoadedSlot)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsLoadGameAvailable");

	Params::KosmosSaveGameBlueprintLibrary_IsLoadGameAvailable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.IgnoreCurrentLoadedSlot = IgnoreCurrentLoadedSlot;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsLoadingGameData
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsLoadingGameData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsLoadingGameData");

	Params::KosmosSaveGameBlueprintLibrary_IsLoadingGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsLoadingOptionsData
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsLoadingOptionsData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsLoadingOptionsData");

	Params::KosmosSaveGameBlueprintLibrary_IsLoadingOptionsData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsOptionsDataValid
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsOptionsDataValid(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsOptionsDataValid");

	Params::KosmosSaveGameBlueprintLibrary_IsOptionsDataValid Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsSaveGameValid
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsSaveGameValid(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "IsSaveGameValid");

	Params::KosmosSaveGameBlueprintLibrary_IsSaveGameValid Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.LoadGameData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveGameActionLoadType           InLoadType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosLevelNameReference& LevelID                                                (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bTriggerButDontLoad                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::LoadGameData(class UObject* WorldContextObject, EKosmosSaveGameActionLoadType InLoadType, const struct FKosmosLevelNameReference& LevelID, bool bTriggerButDontLoad)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "LoadGameData");

	Params::KosmosSaveGameBlueprintLibrary_LoadGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InLoadType = InLoadType;
	Parms.LevelID = std::move(LevelID);
	Parms.bTriggerButDontLoad = bTriggerButDontLoad;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.LoadOptionsData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::LoadOptionsData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "LoadOptionsData");

	Params::KosmosSaveGameBlueprintLibrary_LoadOptionsData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.ResetLoadedGameDataSaveSlot
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bMasterReset                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveGameType                     SaveType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::ResetLoadedGameDataSaveSlot(class UObject* WorldContextObject, bool bMasterReset, EKosmosSaveGameType SaveType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "ResetLoadedGameDataSaveSlot");

	Params::KosmosSaveGameBlueprintLibrary_ResetLoadedGameDataSaveSlot Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bMasterReset = bMasterReset;
	Parms.SaveType = SaveType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.RestoreOptionSettings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::RestoreOptionSettings(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "RestoreOptionSettings");

	Params::KosmosSaveGameBlueprintLibrary_RestoreOptionSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SaveGameData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveGameActionSaveType           InSaveType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosLevelNameReference& LevelID                                                (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ActualLevel                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SaveGameData(class UObject* WorldContextObject, EKosmosSaveGameActionSaveType InSaveType, const struct FKosmosLevelNameReference& LevelID, const class FString& ActualLevel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SaveGameData");

	Params::KosmosSaveGameBlueprintLibrary_SaveGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InSaveType = InSaveType;
	Parms.LevelID = std::move(LevelID);
	Parms.ActualLevel = std::move(ActualLevel);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SaveOptionsData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SaveOptionsData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SaveOptionsData");

	Params::KosmosSaveGameBlueprintLibrary_SaveOptionsData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetIsTrialGameSave
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsTrialGame                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetIsTrialGameSave(class UObject* WorldContextObject, bool bIsTrialGame)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetIsTrialGameSave");

	Params::KosmosSaveGameBlueprintLibrary_SetIsTrialGameSave Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bIsTrialGame = bIsTrialGame;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetOptionsSave_Bool
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetOptionsSave_Bool(class UObject* WorldContextObject, const class FString& InKey, bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetOptionsSave_Bool");

	Params::KosmosSaveGameBlueprintLibrary_SetOptionsSave_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetOptionsSave_Float
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetOptionsSave_Float(class UObject* WorldContextObject, const class FString& InKey, float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetOptionsSave_Float");

	Params::KosmosSaveGameBlueprintLibrary_SetOptionsSave_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetOptionsSave_Int
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetOptionsSave_Int(class UObject* WorldContextObject, const class FString& InKey, int32 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetOptionsSave_Int");

	Params::KosmosSaveGameBlueprintLibrary_SetOptionsSave_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetOptionsSave_String
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    inValue                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetOptionsSave_String(class UObject* WorldContextObject, const class FString& InKey, const class FString& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetOptionsSave_String");

	Params::KosmosSaveGameBlueprintLibrary_SetOptionsSave_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetSaveGameSlot
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSetSlotAction                    InSlotAction                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveGameType                     InSaveGameType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveCharacterRoute               InSaveGameRoute                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosSaveMostRecentType               InMostRecentType                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USMGUIScreenTransition*           InLoadSlot_ChapterSelection                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USMGUIScreenTransition*           InLoadSlot_Continue                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USMGUIScreenTransition*           InLoadSlot_NoSlotFound                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSMGUIScreenGroupReference&InScreenGroupReference                                 (Parm, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   OutWasSucessful                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetSaveGameSlot(class UObject* WorldContextObject, EKosmosSetSlotAction InSlotAction, EKosmosSaveGameType InSaveGameType, EKosmosSaveCharacterRoute InSaveGameRoute, EKosmosSaveMostRecentType InMostRecentType, class USMGUIScreenTransition* InLoadSlot_ChapterSelection, class USMGUIScreenTransition* InLoadSlot_Continue, class USMGUIScreenTransition* InLoadSlot_NoSlotFound, const struct FSMGUIScreenGroupReference& InScreenGroupReference, const struct FLatentActionInfo& LatentInfo, bool* OutWasSucessful)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetSaveGameSlot");

	Params::KosmosSaveGameBlueprintLibrary_SetSaveGameSlot Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InSlotAction = InSlotAction;
	Parms.InSaveGameType = InSaveGameType;
	Parms.InSaveGameRoute = InSaveGameRoute;
	Parms.InMostRecentType = InMostRecentType;
	Parms.InLoadSlot_ChapterSelection = InLoadSlot_ChapterSelection;
	Parms.InLoadSlot_Continue = InLoadSlot_Continue;
	Parms.InLoadSlot_NoSlotFound = InLoadSlot_NoSlotFound;
	Parms.InScreenGroupReference = std::move(InScreenGroupReference);
	Parms.LatentInfo = std::move(LatentInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutWasSucessful != nullptr)
		*OutWasSucessful = Parms.OutWasSucessful;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetSaveSlotData_Bool
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetSaveSlotData_Bool(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey, bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetSaveSlotData_Bool");

	Params::KosmosSaveGameBlueprintLibrary_SetSaveSlotData_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetSaveSlotData_Float
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetSaveSlotData_Float(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey, float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetSaveSlotData_Float");

	Params::KosmosSaveGameBlueprintLibrary_SetSaveSlotData_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetSaveSlotData_Int
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetSaveSlotData_Int(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey, int32 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetSaveSlotData_Int");

	Params::KosmosSaveGameBlueprintLibrary_SetSaveSlotData_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetSaveSlotData_String
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosPersistence                SavePersistance                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    inValue                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetSaveSlotData_String(class UObject* WorldContextObject, const EKosmosPersistence SavePersistance, const class FString& InKey, const class FString& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetSaveSlotData_String");

	Params::KosmosSaveGameBlueprintLibrary_SetSaveSlotData_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.SavePersistance = SavePersistance;
	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetTransientData_Bool
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetTransientData_Bool(class UObject* WorldContextObject, const class FString& InKey, bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetTransientData_Bool");

	Params::KosmosSaveGameBlueprintLibrary_SetTransientData_Bool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetTransientData_Float
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetTransientData_Float(class UObject* WorldContextObject, const class FString& InKey, float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetTransientData_Float");

	Params::KosmosSaveGameBlueprintLibrary_SetTransientData_Float Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetTransientData_Int
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetTransientData_Int(class UObject* WorldContextObject, const class FString& InKey, int32 inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetTransientData_Int");

	Params::KosmosSaveGameBlueprintLibrary_SetTransientData_Int Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.SetTransientData_String
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InKey                                                  (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    inValue                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::SetTransientData_String(class UObject* WorldContextObject, const class FString& InKey, const class FString& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "SetTransientData_String");

	Params::KosmosSaveGameBlueprintLibrary_SetTransientData_String Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.TriggerSlotLoad
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InSlotName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::TriggerSlotLoad(class UObject* WorldContextObject, const class FString& InSlotName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "TriggerSlotLoad");

	Params::KosmosSaveGameBlueprintLibrary_TriggerSlotLoad Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InSlotName = std::move(InSlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.TriggerSlotLoadForCurrentSlot
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveGameBlueprintLibrary::TriggerSlotLoadForCurrentSlot(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBlueprintLibrary", "TriggerSlotLoadForCurrentSlot");

	Params::KosmosSaveGameBlueprintLibrary_TriggerSlotLoadForCurrentSlot Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsSavingGameData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsSavingGameData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveGameBlueprintLibrary", "IsSavingGameData");

	Params::KosmosSaveGameBlueprintLibrary_IsSavingGameData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveGameBlueprintLibrary.IsSavingOptionsData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosSaveGameBlueprintLibrary::IsSavingOptionsData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveGameBlueprintLibrary", "IsSavingOptionsData");

	Params::KosmosSaveGameBlueprintLibrary_IsSavingOptionsData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveLoadScreenBase.DeleteSaveSlot
// (Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InSlotName                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveLoadScreenBase::DeleteSaveSlot(const class FString& InSlotName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveLoadScreenBase", "DeleteSaveSlot");

	Params::KosmosSaveLoadScreenBase_DeleteSaveSlot Parms{};

	Parms.InSlotName = std::move(InSlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveLoadScreenBase.InitializeWidget
// (Native, Public, BlueprintCallable)
// Parameters:
// EKosmosSaveGameType                     InSaveGameType                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveLoadScreenBase::InitializeWidget(EKosmosSaveGameType InSaveGameType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveLoadScreenBase", "InitializeWidget");

	Params::KosmosSaveLoadScreenBase_InitializeWidget Parms{};

	Parms.InSaveGameType = InSaveGameType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveLoadScreenBase.OnFinishLoadingMetaData
// (Event, Public, BlueprintEvent)

void UKosmosSaveLoadScreenBase::OnFinishLoadingMetaData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveLoadScreenBase", "OnFinishLoadingMetaData");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSaveLoadScreenBase.TriggerMissingDLCMessage
// (Event, Public, BlueprintEvent)

void UKosmosSaveLoadScreenBase::TriggerMissingDLCMessage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveLoadScreenBase", "TriggerMissingDLCMessage");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSaveScreen.OverrideSaveSlot
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    SlotName                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSaveScreen::OverrideSaveSlot(const class FString& SlotName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveScreen", "OverrideSaveSlot");

	Params::KosmosSaveScreen_OverrideSaveSlot Parms{};

	Parms.SlotName = std::move(SlotName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveScreen.ShowOverwriteMessageBox
// (Event, Public, BlueprintEvent)

void UKosmosSaveScreen::ShowOverwriteMessageBox()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSaveScreen", "ShowOverwriteMessageBox");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosRoomTransitionBorder.OnCheckpointResume
// (Event, Public, BlueprintEvent)

void AKosmosRoomTransitionBorder::OnCheckpointResume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomTransitionBorder", "OnCheckpointResume");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosErrorCodeHandler.ClearCurrentErrorCode
// (Final, Native, Static, Public, BlueprintCallable)

void UKosmosErrorCodeHandler::ClearCurrentErrorCode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "ClearCurrentErrorCode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosErrorCodeHandler.GetCurrentErrorCode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const EKosmosErrorMessages              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const EKosmosErrorMessages UKosmosErrorCodeHandler::GetCurrentErrorCode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "GetCurrentErrorCode");

	Params::KosmosErrorCodeHandler_GetCurrentErrorCode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosErrorCodeHandler.GetCurrentErrorCodeString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosErrorCodeHandler::GetCurrentErrorCodeString()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "GetCurrentErrorCodeString");

	Params::KosmosErrorCodeHandler_GetCurrentErrorCodeString Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosErrorCodeHandler.GetLastErrorCode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const EKosmosErrorMessages              ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const EKosmosErrorMessages UKosmosErrorCodeHandler::GetLastErrorCode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "GetLastErrorCode");

	Params::KosmosErrorCodeHandler_GetLastErrorCode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosErrorCodeHandler.HasCurrentErrorCodeBeenSpecified
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosErrorCodeHandler::HasCurrentErrorCodeBeenSpecified()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "HasCurrentErrorCodeBeenSpecified");

	Params::KosmosErrorCodeHandler_HasCurrentErrorCodeBeenSpecified Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosErrorCodeHandler.SetCurrentErrorCode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const EKosmosErrorMessages              InErrorCode                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosErrorCodeHandler::SetCurrentErrorCode(const EKosmosErrorMessages InErrorCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "SetCurrentErrorCode");

	Params::KosmosErrorCodeHandler_SetCurrentErrorCode Parms{};

	Parms.InErrorCode = InErrorCode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosErrorCodeHandler.SetLastErrorCode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const EKosmosErrorMessages              InErrorCode                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosErrorCodeHandler::SetLastErrorCode(const EKosmosErrorMessages InErrorCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosErrorCodeHandler", "SetLastErrorCode");

	Params::KosmosErrorCodeHandler_SetLastErrorCode Parms{};

	Parms.InErrorCode = InErrorCode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.CreateSession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::CreateSession(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "CreateSession");

	Params::KosmosOnlineSessionBlueprintInterface_CreateSession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.GetConnectedClientName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosOnlineSessionBlueprintInterface::GetConnectedClientName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "GetConnectedClientName");

	Params::KosmosOnlineSessionBlueprintInterface_GetConnectedClientName Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.GetConnectedClientOnlineID
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosOnlineSessionBlueprintInterface::GetConnectedClientOnlineID(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "GetConnectedClientOnlineID");

	Params::KosmosOnlineSessionBlueprintInterface_GetConnectedClientOnlineID Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.GetConnectedHostName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosOnlineSessionBlueprintInterface::GetConnectedHostName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "GetConnectedHostName");

	Params::KosmosOnlineSessionBlueprintInterface_GetConnectedHostName Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.GetCurrentUserName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosOnlineSessionBlueprintInterface::GetCurrentUserName(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "GetCurrentUserName");

	Params::KosmosOnlineSessionBlueprintInterface_GetCurrentUserName Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.GetGamePermissionType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosGamePermissionType               ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosGamePermissionType UKosmosOnlineSessionBlueprintInterface::GetGamePermissionType(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "GetGamePermissionType");

	Params::KosmosOnlineSessionBlueprintInterface_GetGamePermissionType Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.IsClient
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionBlueprintInterface::IsClient(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "IsClient");

	Params::KosmosOnlineSessionBlueprintInterface_IsClient Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.IsExternalUiOpen
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionBlueprintInterface::IsExternalUiOpen(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "IsExternalUiOpen");

	Params::KosmosOnlineSessionBlueprintInterface_IsExternalUiOpen Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.IsHost
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionBlueprintInterface::IsHost(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "IsHost");

	Params::KosmosOnlineSessionBlueprintInterface_IsHost Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.IsUserSignedIn
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionBlueprintInterface::IsUserSignedIn(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "IsUserSignedIn");

	Params::KosmosOnlineSessionBlueprintInterface_IsUserSignedIn Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.LeaveOrDestroySession
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::LeaveOrDestroySession(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "LeaveOrDestroySession");

	Params::KosmosOnlineSessionBlueprintInterface_LeaveOrDestroySession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.LoginToOnlineServices
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAutoLoggin                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionBlueprintInterface::LoginToOnlineServices(class UObject* WorldContextObject, bool bIsAutoLoggin)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "LoginToOnlineServices");

	Params::KosmosOnlineSessionBlueprintInterface_LoginToOnlineServices Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bIsAutoLoggin = bIsAutoLoggin;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.QuitToFrontend
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosQuitToFrontEndReason             Reason                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::QuitToFrontend(class UObject* WorldContextObject, EKosmosQuitToFrontEndReason Reason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "QuitToFrontend");

	Params::KosmosOnlineSessionBlueprintInterface_QuitToFrontend Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Reason = Reason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.QuitToFrontendNow
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::QuitToFrontendNow(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "QuitToFrontendNow");

	Params::KosmosOnlineSessionBlueprintInterface_QuitToFrontendNow Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.ShowAccountPicker
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::ShowAccountPicker(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "ShowAccountPicker");

	Params::KosmosOnlineSessionBlueprintInterface_ShowAccountPicker Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.ShowInviteUI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::ShowInviteUI(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "ShowInviteUI");

	Params::KosmosOnlineSessionBlueprintInterface_ShowInviteUI Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.ShowPartnerProfile
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::ShowPartnerProfile(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "ShowPartnerProfile");

	Params::KosmosOnlineSessionBlueprintInterface_ShowPartnerProfile Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.ShowStoreUI
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    ProductID                                              (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InEntitlementID                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ServiceLabel                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::ShowStoreUI(class UObject* WorldContextObject, const class FString& ProductID, const class FString& InEntitlementID, int32 ServiceLabel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "ShowStoreUI");

	Params::KosmosOnlineSessionBlueprintInterface_ShowStoreUI Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ProductID = std::move(ProductID);
	Parms.InEntitlementID = std::move(InEntitlementID);
	Parms.ServiceLabel = ServiceLabel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.StartOnlineGame
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::StartOnlineGame(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "StartOnlineGame");

	Params::KosmosOnlineSessionBlueprintInterface_StartOnlineGame Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.StartUsingMultiplayerFeatures
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::StartUsingMultiplayerFeatures(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "StartUsingMultiplayerFeatures");

	Params::KosmosOnlineSessionBlueprintInterface_StartUsingMultiplayerFeatures Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.StopUsingMultiplayerFeatures
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::StopUsingMultiplayerFeatures(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "StopUsingMultiplayerFeatures");

	Params::KosmosOnlineSessionBlueprintInterface_StopUsingMultiplayerFeatures Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionBlueprintInterface.WaitingForCreateSession
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosLatentOutcomes*                  StateOutcome                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionBlueprintInterface::WaitingForCreateSession(class UObject* WorldContextObject, EKosmosLatentOutcomes* StateOutcome)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOnlineSessionBlueprintInterface", "WaitingForCreateSession");

	Params::KosmosOnlineSessionBlueprintInterface_WaitingForCreateSession Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (StateOutcome != nullptr)
		*StateOutcome = Parms.StateOutcome;
}


// Function Kosmos.KosmosFlashHeadband.SetHeadbandVisible
// (Net, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    IsVisible                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosFlashHeadband::SetHeadbandVisible(bool IsVisible)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlashHeadband", "SetHeadbandVisible");

	Params::KosmosFlashHeadband_SetHeadbandVisible Parms{};

	Parms.IsVisible = IsVisible;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlashlight.EnterLightVolume
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosFlashlight::EnterLightVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlashlight", "EnterLightVolume");

	Params::KosmosFlashlight_EnterLightVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlashlight.ExitLightVolume
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosFlashlight::ExitLightVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlashlight", "ExitLightVolume");

	Params::KosmosFlashlight_ExitLightVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlashlight.SetInCombat
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosFlashlight::SetInCombat(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlashlight", "SetInCombat");

	Params::KosmosFlashlight_SetInCombat Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlashlight.IsInCombat
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosFlashlight::IsInCombat() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlashlight", "IsInCombat");

	Params::KosmosFlashlight_IsInCombat Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosFlowControlComponent.OnAnimNotify
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosFlowControlComponent::OnAnimNotify(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "OnAnimNotify");

	Params::KosmosFlowControlComponent_OnAnimNotify Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlowControlComponent.OnPostProcessAnimNotifies
// (Final, Native, Private)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosFlowControlComponent::OnPostProcessAnimNotifies(class AActor* notifier)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "OnPostProcessAnimNotifies");

	Params::KosmosFlowControlComponent_OnPostProcessAnimNotifies Parms{};

	Parms.notifier = notifier;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlowControlComponent.QueueTransition
// (Final, Native, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FCharacterTransitionData&  TransitionData                                         (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetDirection                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosFlowControlComponent::QueueTransition(const struct FCharacterTransitionData& TransitionData, const struct FVector& TargetLocation, const struct FVector& TargetDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "QueueTransition");

	Params::KosmosFlowControlComponent_QueueTransition Parms{};

	Parms.TransitionData = std::move(TransitionData);
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetDirection = std::move(TargetDirection);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlowControlComponent.QueueTransitionAndWait
// (Final, Native, Private, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FCharacterTransitionData&  TransitionData                                         (Parm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetDirection                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)
// ELatentTransitionResult*                TransitionResult                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosFlowControlComponent::QueueTransitionAndWait(const struct FCharacterTransitionData& TransitionData, const struct FVector& TargetLocation, const struct FVector& TargetDirection, const struct FLatentActionInfo& LatentInfo, ELatentTransitionResult* TransitionResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "QueueTransitionAndWait");

	Params::KosmosFlowControlComponent_QueueTransitionAndWait Parms{};

	Parms.TransitionData = std::move(TransitionData);
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.TargetDirection = std::move(TargetDirection);
	Parms.LatentInfo = std::move(LatentInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (TransitionResult != nullptr)
		*TransitionResult = Parms.TransitionResult;
}


// Function Kosmos.KosmosFlowControlComponent.ReleaseGrab
// (Final, Native, Private, BlueprintCallable)

void UKosmosFlowControlComponent::ReleaseGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "ReleaseGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosFlowControlComponent.SetIsSliding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    NewIsSliding                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosFlowControlComponent::SetIsSliding(bool NewIsSliding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosFlowControlComponent", "SetIsSliding");

	Params::KosmosFlowControlComponent_SetIsSliding Parms{};

	Parms.NewIsSliding = NewIsSliding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavModifier.IsTryingToWalkThroughObstacle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosAIController*              AIController                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosNavModifier::IsTryingToWalkThroughObstacle(class AKosmosAIController* AIController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavModifier", "IsTryingToWalkThroughObstacle");

	Params::KosmosNavModifier_IsTryingToWalkThroughObstacle Parms{};

	Parms.AIController = AIController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNavModifier.UpdateBounds
// (Final, Native, Public, BlueprintCallable)

void UKosmosNavModifier::UpdateBounds()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavModifier", "UpdateBounds");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavModifier.UpdateBoundsTransform
// (Final, Native, Public, BlueprintCallable)

void UKosmosNavModifier::UpdateBoundsTransform()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavModifier", "UpdateBoundsTransform");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameInstance.ClearGameData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosPersistence                      InDataType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameInstance::ClearGameData(EKosmosPersistence InDataType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "ClearGameData");

	Params::KosmosGameInstance_ClearGameData Parms{};

	Parms.InDataType = InDataType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameInstance.GetIsAlternateCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameInstance::GetIsAlternateCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "GetIsAlternateCharacter");

	Params::KosmosGameInstance_GetIsAlternateCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameInstance.GetStartupCheckpoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    usePrimaryCharacter                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosGameInstance::GetStartupCheckpoint(bool usePrimaryCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "GetStartupCheckpoint");

	Params::KosmosGameInstance_GetStartupCheckpoint Parms{};

	Parms.usePrimaryCharacter = usePrimaryCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameInstance.SetGameState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosGameFlowState                    NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameInstance::SetGameState(EKosmosGameFlowState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "SetGameState");

	Params::KosmosGameInstance_SetGameState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameInstance.SetIsAlternateCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameInstance::SetIsAlternateCharacter(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "SetIsAlternateCharacter");

	Params::KosmosGameInstance_SetIsAlternateCharacter Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameInstance.SetStartupCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InCheckpointName                                       (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameInstance::SetStartupCheckpoint(const class FString& InCheckpointName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "SetStartupCheckpoint");

	Params::KosmosGameInstance_SetStartupCheckpoint Parms{};

	Parms.InCheckpointName = std::move(InCheckpointName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameInstance.GetKosmosSessionManager
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosOnlineSessionManager*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosOnlineSessionManager* UKosmosGameInstance::GetKosmosSessionManager() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameInstance", "GetKosmosSessionManager");

	Params::KosmosGameInstance_GetKosmosSessionManager Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeBase.GetCheckpointForChapterStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKosmosLevelNameReference& InChapter                                              (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString AKosmosGameModeBase::GetCheckpointForChapterStart(const struct FKosmosLevelNameReference& InChapter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeBase", "GetCheckpointForChapterStart");

	Params::KosmosGameModeBase_GetCheckpointForChapterStart Parms{};

	Parms.InChapter = std::move(InChapter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.CreateMissingCharacters
// (Final, Native, Public, BlueprintCallable)

void AKosmosGameModeInGame::CreateMissingCharacters()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "CreateMissingCharacters");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.GetCurrentCheckpointByCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AKosmosBaseCharacter*       InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCheckpoint*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosCheckpoint* AKosmosGameModeInGame::GetCurrentCheckpointByCharacter(const class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetCurrentCheckpointByCharacter");

	Params::KosmosGameModeInGame_GetCurrentCheckpointByCharacter Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.GetCurrentPrimaryCharacterCheckpoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosCheckpoint*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosCheckpoint* AKosmosGameModeInGame::GetCurrentPrimaryCharacterCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetCurrentPrimaryCharacterCheckpoint");

	Params::KosmosGameModeInGame_GetCurrentPrimaryCharacterCheckpoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.GetCurrentSecondaryCharacterCheckpoint
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosCheckpoint*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosCheckpoint* AKosmosGameModeInGame::GetCurrentSecondaryCharacterCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetCurrentSecondaryCharacterCheckpoint");

	Params::KosmosGameModeInGame_GetCurrentSecondaryCharacterCheckpoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.GetOtherCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* AKosmosGameModeInGame::GetOtherCharacter(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetOtherCharacter");

	Params::KosmosGameModeInGame_GetOtherCharacter Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.IsSinglePlayerGame
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosGameModeInGame::IsSinglePlayerGame()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "IsSinglePlayerGame");

	Params::KosmosGameModeInGame_IsSinglePlayerGame Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.K2_OnSetMatchState
// (Event, Protected, BlueprintEvent)
// Parameters:
// class FName                             NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::K2_OnSetMatchState(class FName NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "K2_OnSetMatchState");

	Params::KosmosGameModeInGame_K2_OnSetMatchState Parms{};

	Parms.NewState = NewState;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosGameModeInGame.ReadyToStartMatch
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosGameModeInGame::ReadyToStartMatch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "ReadyToStartMatch");

	Params::KosmosGameModeInGame_ReadyToStartMatch Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.ResumeFromCheckpoint
// (Final, Native, Public, BlueprintCallable)

void AKosmosGameModeInGame::ResumeFromCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "ResumeFromCheckpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SetCheckpointForChapterStart
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FKosmosLevelNameReference& InChapter                                              (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::SetCheckpointForChapterStart(const struct FKosmosLevelNameReference& InChapter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SetCheckpointForChapterStart");

	Params::KosmosGameModeInGame_SetCheckpointForChapterStart Parms{};

	Parms.InChapter = std::move(InChapter);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SetCurrentCheckpointByCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class AKosmosBaseCharacter*       InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInForceSet                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::SetCurrentCheckpointByCharacter(const class AKosmosBaseCharacter* InCharacter, class AKosmosCheckpoint* InCheckpoint, bool bInForceSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SetCurrentCheckpointByCharacter");

	Params::KosmosGameModeInGame_SetCurrentCheckpointByCharacter Parms{};

	Parms.InCharacter = InCharacter;
	Parms.InCheckpoint = InCheckpoint;
	Parms.bInForceSet = bInForceSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SetCurrentMajorCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInForceSet                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::SetCurrentMajorCheckpoint(class AKosmosCheckpoint* InCheckpoint, bool bInForceSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SetCurrentMajorCheckpoint");

	Params::KosmosGameModeInGame_SetCurrentMajorCheckpoint Parms{};

	Parms.InCheckpoint = InCheckpoint;
	Parms.bInForceSet = bInForceSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SetCurrentPrimaryCharacterCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInForceSet                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::SetCurrentPrimaryCharacterCheckpoint(class AKosmosCheckpoint* InCheckpoint, bool bInForceSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SetCurrentPrimaryCharacterCheckpoint");

	Params::KosmosGameModeInGame_SetCurrentPrimaryCharacterCheckpoint Parms{};

	Parms.InCheckpoint = InCheckpoint;
	Parms.bInForceSet = bInForceSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SetCurrentSecondaryCharacterCheckpoint
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosCheckpoint*                InCheckpoint                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInForceSet                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameModeInGame::SetCurrentSecondaryCharacterCheckpoint(class AKosmosCheckpoint* InCheckpoint, bool bInForceSet)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SetCurrentSecondaryCharacterCheckpoint");

	Params::KosmosGameModeInGame_SetCurrentSecondaryCharacterCheckpoint Parms{};

	Parms.InCheckpoint = InCheckpoint;
	Parms.bInForceSet = bInForceSet;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.StartMatch
// (Native, Protected, BlueprintCallable)

void AKosmosGameModeInGame::StartMatch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "StartMatch");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.SyncBothPlayersToTheSameCheckpoint
// (Final, Native, Public, BlueprintCallable)

void AKosmosGameModeInGame::SyncBothPlayersToTheSameCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "SyncBothPlayersToTheSameCheckpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameModeInGame.GetCharacterSelectionInverted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosGameModeInGame::GetCharacterSelectionInverted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetCharacterSelectionInverted");

	Params::KosmosGameModeInGame_GetCharacterSelectionInverted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.GetMatchState
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName AKosmosGameModeInGame::GetMatchState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "GetMatchState");

	Params::KosmosGameModeInGame_GetMatchState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameModeInGame.IsMatchInProgress
// (Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosGameModeInGame::IsMatchInProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameModeInGame", "IsMatchInProgress");

	Params::KosmosGameModeInGame_IsMatchInProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayEffectVolume.OnBeginOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameplayEffectVolume::OnBeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "OnBeginOverlap");

	Params::KosmosGameplayEffectVolume_OnBeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayEffectVolume.OnEndOverlap
// (Final, Native, Protected)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameplayEffectVolume::OnEndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "OnEndOverlap");

	Params::KosmosGameplayEffectVolume_OnEndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayEffectVolume.OnPawnBeginOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameplayEffectVolume::OnPawnBeginOverlap_Blueprint(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "OnPawnBeginOverlap_Blueprint");

	Params::KosmosGameplayEffectVolume_OnPawnBeginOverlap_Blueprint Parms{};

	Parms.Pawn = Pawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosGameplayEffectVolume.OnPawnEndOverlap_Blueprint
// (Event, Protected, BlueprintEvent)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameplayEffectVolume::OnPawnEndOverlap_Blueprint(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "OnPawnEndOverlap_Blueprint");

	Params::KosmosGameplayEffectVolume_OnPawnEndOverlap_Blueprint Parms{};

	Parms.Pawn = Pawn;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosGameplayEffectVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameplayEffectVolume::SetEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "SetEnabled");

	Params::KosmosGameplayEffectVolume_SetEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayEffectVolume.IsPawnOverlapping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosGameplayEffectVolume::IsPawnOverlapping(class APawn* Pawn) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "IsPawnOverlapping");

	Params::KosmosGameplayEffectVolume_IsPawnOverlapping Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayEffectVolume.NumOverlappingPawns
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKosmosGameplayEffectVolume::NumOverlappingPawns() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayEffectVolume", "NumOverlappingPawns");

	Params::KosmosGameplayEffectVolume_NumOverlappingPawns Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNome.Client_HandleResume
// (Net, NetReliable, Native, Event, NetMulticast, Protected)

void AKosmosNome::Client_HandleResume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "Client_HandleResume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNome.Client_SetEnabled
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNome::Client_SetEnabled(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "Client_SetEnabled");

	Params::KosmosNome_Client_SetEnabled Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNome.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNome::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "HandleResume");

	Params::KosmosNome_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNome.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNome::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "HandleSnapshot");

	Params::KosmosNome_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNome.IsNomeReadyToBeHugged
// (Native, Event, Public, BlueprintCallable, BlueprintEvent, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosNome::IsNomeReadyToBeHugged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "IsNomeReadyToBeHugged");

	Params::KosmosNome_IsNomeReadyToBeHugged Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNome.OnCheckpointResumed
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosNome::OnCheckpointResumed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "OnCheckpointResumed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosNome.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNome::SetEnabled(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNome", "SetEnabled");

	Params::KosmosNome_SetEnabled Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlayCharacterMontage.PlayCharacterMontage
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAnimMontage*                     MontageToPlay                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   PlayRate                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   StartingPosition                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             StartingSection                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosGameplayTask_PlayCharacterMontage*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosGameplayTask_PlayCharacterMontage* UKosmosGameplayTask_PlayCharacterMontage::PlayCharacterMontage(class AKosmosBaseCharacter* Character, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, class FName StartingSection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosGameplayTask_PlayCharacterMontage", "PlayCharacterMontage");

	Params::KosmosGameplayTask_PlayCharacterMontage_PlayCharacterMontage Parms{};

	Parms.Character = Character;
	Parms.MontageToPlay = MontageToPlay;
	Parms.PlayRate = PlayRate;
	Parms.StartingPosition = StartingPosition;
	Parms.StartingSection = StartingSection;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayTask_PlayCharacterMontage.OnMontageBlendingOut
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameplayTask_PlayCharacterMontage::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlayCharacterMontage", "OnMontageBlendingOut");

	Params::KosmosGameplayTask_PlayCharacterMontage_OnMontageBlendingOut Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlayCharacterMontage.OnMontageEnded
// (Final, Native, Protected)
// Parameters:
// class UAnimMontage*                     Montage                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInterrupted                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameplayTask_PlayCharacterMontage::OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlayCharacterMontage", "OnMontageEnded");

	Params::KosmosGameplayTask_PlayCharacterMontage_OnMontageEnded Parms{};

	Parms.Montage = Montage;
	Parms.bInterrupted = bInterrupted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlayCharacterMontage.OnNotifyBeginReceived
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosGameplayTask_PlayCharacterMontage::OnNotifyBeginReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlayCharacterMontage", "OnNotifyBeginReceived");

	Params::KosmosGameplayTask_PlayCharacterMontage_OnNotifyBeginReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlayCharacterMontage.OnNotifyEndReceived
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosGameplayTask_PlayCharacterMontage::OnNotifyEndReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlayCharacterMontage", "OnNotifyEndReceived");

	Params::KosmosGameplayTask_PlayCharacterMontage_OnNotifyEndReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.PlaypalActionRetainer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UKosmosAIAsyncAction> Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosGameplayTask_PlaypalActionRetainer*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosGameplayTask_PlaypalActionRetainer* UKosmosGameplayTask_PlaypalActionRetainer::PlaypalActionRetainer(class UObject* WorldContextObject, class AKosmosBaseCharacter* Character, TSubclassOf<class UKosmosAIAsyncAction> Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "PlaypalActionRetainer");

	Params::KosmosGameplayTask_PlaypalActionRetainer_PlaypalActionRetainer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;
	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.CancelAction
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DelayTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGameplayTask_PlaypalActionRetainer::CancelAction(float DelayTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "CancelAction");

	Params::KosmosGameplayTask_PlaypalActionRetainer_CancelAction Parms{};

	Parms.DelayTime = DelayTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.ClearCancel
// (Final, Native, Public, BlueprintCallable)

void UKosmosGameplayTask_PlaypalActionRetainer::ClearCancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "ClearCancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.IsTaskActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameplayTask_PlaypalActionRetainer::IsTaskActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "IsTaskActive");

	Params::KosmosGameplayTask_PlaypalActionRetainer_IsTaskActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.IsWatingForAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosGameplayTask_PlaypalActionRetainer::IsWatingForAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "IsWatingForAction");

	Params::KosmosGameplayTask_PlaypalActionRetainer_IsWatingForAction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameplayTask_PlaypalActionRetainer.OnInteractActionEnd
// (Final, Native, Protected)

void UKosmosGameplayTask_PlaypalActionRetainer::OnInteractActionEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameplayTask_PlaypalActionRetainer", "OnInteractActionEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitBlueprintLibrary.GetCurrentOutfitSaveCostume
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CharacterTag                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosOutfitBlueprintLibrary::GetCurrentOutfitSaveCostume(class UObject* WorldContextObject, const class FString& CharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOutfitBlueprintLibrary", "GetCurrentOutfitSaveCostume");

	Params::KosmosOutfitBlueprintLibrary_GetCurrentOutfitSaveCostume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.CharacterTag = std::move(CharacterTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOutfitBlueprintLibrary.RemoveCustomOutfit
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitBlueprintLibrary::RemoveCustomOutfit(class UObject* WorldContextObject, const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOutfitBlueprintLibrary", "RemoveCustomOutfit");

	Params::KosmosOutfitBlueprintLibrary_RemoveCustomOutfit Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitBlueprintLibrary.SetCurrentOutfitSaveCostume
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    CharacterTag                                           (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    OutfitVariation                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitBlueprintLibrary::SetCurrentOutfitSaveCostume(class UObject* WorldContextObject, const class FString& CharacterTag, const class FString& OutfitVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOutfitBlueprintLibrary", "SetCurrentOutfitSaveCostume");

	Params::KosmosOutfitBlueprintLibrary_SetCurrentOutfitSaveCostume Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.CharacterTag = std::move(CharacterTag);
	Parms.OutfitVariation = std::move(OutfitVariation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitBlueprintLibrary.SetCustomOutfit
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    OutfitVariant                                          (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitBlueprintLibrary::SetCustomOutfit(class UObject* WorldContextObject, const class AKosmosBaseCharacter* Character, const class FString& OutfitVariant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosOutfitBlueprintLibrary", "SetCustomOutfit");

	Params::KosmosOutfitBlueprintLibrary_SetCustomOutfit Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Character = Character;
	Parms.OutfitVariant = std::move(OutfitVariant);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlaypalInteraction.PlaypalInteraction
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UGameplayAbility*                 OwningAbility                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosGameplayTaskPlaypalInteractionTypeType                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UAbilityTask_PlaypalInteraction*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAbilityTask_PlaypalInteraction* UAbilityTask_PlaypalInteraction::PlaypalInteraction(class UGameplayAbility* OwningAbility, class AKosmosBaseCharacter* Character, EKosmosGameplayTaskPlaypalInteractionType Type)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("AbilityTask_PlaypalInteraction", "PlaypalInteraction");

	Params::AbilityTask_PlaypalInteraction_PlaypalInteraction Parms{};

	Parms.OwningAbility = OwningAbility;
	Parms.Character = Character;
	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_PlaypalInteraction.GetCrankAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosAIActionCrank*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIActionCrank* UAbilityTask_PlaypalInteraction::GetCrankAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlaypalInteraction", "GetCrankAction");

	Params::AbilityTask_PlaypalInteraction_GetCrankAction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_PlaypalInteraction.GetInteractAction
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosAIActionInteract*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIActionInteract* UAbilityTask_PlaypalInteraction::GetInteractAction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlaypalInteraction", "GetInteractAction");

	Params::AbilityTask_PlaypalInteraction_GetInteractAction Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.AbilityTask_PlaypalInteraction.OnInteractActionEnd
// (Final, Native, Private)

void UAbilityTask_PlaypalInteraction::OnInteractActionEnd()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlaypalInteraction", "OnInteractActionEnd");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.AbilityTask_PlaypalInteraction.IsValidPlaypal
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UAbilityTask_PlaypalInteraction::IsValidPlaypal() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("AbilityTask_PlaypalInteraction", "IsValidPlaypal");

	Params::AbilityTask_PlaypalInteraction_IsValidPlaypal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.CancelPlaypalActions
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlaypalInteractionPoint::CancelPlaypalActions(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "CancelPlaypalActions");

	Params::KosmosPlaypalInteractionPoint_CancelPlaypalActions Parms{};

	Parms.WorldContextObject = WorldContextObject;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosPlaypalInteractionPoint.FinishedPlaypalActions
// (Native, Public, BlueprintCallable)

void AKosmosPlaypalInteractionPoint::FinishedPlaypalActions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "FinishedPlaypalActions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.GetBehaviouralComponent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosBehaviouralPIPComponent*   ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosBehaviouralPIPComponent* AKosmosPlaypalInteractionPoint::GetBehaviouralComponent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "GetBehaviouralComponent");

	Params::KosmosPlaypalInteractionPoint_GetBehaviouralComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.GetMoveToVolumeActor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TSoftObjectPtr<class AKosmosPlaypalMoveToVolume>ReturnValue                                            (Parm, OutParm, ReturnParm, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSoftObjectPtr<class AKosmosPlaypalMoveToVolume> AKosmosPlaypalInteractionPoint::GetMoveToVolumeActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "GetMoveToVolumeActor");

	Params::KosmosPlaypalInteractionPoint_GetMoveToVolumeActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlaypalInteractionPoint::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "HandleResume");

	Params::KosmosPlaypalInteractionPoint_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlaypalInteractionPoint::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "HandleSnapshot");

	Params::KosmosPlaypalInteractionPoint_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalInteractionPoint.TriggerPlaypalActions
// (Event, Protected, BlueprintEvent)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlaypalInteractionPoint::TriggerPlaypalActions(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalInteractionPoint", "TriggerPlaypalActions");

	Params::KosmosPlaypalInteractionPoint_TriggerPlaypalActions Parms{};

	Parms.WorldContextObject = WorldContextObject;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosPauseManagementConmponent.SetCurrentPauseState_Server
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosPauseType                        InPauseType                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementConmponent::SetCurrentPauseState_Server(EKosmosPauseType InPauseType)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementConmponent", "SetCurrentPauseState_Server");

	Params::KosmosPauseManagementConmponent_SetCurrentPauseState_Server Parms{};

	Parms.InPauseType = InPauseType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementConmponent.SetIsAnyPlayerPaused_Multi
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    bInIsPaused                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementConmponent::SetIsAnyPlayerPaused_Multi(bool bInIsPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementConmponent", "SetIsAnyPlayerPaused_Multi");

	Params::KosmosPauseManagementConmponent_SetIsAnyPlayerPaused_Multi Parms{};

	Parms.bInIsPaused = bInIsPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementConmponent.SetIsPaused_Multi
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// bool                                    bInIsPaused                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementConmponent::SetIsPaused_Multi(bool bInIsPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementConmponent", "SetIsPaused_Multi");

	Params::KosmosPauseManagementConmponent_SetIsPaused_Multi Parms{};

	Parms.bInIsPaused = bInIsPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementConmponent.SetIsPaused_Server
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// bool                                    bInIsPaused                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementConmponent::SetIsPaused_Server(bool bInIsPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementConmponent", "SetIsPaused_Server");

	Params::KosmosPauseManagementConmponent_SetIsPaused_Server Parms{};

	Parms.bInIsPaused = bInIsPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementConmponent.GetCurrentPauseState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosPauseType                        ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosPauseType UKosmosPauseManagementConmponent::GetCurrentPauseState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementConmponent", "GetCurrentPauseState");

	Params::KosmosPauseManagementConmponent_GetCurrentPauseState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGameStateInGame.Client_InvokeNetSyncGameEvent
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const struct FNetSyncGameEventIdentifier&Identifier                                             (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InvokeTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ENetSyncEventResult                     Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGameStateInGame::Client_InvokeNetSyncGameEvent(const struct FNetSyncGameEventIdentifier& Identifier, float InvokeTime, ENetSyncEventResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameStateInGame", "Client_InvokeNetSyncGameEvent");

	Params::KosmosGameStateInGame_Client_InvokeNetSyncGameEvent Parms{};

	Parms.Identifier = std::move(Identifier);
	Parms.InvokeTime = InvokeTime;
	Parms.Result = Result;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameStateInGame.OnRep_MatchState
// (Native, Protected)

void AKosmosGameStateInGame::OnRep_MatchState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGameStateInGame", "OnRep_MatchState");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGameUserSettingsBlueprintLibrary.GetKosmosGameUserSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UKosmosGameUserSettings*          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosGameUserSettings* UKosmosGameUserSettingsBlueprintLibrary::GetKosmosGameUserSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosGameUserSettingsBlueprintLibrary", "GetKosmosGameUserSettings");

	Params::KosmosGameUserSettingsBlueprintLibrary_GetKosmosGameUserSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCarriable.PlaypalCarriable_Pickup
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosCarriable*                 Carriable                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCarriable*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCarriable* UKosmosPlaypalCommandsCarriable::PlaypalCarriable_Pickup(class UObject* WorldContextObject, class AKosmosCarriable* Carriable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCarriable", "PlaypalCarriable_Pickup");

	Params::KosmosPlaypalCommandsCarriable_PlaypalCarriable_Pickup Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Carriable = Carriable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCarriable.PlaypalCarriable_Putdown
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldMoveToLocation                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   MoveToLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCarriable*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCarriable* UKosmosPlaypalCommandsCarriable::PlaypalCarriable_Putdown(class UObject* WorldContextObject, bool ShouldMoveToLocation, const struct FVector& MoveToLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCarriable", "PlaypalCarriable_Putdown");

	Params::KosmosPlaypalCommandsCarriable_PlaypalCarriable_Putdown Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShouldMoveToLocation = ShouldMoveToLocation;
	Parms.MoveToLocation = std::move(MoveToLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsCarriable.PlaypalCarriable_Throw
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ThrowStandLocation                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ThrowTargetActor                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsCarriable*  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsCarriable* UKosmosPlaypalCommandsCarriable::PlaypalCarriable_Throw(class UObject* WorldContextObject, class AActor* ThrowStandLocation, class AActor* ThrowTargetActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsCarriable", "PlaypalCarriable_Throw");

	Params::KosmosPlaypalCommandsCarriable_PlaypalCarriable_Throw Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ThrowStandLocation = ThrowStandLocation;
	Parms.ThrowTargetActor = ThrowTargetActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGasMask.RefillGasMask
// (Native, Protected)

void AKosmosGasMask::RefillGasMask()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGasMask", "RefillGasMask");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGasMask.TryRefillGasMask
// (Final, Native, Public)
// Parameters:
// const EKosmosBreathingState             NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosBreathingState             OldState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosGasMask::TryRefillGasMask(const EKosmosBreathingState NewState, const EKosmosBreathingState OldState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGasMask", "TryRefillGasMask");

	Params::KosmosGasMask_TryRefillGasMask Parms{};

	Parms.NewState = NewState;
	Parms.OldState = OldState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGlyphWidget.SetUpGlyph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const struct FSMGMappingReference&      InMappingReference                                     (Parm, NativeAccessSpecifierPublic)
// float                                   GlyphWidth                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GlyphHeight                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInstantFadeIn                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInIsNegativeValue                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGlyphWidget::SetUpGlyph(const struct FSMGMappingReference& InMappingReference, float GlyphWidth, float GlyphHeight, class APlayerController* InPlayerController, bool bInstantFadeIn, bool bInIsNegativeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGlyphWidget", "SetUpGlyph");

	Params::KosmosGlyphWidget_SetUpGlyph Parms{};

	Parms.InMappingReference = std::move(InMappingReference);
	Parms.GlyphWidth = GlyphWidth;
	Parms.GlyphHeight = GlyphHeight;
	Parms.InPlayerController = InPlayerController;
	Parms.bInstantFadeIn = bInstantFadeIn;
	Parms.bInIsNegativeValue = bInIsNegativeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGlyphWidget.UpdateGlyph
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGlyphWidget::UpdateGlyph(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGlyphWidget", "UpdateGlyph");

	Params::KosmosGlyphWidget_UpdateGlyph Parms{};

	Parms.InPlayerController = InPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.GrabbableLedgeComponent.SetLedgeEnabled
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    Enabled                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UGrabbableLedgeComponent::SetLedgeEnabled(bool Enabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabbableLedgeComponent", "SetLedgeEnabled");

	Params::GrabbableLedgeComponent_SetLedgeEnabled Parms{};

	Parms.Enabled = Enabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.GrabbableLedgeComponent.GetClosestPointOnLedge
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    mustBeClimbable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   minimumDistanceToEdge                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outClosestPoint                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         outLedgeForward                                        (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabbableLedgeComponent::GetClosestPointOnLedge(const struct FVector& Location, bool mustBeClimbable, float minimumDistanceToEdge, struct FVector* outClosestPoint, struct FVector* outLedgeForward) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabbableLedgeComponent", "GetClosestPointOnLedge");

	Params::GrabbableLedgeComponent_GetClosestPointOnLedge Parms{};

	Parms.Location = std::move(Location);
	Parms.mustBeClimbable = mustBeClimbable;
	Parms.minimumDistanceToEdge = minimumDistanceToEdge;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outClosestPoint != nullptr)
		*outClosestPoint = std::move(Parms.outClosestPoint);

	if (outLedgeForward != nullptr)
		*outLedgeForward = std::move(Parms.outLedgeForward);

	return Parms.ReturnValue;
}


// Function Kosmos.GrabbableLedgeComponent.IsLedgeEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UGrabbableLedgeComponent::IsLedgeEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("GrabbableLedgeComponent", "IsLedgeEnabled");

	Params::GrabbableLedgeComponent_IsLedgeEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosGrungeComponent.NotifyBeginOverlap
// (Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UKosmosGrungeComponent::NotifyBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "NotifyBeginOverlap");

	Params::KosmosGrungeComponent_NotifyBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGrungeComponent.NotifyEndOverlap
// (Native, Protected, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGrungeComponent::NotifyEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "NotifyEndOverlap");

	Params::KosmosGrungeComponent_NotifyEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGrungeComponent.OnOutfitChanged
// (Final, Native, Protected)

void UKosmosGrungeComponent::OnOutfitChanged()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "OnOutfitChanged");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGrungeComponent.RegisterPainter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosGrungePainterComponent*    Painter                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGrungeComponent::RegisterPainter(class UKosmosGrungePainterComponent* Painter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "RegisterPainter");

	Params::KosmosGrungeComponent_RegisterPainter Parms{};

	Parms.Painter = Painter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGrungeComponent.UnRegisterPainter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosGrungePainterComponent*    Painter                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosGrungeComponent::UnRegisterPainter(class UKosmosGrungePainterComponent* Painter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "UnRegisterPainter");

	Params::KosmosGrungeComponent_UnRegisterPainter Parms{};

	Parms.Painter = Painter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosGrungeComponent.GetGrungeData
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EGrungeType                             Type                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FGrungeData                      ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

struct FGrungeData UKosmosGrungeComponent::GetGrungeData(EGrungeType Type) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosGrungeComponent", "GetGrungeData");

	Params::KosmosGrungeComponent_GetGrungeData Parms{};

	Parms.Type = Type;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHangableComponent.SetIsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              IsEnabled                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHangableComponent::SetIsEnabled(const bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableComponent", "SetIsEnabled");

	Params::KosmosHangableComponent_SetIsEnabled Parms{};

	Parms.IsEnabled = IsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableComponent.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHangableComponent::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableComponent", "IsEnabled");

	Params::KosmosHangableComponent_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHangableComponent.IsGrabbed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHangableComponent::IsGrabbed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableComponent", "IsGrabbed");

	Params::KosmosHangableComponent_IsGrabbed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHangableComponent.IsTransitioning
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHangableComponent::IsTransitioning() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableComponent", "IsTransitioning");

	Params::KosmosHangableComponent_IsTransitioning Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlayerController.Client_DebugTeleport
// (Net, NetReliable, Native, Event, Public, NetServer, HasDefaults)
// Parameters:
// const struct FVector&                   DestLocation                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  DestRotation                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIsATest                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNoCheck                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Client_DebugTeleport(const struct FVector& DestLocation, const struct FRotator& DestRotation, bool bIsATest, bool bNoCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Client_DebugTeleport");

	Params::KosmosPlayerController_Client_DebugTeleport Parms{};

	Parms.DestLocation = std::move(DestLocation);
	Parms.DestRotation = std::move(DestRotation);
	Parms.bIsATest = bIsATest;
	Parms.bNoCheck = bNoCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Client_FadeIn
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Client_FadeIn(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Client_FadeIn");

	Params::KosmosPlayerController_Client_FadeIn Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Client_FadeOut
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Client_FadeOut(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Client_FadeOut");

	Params::KosmosPlayerController_Client_FadeOut Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Client_PostTelemtryOnCheckpoint
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const class FString&                    InGameID                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InDurationInGame                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Client_PostTelemtryOnCheckpoint(const class FString& InGameID, float InDurationInGame)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Client_PostTelemtryOnCheckpoint");

	Params::KosmosPlayerController_Client_PostTelemtryOnCheckpoint Parms{};

	Parms.InGameID = std::move(InGameID);
	Parms.InDurationInGame = InDurationInGame;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Client_PostTelemtryStartGameSession
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// const class FString&                    InGameID                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InDurationInGame                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Client_PostTelemtryStartGameSession(const class FString& InGameID, float InDurationInGame)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Client_PostTelemtryStartGameSession");

	Params::KosmosPlayerController_Client_PostTelemtryStartGameSession Parms{};

	Parms.InGameID = std::move(InGameID);
	Parms.InDurationInGame = InDurationInGame;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.ClientQuitToFrontend
// (Net, NetReliable, Native, Event, Public, NetClient)
// Parameters:
// EKosmosQuitToFrontEndReason             InQuitToFrontEndReason                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::ClientQuitToFrontend(EKosmosQuitToFrontEndReason InQuitToFrontEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "ClientQuitToFrontend");

	Params::KosmosPlayerController_ClientQuitToFrontend Parms{};

	Parms.InQuitToFrontEndReason = InQuitToFrontEndReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.ClientReportServerTime
// (Net, NetReliable, Native, Event, Protected, NetClient)
// Parameters:
// float                                   requestWorldTime                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   serverTime                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::ClientReportServerTime(float requestWorldTime, float serverTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "ClientReportServerTime");

	Params::KosmosPlayerController_ClientReportServerTime Parms{};

	Parms.requestWorldTime = requestWorldTime;
	Parms.serverTime = serverTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.ClientResetView
// (Net, NetReliable, Native, Event, Public, NetClient)

void AKosmosPlayerController::ClientResetView()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "ClientResetView");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.FadeIn
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::FadeIn(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "FadeIn");

	Params::KosmosPlayerController_FadeIn Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.FadeInAudio
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::FadeInAudio(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "FadeInAudio");

	Params::KosmosPlayerController_FadeInAudio Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.FadeOut
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::FadeOut(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "FadeOut");

	Params::KosmosPlayerController_FadeOut Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.FadeOutAudio
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::FadeOutAudio(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "FadeOutAudio");

	Params::KosmosPlayerController_FadeOutAudio Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Server_DebugTeleport
// (Net, NetReliable, Native, Event, NetMulticast, Public, HasDefaults)
// Parameters:
// const struct FVector&                   DestLocation                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  DestRotation                                           (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bIsATest                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNoCheck                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Server_DebugTeleport(const struct FVector& DestLocation, const struct FRotator& DestRotation, bool bIsATest, bool bNoCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Server_DebugTeleport");

	Params::KosmosPlayerController_Server_DebugTeleport Parms{};

	Parms.DestLocation = std::move(DestLocation);
	Parms.DestRotation = std::move(DestRotation);
	Parms.bIsATest = bIsATest;
	Parms.bNoCheck = bNoCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Server_FadeIn
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Server_FadeIn(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Server_FadeIn");

	Params::KosmosPlayerController_Server_FadeIn Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Server_FadeOut
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Server_FadeOut(float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Server_FadeOut");

	Params::KosmosPlayerController_Server_FadeOut Parms{};

	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.Server_RegisterNetSyncGameEvent
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// const struct FNetSyncGameEventMessage&  Msg                                                    (ConstParm, Parm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosPlayerController::Server_RegisterNetSyncGameEvent(const struct FNetSyncGameEventMessage& Msg)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "Server_RegisterNetSyncGameEvent");

	Params::KosmosPlayerController_Server_RegisterNetSyncGameEvent Parms{};

	Parms.Msg = std::move(Msg);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.ServerQuitToFrontend
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
// Parameters:
// EKosmosQuitToFrontEndReason             InQuitToFrontEndReason                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::ServerQuitToFrontend(EKosmosQuitToFrontEndReason InQuitToFrontEndReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "ServerQuitToFrontend");

	Params::KosmosPlayerController_ServerQuitToFrontend Parms{};

	Parms.InQuitToFrontEndReason = InQuitToFrontEndReason;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.ServerRequestServerTime
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// class APlayerController*                requester                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   requestWorldTime                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::ServerRequestServerTime(class APlayerController* requester, float requestWorldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "ServerRequestServerTime");

	Params::KosmosPlayerController_ServerRequestServerTime Parms{};

	Parms.requester = requester;
	Parms.requestWorldTime = requestWorldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.SetShowMouseCursor
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInShowMouseCursor                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPlayerController::SetShowMouseCursor(bool bInShowMouseCursor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "SetShowMouseCursor");

	Params::KosmosPlayerController_SetShowMouseCursor Parms{};

	Parms.bInShowMouseCursor = bInShowMouseCursor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerController.AllowDebugControls
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPlayerController::AllowDebugControls() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "AllowDebugControls");

	Params::KosmosPlayerController_AllowDebugControls Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlayerController.GetCurrentControlScheme
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosControlScheme                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosControlScheme AKosmosPlayerController::GetCurrentControlScheme() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "GetCurrentControlScheme");

	Params::KosmosPlayerController_GetCurrentControlScheme Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlayerController.GetHUDComponent
// (Final, Native, Public, Const)
// Parameters:
// class UKosmosHUDComponent*              ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosHUDComponent* AKosmosPlayerController::GetHUDComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerController", "GetHUDComponent");

	Params::KosmosPlayerController_GetHUDComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHangableInterface.IsReleaseGrabRestricted
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHangableInterface::IsReleaseGrabRestricted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "IsReleaseGrabRestricted");

	Params::KosmosHangableInterface_IsReleaseGrabRestricted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHangableInterface.Multicast_GrabEndError
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, HasDefaults)
// Parameters:
// const struct FVector&                   CorrectLocation                                        (ConstParm, Parm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHangableInterface::Multicast_GrabEndError(const struct FVector& CorrectLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "Multicast_GrabEndError");

	Params::KosmosHangableInterface_Multicast_GrabEndError Parms{};

	Parms.CorrectLocation = std::move(CorrectLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.OnJumpChanged
// (Final, Native, Private)
// Parameters:
// bool                                    bNewJump                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHangableInterface::OnJumpChanged(bool bNewJump)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "OnJumpChanged");

	Params::KosmosHangableInterface_OnJumpChanged Parms{};

	Parms.bNewJump = bNewJump;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.OnTransitionFinished
// (Final, Native, Private)

void UKosmosHangableInterface::OnTransitionFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "OnTransitionFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.RestrictReleaseGrab
// (Final, Native, Public, BlueprintCallable)

void UKosmosHangableInterface::RestrictReleaseGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "RestrictReleaseGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.SetGrabHangable
// (Final, Native, Private)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAutoTraversing                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHangableInterface::SetGrabHangable(class UKosmosHangableComponent* hangable, bool bIsAutoTraversing)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "SetGrabHangable");

	Params::KosmosHangableInterface_SetGrabHangable Parms{};

	Parms.hangable = hangable;
	Parms.bIsAutoTraversing = bIsAutoTraversing;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.TransitionProgress
// (Final, Native, Private)
// Parameters:
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHangableInterface::TransitionProgress(float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "TransitionProgress");

	Params::KosmosHangableInterface_TransitionProgress Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHangableInterface.UnRestrictReleaseGrab
// (Final, Native, Public, BlueprintCallable)

void UKosmosHangableInterface::UnRestrictReleaseGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHangableInterface", "UnRestrictReleaseGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.HideCollectableFoundScreen
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    QuickHide                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::HideCollectableFoundScreen(class UObject* WorldContextObject, bool QuickHide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "HideCollectableFoundScreen");

	Params::KosmosHUDBlueprintLibrary_HideCollectableFoundScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.QuickHide = QuickHide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.HideLoadingScreen
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    QuickHide                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::HideLoadingScreen(class UObject* WorldContextObject, bool QuickHide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "HideLoadingScreen");

	Params::KosmosHUDBlueprintLibrary_HideLoadingScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.QuickHide = QuickHide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.HideTutorialPrompt
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    QuickHide                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::HideTutorialPrompt(class UObject* WorldContextObject, bool QuickHide)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "HideTutorialPrompt");

	Params::KosmosHUDBlueprintLibrary_HideTutorialPrompt Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.QuickHide = QuickHide;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.IsLoadingScreenShowing
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHUDBlueprintLibrary::IsLoadingScreenShowing(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "IsLoadingScreenShowing");

	Params::KosmosHUDBlueprintLibrary_IsLoadingScreenShowing Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.ShowCollectableFoundScreen
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&InCollectableName                                      (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::ShowCollectableFoundScreen(class UObject* WorldContextObject, const struct FKosmosCollectableNameReference& InCollectableName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "ShowCollectableFoundScreen");

	Params::KosmosHUDBlueprintLibrary_ShowCollectableFoundScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCollectableName = std::move(InCollectableName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.ShowLoadingScreen
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosHUDBlueprintLibrary::ShowLoadingScreen(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "ShowLoadingScreen");

	Params::KosmosHUDBlueprintLibrary_ShowLoadingScreen Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.ShowSavingIcon
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::ShowSavingIcon(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "ShowSavingIcon");

	Params::KosmosHUDBlueprintLibrary_ShowSavingIcon Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDBlueprintLibrary.ShowTutorialPrompt
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      TutorialText                                           (Parm, NativeAccessSpecifierPublic)
// const TArray<struct FSMGMappingReference>&ButtonMapping                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bIsKeyNegativeScale                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IgnoreTimeout                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Timeout                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDBlueprintLibrary::ShowTutorialPrompt(class UObject* WorldContextObject, const class FText& TutorialText, const TArray<struct FSMGMappingReference>& ButtonMapping, bool bIsKeyNegativeScale, bool IgnoreTimeout, float Timeout)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosHUDBlueprintLibrary", "ShowTutorialPrompt");

	Params::KosmosHUDBlueprintLibrary_ShowTutorialPrompt Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.TutorialText = std::move(TutorialText);
	Parms.ButtonMapping = std::move(ButtonMapping);
	Parms.bIsKeyNegativeScale = bIsKeyNegativeScale;
	Parms.IgnoreTimeout = IgnoreTimeout;
	Parms.Timeout = Timeout;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalMoveToVolume.ForceUpdate
// (Final, Native, Public, BlueprintCallable)

void AKosmosPlaypalMoveToVolume::ForceUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlaypalMoveToVolume", "ForceUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRoom.GetLevels
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosRoomLevelFlags                   LevelFlags                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<TSoftObjectPtr<class UWorld>>    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, UObjectWrapper, NativeAccessSpecifierPublic)

TArray<TSoftObjectPtr<class UWorld>> UKosmosRoom::GetLevels(EKosmosRoomLevelFlags LevelFlags) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoom", "GetLevels");

	Params::KosmosRoom_GetLevels Parms{};

	Parms.LevelFlags = LevelFlags;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoom.IsLoadedAndVisible
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IgnoreNonCriticalLevels                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosRoom::IsLoadedAndVisible(const class UObject* WorldContextObject, bool IgnoreNonCriticalLevels) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoom", "IsLoadedAndVisible");

	Params::KosmosRoom_IsLoadedAndVisible Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.IgnoreNonCriticalLevels = IgnoreNonCriticalLevels;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosHUDItemOffScreen.ManageHudWidget
// (Final, Native, Public)

void UKosmosHUDItemOffScreen::ManageHudWidget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHUDItemOffScreen", "ManageHudWidget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalGetCurrentCommand
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAIAsyncAction*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAIAsyncAction* UKosmosPlaypalCommandUtils::PlaypalGetCurrentCommand(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalGetCurrentCommand");

	Params::KosmosPlaypalCommandUtils_PlaypalGetCurrentCommand Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalIsRunningAction
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UKosmosAIAsyncAction> ActionToCheck                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPlaypalCommandUtils::PlaypalIsRunningAction(class UObject* WorldContextObject, TSubclassOf<class UKosmosAIAsyncAction> ActionToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalIsRunningAction");

	Params::KosmosPlaypalCommandUtils_PlaypalIsRunningAction Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActionToCheck = ActionToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalManualJumpOff
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   JumpToDir                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPlaypalCommandUtils::PlaypalManualJumpOff(class UObject* WorldContextObject, const struct FVector& JumpToDir)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalManualJumpOff");

	Params::KosmosPlaypalCommandUtils_PlaypalManualJumpOff Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.JumpToDir = std::move(JumpToDir);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalMoveToMode
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EAIPlaypalChaseMode                     Mode                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPlaypalCommandUtils::PlaypalMoveToMode(class UObject* WorldContextObject, EAIPlaypalChaseMode Mode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalMoveToMode");

	Params::KosmosPlaypalCommandUtils_PlaypalMoveToMode Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Mode = Mode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalMoveToOffset
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPlaypalCommandUtils::PlaypalMoveToOffset(class UObject* WorldContextObject, bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalMoveToOffset");

	Params::KosmosPlaypalCommandUtils_PlaypalMoveToOffset Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalSetAvoidPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldAvoidPlayer                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPlaypalCommandUtils::PlaypalSetAvoidPlayer(class UObject* WorldContextObject, bool ShouldAvoidPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalSetAvoidPlayer");

	Params::KosmosPlaypalCommandUtils_PlaypalSetAvoidPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShouldAvoidPlayer = ShouldAvoidPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalStopCurrentCommand
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPlaypalCommandUtils::PlaypalStopCurrentCommand(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalStopCurrentCommand");

	Params::KosmosPlaypalCommandUtils_PlaypalStopCurrentCommand Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlaypalCommandUtils.PlaypalSwingableManualJumpOff
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPlaypalCommandUtils::PlaypalSwingableManualJumpOff(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandUtils", "PlaypalSwingableManualJumpOff");

	Params::KosmosPlaypalCommandUtils_PlaypalSwingableManualJumpOff Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDItemToggleHint.EnableHudWidget
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bEnable                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDItemToggleHint::EnableHudWidget(const bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHUDItemToggleHint", "EnableHudWidget");

	Params::KosmosHUDItemToggleHint_EnableHudWidget Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosHUDItemToggleHint.ToggleIcon
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const EToggleType                       ToggleType                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bEnabled                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosHUDItemToggleHint::ToggleIcon(const EToggleType ToggleType, const bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosHUDItemToggleHint", "ToggleIcon");

	Params::KosmosHUDItemToggleHint_ToggleIcon Parms{};

	Parms.ToggleType = ToggleType;
	Parms.bEnabled = bEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSwingable.OnHangableEndGrabEvent
// (Native, Protected)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosSwingable::OnHangableEndGrabEvent(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwingable", "OnHangableEndGrabEvent");

	Params::KosmosSwingable_OnHangableEndGrabEvent Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSwingable.OnHangableStartGrabEvent
// (Native, Protected)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosSwingable::OnHangableStartGrabEvent(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwingable", "OnHangableStartGrabEvent");

	Params::KosmosSwingable_OnHangableStartGrabEvent Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSwingable.SetIsEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              IsEnabled                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosSwingable::SetIsEnabled(const bool IsEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwingable", "SetIsEnabled");

	Params::KosmosSwingable_SetIsEnabled Parms{};

	Parms.IsEnabled = IsEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIdleBehaviourComponent.ForceExitIdleAnim
// (Final, Native, Public, BlueprintCallable)

void UKosmosIdleBehaviourComponent::ForceExitIdleAnim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIdleBehaviourComponent", "ForceExitIdleAnim");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIdleBehaviourComponent.PlayIdle
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class FName                             IdleAnimID                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosIdleBehaviourComponent::PlayIdle(class FName IdleAnimID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIdleBehaviourComponent", "PlayIdle");

	Params::KosmosIdleBehaviourComponent_PlayIdle Parms{};

	Parms.IdleAnimID = IdleAnimID;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosIdleBehaviourComponent.SetEnable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIdleBehaviourComponent::SetEnable(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIdleBehaviourComponent", "SetEnable");

	Params::KosmosIdleBehaviourComponent_SetEnable Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIdleBehaviourComponent.SetIdleEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bEnable                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIdleBehaviourComponent::SetIdleEnabled(bool bEnable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIdleBehaviourComponent", "SetIdleEnabled");

	Params::KosmosIdleBehaviourComponent_SetIdleEnabled Parms{};

	Parms.bEnable = bEnable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIdleBehaviourComponent.IsBusy
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosIdleBehaviourComponent::IsBusy() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIdleBehaviourComponent", "IsBusy");

	Params::KosmosIdleBehaviourComponent_IsBusy Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQTESequence.BeginForCharacter
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             KosmosCharacter                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::BeginForCharacter(class AKosmosBaseCharacter* KosmosCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "BeginForCharacter");

	Params::KosmosQTESequence_BeginForCharacter Parms{};

	Parms.KosmosCharacter = KosmosCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.Failed
// (Final, Native, Public, BlueprintCallable)

void AKosmosQTESequence::Failed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "Failed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.Finish
// (Final, Native, Public, BlueprintCallable)

void AKosmosQTESequence::Finish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "Finish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.GetCharacterData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    bIsPrimary                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosQTESequenceCharData ReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NativeAccessSpecifierPublic)

const struct FKosmosQTESequenceCharData AKosmosQTESequence::GetCharacterData(bool bIsPrimary)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "GetCharacterData");

	Params::KosmosQTESequence_GetCharacterData Parms{};

	Parms.bIsPrimary = bIsPrimary;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQTESequence.GetCurrentSectionIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKosmosQTESequence::GetCurrentSectionIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "GetCurrentSectionIndex");

	Params::KosmosQTESequence_GetCurrentSectionIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQTESequence.GetCurrentSectionName
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName AKosmosQTESequence::GetCurrentSectionName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "GetCurrentSectionName");

	Params::KosmosQTESequence_GetCurrentSectionName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQTESequence.GetSectionData
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   SectionIndex                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosQTESequenceSectionDataReturnValue                                            (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

const struct FKosmosQTESequenceSectionData AKosmosQTESequence::GetSectionData(int32 SectionIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "GetSectionData");

	Params::KosmosQTESequence_GetSectionData Parms{};

	Parms.SectionIndex = SectionIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQTESequence.Multicast_ResetQTESection
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// bool                                    bFinished                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::Multicast_ResetQTESection(bool bFinished)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "Multicast_ResetQTESection");

	Params::KosmosQTESequence_Multicast_ResetQTESection Parms{};

	Parms.bFinished = bFinished;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.OnRep_CurrentState
// (Final, Native, Private)
// Parameters:
// EKosmosQTESequenceState                 PrevState                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::OnRep_CurrentState(EKosmosQTESequenceState PrevState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "OnRep_CurrentState");

	Params::KosmosQTESequence_OnRep_CurrentState Parms{};

	Parms.PrevState = PrevState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.ProcessQTEInteract
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bGrabInteract                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::ProcessQTEInteract(class AKosmosBaseCharacter* Character, bool bGrabInteract)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "ProcessQTEInteract");

	Params::KosmosQTESequence_ProcessQTEInteract Parms{};

	Parms.Character = Character;
	Parms.bGrabInteract = bGrabInteract;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.ProcessRepFailed
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::ProcessRepFailed(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "ProcessRepFailed");

	Params::KosmosQTESequence_ProcessRepFailed Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQTESequence.ProcessRepSuccess
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQTESequence::ProcessRepSuccess(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQTESequence", "ProcessRepSuccess");

	Params::KosmosQTESequence_ProcessRepSuccess Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIKComponent.ClearTaskTransform
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosIKTasks                          InTask                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIKComponent::ClearTaskTransform(EKosmosIKTasks InTask)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "ClearTaskTransform");

	Params::KosmosIKComponent_ClearTaskTransform Parms{};

	Parms.InTask = InTask;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIKComponent.ComputeAggregatedIKErrorAgainstPose
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector*                         outTranslationError                                    (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        outRotationError                                       (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// const struct FTransform&                Offset                                                 (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosIKComponent::ComputeAggregatedIKErrorAgainstPose(struct FVector* outTranslationError, struct FRotator* outRotationError, const struct FTransform& Offset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "ComputeAggregatedIKErrorAgainstPose");

	Params::KosmosIKComponent_ComputeAggregatedIKErrorAgainstPose Parms{};

	Parms.Offset = std::move(Offset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (outTranslationError != nullptr)
		*outTranslationError = std::move(Parms.outTranslationError);

	if (outRotationError != nullptr)
		*outRotationError = std::move(Parms.outRotationError);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosIKComponent.GetTaskTransform
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const EKosmosIKTasks                    InTask                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UKosmosIKComponent::GetTaskTransform(const EKosmosIKTasks InTask)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "GetTaskTransform");

	Params::KosmosIKComponent_GetTaskTransform Parms{};

	Parms.InTask = InTask;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosIKComponent.SetTask
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EKosmosIKTasks                          InTask                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                InTransform                                            (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bInUseCurve                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIKComponent::SetTask(EKosmosIKTasks InTask, const struct FTransform& InTransform, bool bInUseCurve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "SetTask");

	Params::KosmosIKComponent_SetTask Parms{};

	Parms.InTask = InTask;
	Parms.InTransform = std::move(InTransform);
	Parms.bInUseCurve = bInUseCurve;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIKComponent.SetTaskDynamic
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// EKosmosIKTasks                          InTask                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class USceneComponent*                  InComponent                                            (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                InLocalTransformOffset                                 (Parm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    bInUseCurve                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIKComponent::SetTaskDynamic(EKosmosIKTasks InTask, class USceneComponent* InComponent, const struct FTransform& InLocalTransformOffset, bool bInUseCurve)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "SetTaskDynamic");

	Params::KosmosIKComponent_SetTaskDynamic Parms{};

	Parms.InTask = InTask;
	Parms.InComponent = InComponent;
	Parms.InLocalTransformOffset = std::move(InLocalTransformOffset);
	Parms.bInUseCurve = bInUseCurve;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIKComponent.UpdateTaskTransforms
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosIKComponent::UpdateTaskTransforms(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "UpdateTaskTransforms");

	Params::KosmosIKComponent_UpdateTaskTransforms Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosIKComponent.IsAnyTaskAlphaActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosIKComponent::IsAnyTaskAlphaActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "IsAnyTaskAlphaActive");

	Params::KosmosIKComponent_IsAnyTaskAlphaActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosIKComponent.IsTaskSet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EKosmosIKTasks                    InTask                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosIKComponent::IsTaskSet(const EKosmosIKTasks InTask) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIKComponent", "IsTaskSet");

	Params::KosmosIKComponent_IsTaskSet Parms{};

	Parms.InTask = InTask;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosIlluminatorBridge.GetBridgeOffset
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosIlluminatorBridge::GetBridgeOffset()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosIlluminatorBridge", "GetBridgeOffset");

	Params::KosmosIlluminatorBridge_GetBridgeOffset Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSlidingComponent.OnJumpChanged
// (Final, Native, Protected)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlidingComponent::OnJumpChanged(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlidingComponent", "OnJumpChanged");

	Params::KosmosSlidingComponent_OnJumpChanged Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlidingComponent.OnSlideChanged
// (Final, Native, Protected)
// Parameters:
// bool                                    bValue                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlidingComponent::OnSlideChanged(bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlidingComponent", "OnSlideChanged");

	Params::KosmosSlidingComponent_OnSlideChanged Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInputBPLibrary.BindingsHaveChanged
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::BindingsHaveChanged(const class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "BindingsHaveChanged");

	Params::KosmosInputBPLibrary_BindingsHaveChanged Parms{};

	Parms.InPlayerController = InPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CalculateDirectionalInputUpdate
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// float                                   InCurrentProgress                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosDirectionalInputParameters&InParameters                                           (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// bool*                                   OutInputNulled                                         (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosInputBPLibrary::CalculateDirectionalInputUpdate(float InCurrentProgress, class AKosmosBaseCharacter* InCharacter, const struct FKosmosDirectionalInputParameters& InParameters, bool* OutInputNulled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CalculateDirectionalInputUpdate");

	Params::KosmosInputBPLibrary_CalculateDirectionalInputUpdate Parms{};

	Parms.InCurrentProgress = InCurrentProgress;
	Parms.InCharacter = InCharacter;
	Parms.InParameters = std::move(InParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutInputNulled != nullptr)
		*OutInputNulled = Parms.OutInputNulled;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckBackPressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckBackPressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckBackPressed");

	Params::KosmosInputBPLibrary_CheckBackPressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckLeftFacePressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckLeftFacePressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckLeftFacePressed");

	Params::KosmosInputBPLibrary_CheckLeftFacePressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckProfilePressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckProfilePressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckProfilePressed");

	Params::KosmosInputBPLibrary_CheckProfilePressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckQuitPressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckQuitPressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckQuitPressed");

	Params::KosmosInputBPLibrary_CheckQuitPressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckReadyInvitePressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckReadyInvitePressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckReadyInvitePressed");

	Params::KosmosInputBPLibrary_CheckReadyInvitePressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckSelectPressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayer                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckSelectPressed(const class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckSelectPressed");

	Params::KosmosInputBPLibrary_CheckSelectPressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckSettingsClearPressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckSettingsClearPressed(class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckSettingsClearPressed");

	Params::KosmosInputBPLibrary_CheckSettingsClearPressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.CheckSettingsResetPressed
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::CheckSettingsResetPressed(class APlayerController* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "CheckSettingsResetPressed");

	Params::KosmosInputBPLibrary_CheckSettingsResetPressed Parms{};

	Parms.InPlayer = InPlayer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.ClearKeyBindingsToAction
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputMappingName                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInIsNegativeScale                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosControlScheme              InControlScheme                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InReboundInputMappingName                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::ClearKeyBindingsToAction(class APlayerController* InPlayerController, const class FName& InInputMappingName, bool bInIsNegativeScale, const EKosmosControlScheme InControlScheme, const class FName& InReboundInputMappingName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "ClearKeyBindingsToAction");

	Params::KosmosInputBPLibrary_ClearKeyBindingsToAction Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InInputMappingName = InInputMappingName;
	Parms.bInIsNegativeScale = bInIsNegativeScale;
	Parms.InControlScheme = InControlScheme;
	Parms.InReboundInputMappingName = InReboundInputMappingName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetAxisKeyFromAction
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosInputBPLibrary::GetAxisKeyFromAction(const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetAxisKeyFromAction");

	Params::KosmosInputBPLibrary_GetAxisKeyFromAction Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetConflictingMappingReferences
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      KeyMappingName                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bAxisVariant                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosControlScheme              InControlScheme                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UKosmosInputBPLibrary::GetConflictingMappingReferences(const class APlayerController* InPlayerController, const class FName& KeyMappingName, const bool bAxisVariant, const EKosmosControlScheme InControlScheme)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetConflictingMappingReferences");

	Params::KosmosInputBPLibrary_GetConflictingMappingReferences Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.KeyMappingName = KeyMappingName;
	Parms.bAxisVariant = bAxisVariant;
	Parms.InControlScheme = InControlScheme;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetCurrentGamepadInputType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosInputBPLibrary::GetCurrentGamepadInputType(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetCurrentGamepadInputType");

	Params::KosmosInputBPLibrary_GetCurrentGamepadInputType Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetCurrentKeyboardLayout
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EKosmosKeyboardLayouts                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosKeyboardLayouts UKosmosInputBPLibrary::GetCurrentKeyboardLayout()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetCurrentKeyboardLayout");

	Params::KosmosInputBPLibrary_GetCurrentKeyboardLayout Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetCurrentOverrideButtonIconType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosButtonOverrideIcons              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosButtonOverrideIcons UKosmosInputBPLibrary::GetCurrentOverrideButtonIconType(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetCurrentOverrideButtonIconType");

	Params::KosmosInputBPLibrary_GetCurrentOverrideButtonIconType Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetGamepadDisplayNameForMapping
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSMGMappingReference&      InInputMappingName                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EKosmosControlScheme                    InControlScheme                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bIsNegative                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosInputBPLibrary::GetGamepadDisplayNameForMapping(const class UObject* WorldContextObject, const struct FSMGMappingReference& InInputMappingName, EKosmosControlScheme InControlScheme, const bool bIsNegative)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetGamepadDisplayNameForMapping");

	Params::KosmosInputBPLibrary_GetGamepadDisplayNameForMapping Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InInputMappingName = std::move(InInputMappingName);
	Parms.InControlScheme = InControlScheme;
	Parms.bIsNegative = bIsNegative;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetInputAxis
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             InAxisName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosInputBPLibrary::GetInputAxis(const class APlayerController* InPlayerController, class FName InAxisName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetInputAxis");

	Params::KosmosInputBPLibrary_GetInputAxis Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InAxisName = InAxisName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetKeyCategory
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FName UKosmosInputBPLibrary::GetKeyCategory(const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetKeyCategory");

	Params::KosmosInputBPLibrary_GetKeyCategory Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetKeyForMapping
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FSMGMappingReference&      InInputMappingName                                     (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// EKosmosControlScheme                    InControlScheme                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bIsNegative                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosInputBPLibrary::GetKeyForMapping(const class UObject* WorldContextObject, const struct FSMGMappingReference& InInputMappingName, EKosmosControlScheme InControlScheme, const bool bIsNegative)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetKeyForMapping");

	Params::KosmosInputBPLibrary_GetKeyForMapping Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InInputMappingName = std::move(InInputMappingName);
	Parms.InControlScheme = InControlScheme;
	Parms.bIsNegative = bIsNegative;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetKeyInteractType
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosMenuInteractType                 ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EKosmosMenuInteractType UKosmosInputBPLibrary::GetKeyInteractType(const class APlayerController* InPlayerController, const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetKeyInteractType");

	Params::KosmosInputBPLibrary_GetKeyInteractType Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetMatchingGameActionForKey
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool*                                   bOutSuccess                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UKosmosInputBPLibrary::GetMatchingGameActionForKey(class APlayerController* InPlayerController, const struct FKey& InKey, bool* bOutSuccess)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetMatchingGameActionForKey");

	Params::KosmosInputBPLibrary_GetMatchingGameActionForKey Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (bOutSuccess != nullptr)
		*bOutSuccess = Parms.bOutSuccess;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.GetStickFromAxis
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosInputBPLibrary::GetStickFromAxis(const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "GetStickFromAxis");

	Params::KosmosInputBPLibrary_GetStickFromAxis Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.HasAnyClearBindings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosControlScheme              InControlScheme                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::HasAnyClearBindings(class APlayerController* InPlayerController, const EKosmosControlScheme InControlScheme)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "HasAnyClearBindings");

	Params::KosmosInputBPLibrary_HasAnyClearBindings Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InControlScheme = InControlScheme;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.IsDPadKey
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      InKey                                                  (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::IsDPadKey(const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "IsDPadKey");

	Params::KosmosInputBPLibrary_IsDPadKey Parms{};

	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.IsInputMappingBoundToKey
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputMappingName                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::IsInputMappingBoundToKey(class APlayerController* InPlayerController, const class FName& InInputMappingName, const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "IsInputMappingBoundToKey");

	Params::KosmosInputBPLibrary_IsInputMappingBoundToKey Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InInputMappingName = InInputMappingName;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.IsKeyBlockedFromRebinding
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKey&                      InNewKey                                               (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::IsKeyBlockedFromRebinding(const struct FKey& InNewKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "IsKeyBlockedFromRebinding");

	Params::KosmosInputBPLibrary_IsKeyBlockedFromRebinding Parms{};

	Parms.InNewKey = std::move(InNewKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.IsKeyBoundToOtherMapping
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputMappingName                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InNewKey                                               (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInIsNegativeScale                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::IsKeyBoundToOtherMapping(class APlayerController* InPlayerController, const class FName& InInputMappingName, const struct FKey& InNewKey, bool bInIsNegativeScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "IsKeyBoundToOtherMapping");

	Params::KosmosInputBPLibrary_IsKeyBoundToOtherMapping Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InInputMappingName = InInputMappingName;
	Parms.InNewKey = std::move(InNewKey);
	Parms.bInIsNegativeScale = bInIsNegativeScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.LoadKeyBindings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::LoadKeyBindings(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "LoadKeyBindings");

	Params::KosmosInputBPLibrary_LoadKeyBindings Parms{};

	Parms.InPlayerController = InPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.RebindKey
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      InInputMappingName                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InNewKey                                               (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInIsNegativeScale                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bAxisVariant                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::RebindKey(class APlayerController* InPlayerController, const class FName& InInputMappingName, const struct FKey& InNewKey, bool bInIsNegativeScale, const bool bAxisVariant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "RebindKey");

	Params::KosmosInputBPLibrary_RebindKey Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InInputMappingName = InInputMappingName;
	Parms.InNewKey = std::move(InNewKey);
	Parms.bInIsNegativeScale = bInIsNegativeScale;
	Parms.bAxisVariant = bAxisVariant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.ResetKeyBindingsToDefault
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EKosmosControlScheme              InControlScheme                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::ResetKeyBindingsToDefault(class APlayerController* InPlayerController, const EKosmosControlScheme InControlScheme)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "ResetKeyBindingsToDefault");

	Params::KosmosInputBPLibrary_ResetKeyBindingsToDefault Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InControlScheme = InControlScheme;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.SaveKeyBindings
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class APlayerController*                InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInputBPLibrary::SaveKeyBindings(class APlayerController* InPlayerController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "SaveKeyBindings");

	Params::KosmosInputBPLibrary_SaveKeyBindings Parms{};

	Parms.InPlayerController = InPlayerController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.SwapMenuButtonKey
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosInputBPLibrary::SwapMenuButtonKey(const class UObject* WorldContextObject, const struct FKey& InKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "SwapMenuButtonKey");

	Params::KosmosInputBPLibrary_SwapMenuButtonKey Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInputBPLibrary.ValidateTriggerKeyForRebinding
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKey&                      InNewKey                                               (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKey                             ReturnValue                                            (Parm, OutParm, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FKey UKosmosInputBPLibrary::ValidateTriggerKeyForRebinding(const struct FKey& InNewKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosInputBPLibrary", "ValidateTriggerKeyForRebinding");

	Params::KosmosInputBPLibrary_ValidateTriggerKeyForRebinding Parms{};

	Parms.InNewKey = std::move(InNewKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInteractInterface.GetCurrentInteractable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UObject*                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UObject* UKosmosInteractInterface::GetCurrentInteractable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "GetCurrentInteractable");

	Params::KosmosInteractInterface_GetCurrentInteractable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInteractInterface.InterruptInteraction
// (Final, Native, Public, BlueprintCallable)

void UKosmosInteractInterface::InterruptInteraction()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "InterruptInteraction");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.LockSelectedInteractableObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InteractItem                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInteractInterface::LockSelectedInteractableObject(class AKosmosEnvironmentInteractable* InteractItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "LockSelectedInteractableObject");

	Params::KosmosInteractInterface_LockSelectedInteractableObject Parms{};

	Parms.InteractItem = InteractItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.Multicast_FocusInteractable
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// class AKosmosEnvironmentInteractable*   NewInteractable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInteractInterface::Multicast_FocusInteractable(class AKosmosEnvironmentInteractable* NewInteractable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "Multicast_FocusInteractable");

	Params::KosmosInteractInterface_Multicast_FocusInteractable Parms{};

	Parms.NewInteractable = NewInteractable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.OnCharacterRestarted
// (Final, Native, Public)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInteractInterface::OnCharacterRestarted(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "OnCharacterRestarted");

	Params::KosmosInteractInterface_OnCharacterRestarted Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.Server_FocusInteractable
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// class AKosmosEnvironmentInteractable*   NewInteractable                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInteractInterface::Server_FocusInteractable(class AKosmosEnvironmentInteractable* NewInteractable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "Server_FocusInteractable");

	Params::KosmosInteractInterface_Server_FocusInteractable Parms{};

	Parms.NewInteractable = NewInteractable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.UnlockSelectedInteractableObject
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosEnvironmentInteractable*   InteractItem                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInteractInterface::UnlockSelectedInteractableObject(class AKosmosEnvironmentInteractable* InteractItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "UnlockSelectedInteractableObject");

	Params::KosmosInteractInterface_UnlockSelectedInteractableObject Parms{};

	Parms.InteractItem = InteractItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInteractInterface.GetFocused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosEnvironmentInteractable*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosEnvironmentInteractable* UKosmosInteractInterface::GetFocused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInteractInterface", "GetFocused");

	Params::KosmosInteractInterface_GetFocused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryComponent.AddItemToInventory
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsUniqueItem                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::AddItemToInventory(const struct FKosmosInventoryItemNameReference& InItem, bool IsUniqueItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "AddItemToInventory");

	Params::KosmosInventoryComponent_AddItemToInventory Parms{};

	Parms.InItem = std::move(InItem);
	Parms.IsUniqueItem = IsUniqueItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.ClientOnInventoryStorageChanged
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsAdded                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::ClientOnInventoryStorageChanged(const struct FKosmosInventoryItemNameReference& InItem, bool IsAdded)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "ClientOnInventoryStorageChanged");

	Params::KosmosInventoryComponent_ClientOnInventoryStorageChanged Parms{};

	Parms.InItem = std::move(InItem);
	Parms.IsAdded = IsAdded;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.DebugOnlyAddItemToInventory
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IsUniqueItem                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::DebugOnlyAddItemToInventory(const struct FKosmosInventoryItemNameReference& InItem, bool IsUniqueItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "DebugOnlyAddItemToInventory");

	Params::KosmosInventoryComponent_DebugOnlyAddItemToInventory Parms{};

	Parms.InItem = std::move(InItem);
	Parms.IsUniqueItem = IsUniqueItem;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.DebugOnlyRemoveItemFromInventory
// (Net, NetReliable, Native, Event, Public, NetServer, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::DebugOnlyRemoveItemFromInventory(const struct FKosmosInventoryItemNameReference& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "DebugOnlyRemoveItemFromInventory");

	Params::KosmosInventoryComponent_DebugOnlyRemoveItemFromInventory Parms{};

	Parms.InItem = std::move(InItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.DisableItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRemoveFromInventory                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::DisableItem(const struct FKosmosInventoryItemNameReference& InItemName, bool bRemoveFromInventory)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "DisableItem");

	Params::KosmosInventoryComponent_DisableItem Parms{};

	Parms.InItemName = std::move(InItemName);
	Parms.bRemoveFromInventory = bRemoveFromInventory;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.DisableItem_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bRemoveFromInventory                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::DisableItem_Multicast(const struct FKosmosInventoryItemNameReference& InItemName, bool bRemoveFromInventory)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "DisableItem_Multicast");

	Params::KosmosInventoryComponent_DisableItem_Multicast Parms{};

	Parms.InItemName = std::move(InItemName);
	Parms.bRemoveFromInventory = bRemoveFromInventory;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.EnableItem
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSKipTakeout                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::EnableItem(const struct FKosmosInventoryItemNameReference& InItemName, bool bSKipTakeout)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "EnableItem");

	Params::KosmosInventoryComponent_EnableItem Parms{};

	Parms.InItemName = std::move(InItemName);
	Parms.bSKipTakeout = bSKipTakeout;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.EnableItem_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSKipTakeout                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::EnableItem_Multicast(const struct FKosmosInventoryItemNameReference& InItemName, bool bSKipTakeout)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "EnableItem_Multicast");

	Params::KosmosInventoryComponent_EnableItem_Multicast Parms{};

	Parms.InItemName = std::move(InItemName);
	Parms.bSKipTakeout = bSKipTakeout;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.GetCurrentInventoryItems
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UKosmosInventoryComponent::GetCurrentInventoryItems()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "GetCurrentInventoryItems");

	Params::KosmosInventoryComponent_GetCurrentInventoryItems Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryComponent.GetStoredActor
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosInventoryStoredItem*      OutActor                                               (Parm, OutParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInventoryComponent::GetStoredActor(const struct FKosmosInventoryItemNameReference& InItem, struct FKosmosInventoryStoredItem* OutActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "GetStoredActor");

	Params::KosmosInventoryComponent_GetStoredActor Parms{};

	Parms.InItem = std::move(InItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutActor != nullptr)
		*OutActor = std::move(Parms.OutActor);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryComponent.GiveItemToPlayer_Complete_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::GiveItemToPlayer_Complete_Multicast(const struct FKosmosInventoryItemNameReference& InItemName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "GiveItemToPlayer_Complete_Multicast");

	Params::KosmosInventoryComponent_GiveItemToPlayer_Complete_Multicast Parms{};

	Parms.InItemName = std::move(InItemName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.OnItemsChange
// (Final, Native, Private)

void UKosmosInventoryComponent::OnItemsChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "OnItemsChange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.RemoveItemFromInventory
// (Final, BlueprintAuthorityOnly, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::RemoveItemFromInventory(const struct FKosmosInventoryItemNameReference& InItem)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "RemoveItemFromInventory");

	Params::KosmosInventoryComponent_RemoveItemFromInventory Parms{};

	Parms.InItem = std::move(InItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.SetCurrentInventoryItems
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class FString>&            InItems                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::SetCurrentInventoryItems(const TArray<class FString>& InItems)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "SetCurrentInventoryItems");

	Params::KosmosInventoryComponent_SetCurrentInventoryItems Parms{};

	Parms.InItems = std::move(InItems);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.SetCurrentItem
// (Final, Native, Private, HasOutParams)
// Parameters:
// const struct FKosmosInventoryStoredItem&InNewCurrentItem                                       (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bSKipTakeout                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::SetCurrentItem(const struct FKosmosInventoryStoredItem& InNewCurrentItem, bool bSKipTakeout)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "SetCurrentItem");

	Params::KosmosInventoryComponent_SetCurrentItem Parms{};

	Parms.InNewCurrentItem = std::move(InNewCurrentItem);
	Parms.bSKipTakeout = bSKipTakeout;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.TakeItemFromPlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             OtherCharacter                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::TakeItemFromPlayer(class AKosmosBaseCharacter* OtherCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "TakeItemFromPlayer");

	Params::KosmosInventoryComponent_TakeItemFromPlayer Parms{};

	Parms.OtherCharacter = OtherCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.TakeItemFromPlayer_Complete_Multicast
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::TakeItemFromPlayer_Complete_Multicast(const struct FKosmosInventoryItemNameReference& InItemName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "TakeItemFromPlayer_Complete_Multicast");

	Params::KosmosInventoryComponent_TakeItemFromPlayer_Complete_Multicast Parms{};

	Parms.InItemName = std::move(InItemName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.TakeItemFromPlayer_Server
// (Final, Net, NetReliable, Native, Event, Private, NetServer)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItemName                                             (ConstParm, Parm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosInventoryComponent*        OtherInventoryComponent                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInventoryComponent::TakeItemFromPlayer_Server(const struct FKosmosInventoryItemNameReference& InItemName, class UKosmosInventoryComponent* OtherInventoryComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "TakeItemFromPlayer_Server");

	Params::KosmosInventoryComponent_TakeItemFromPlayer_Server Parms{};

	Parms.InItemName = std::move(InItemName);
	Parms.OtherInventoryComponent = OtherInventoryComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryComponent.DoesInventoryContain
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FKosmosInventoryItemNameReference&InItem                                                 (ConstParm, Parm, OutParm, ReferenceParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosInventoryComponent::DoesInventoryContain(const struct FKosmosInventoryItemNameReference& InItem) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "DoesInventoryContain");

	Params::KosmosInventoryComponent_DoesInventoryContain Parms{};

	Parms.InItem = std::move(InItem);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryComponent.GetCurrentInventoryItemList
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<struct FKosmosInventoryItemNameReference>ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKosmosInventoryItemNameReference> UKosmosInventoryComponent::GetCurrentInventoryItemList() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "GetCurrentInventoryItemList");

	Params::KosmosInventoryComponent_GetCurrentInventoryItemList Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryComponent.GetCurrentSpawnedActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* UKosmosInventoryComponent::GetCurrentSpawnedActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryComponent", "GetCurrentSpawnedActor");

	Params::KosmosInventoryComponent_GetCurrentSpawnedActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosInventoryItemComponent.CollectItem
// (Final, Native, Public, BlueprintCallable)

void UKosmosInventoryItemComponent::CollectItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryItemComponent", "CollectItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInventoryItemComponent.RevokeCollectItem
// (Final, Native, Public, BlueprintCallable)

void UKosmosInventoryItemComponent::RevokeCollectItem()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInventoryItemComponent", "RevokeCollectItem");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSingleKeyBindingWidget.RebindBinding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class APlayerController*          InPlayerController                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAssignableKeyWidget*       InAssignableKeyWidget                                  (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bInIsNegativeScale                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSingleKeyBindingWidget::RebindBinding(const class APlayerController* InPlayerController, class UKosmosAssignableKeyWidget* InAssignableKeyWidget, const struct FKey& InKey, bool bInIsNegativeScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSingleKeyBindingWidget", "RebindBinding");

	Params::KosmosSingleKeyBindingWidget_RebindBinding Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.InAssignableKeyWidget = InAssignableKeyWidget;
	Parms.InKey = std::move(InKey);
	Parms.bInIsNegativeScale = bInIsNegativeScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosInvisibleWallComponent.BuildWalls
// (Final, Native, Public, HasDefaults)
// Parameters:
// const struct FVector&                   InExtent                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosInvisibleWallComponent::BuildWalls(const struct FVector& InExtent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosInvisibleWallComponent", "BuildWalls");

	Params::KosmosInvisibleWallComponent_BuildWalls Parms{};

	Parms.InExtent = std::move(InExtent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSunSafetyVolume.OnVolumeBeginOverlap
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosSunSafetyVolume::OnVolumeBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSunSafetyVolume", "OnVolumeBeginOverlap");

	Params::KosmosSunSafetyVolume_OnVolumeBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSunSafetyVolume.OnVolumeEndOverlap
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosSunSafetyVolume::OnVolumeEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSunSafetyVolume", "OnVolumeEndOverlap");

	Params::KosmosSunSafetyVolume_OnVolumeEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.ForcefullyEndJump
// (Final, Native, Private)

void UKosmosJumpComponent::ForcefullyEndJump()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "ForcefullyEndJump");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnFallingChanged
// (Final, Native, Private)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosJumpComponent::OnFallingChanged(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnFallingChanged");

	Params::KosmosJumpComponent_OnFallingChanged Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnJumpApex
// (Final, Native, Private)

void UKosmosJumpComponent::OnJumpApex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnJumpApex");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnJumpChange
// (Final, Native, Private)
// Parameters:
// bool                                    Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosJumpComponent::OnJumpChange(bool Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnJumpChange");

	Params::KosmosJumpComponent_OnJumpChange Parms{};

	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnJumpRequestChanged
// (Final, Native, Private)
// Parameters:
// const struct FKosmosJumpParameters&     Value                                                  (Parm, NativeAccessSpecifierPublic)

void UKosmosJumpComponent::OnJumpRequestChanged(const struct FKosmosJumpParameters& Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnJumpRequestChanged");

	Params::KosmosJumpComponent_OnJumpRequestChanged Parms{};

	Parms.Value = std::move(Value);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnJumpTargetRequestChanged
// (Final, Native, Private, HasDefaults)
// Parameters:
// const struct FVector&                   JumpTarget                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosJumpComponent::OnJumpTargetRequestChanged(const struct FVector& JumpTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnJumpTargetRequestChanged");

	Params::KosmosJumpComponent_OnJumpTargetRequestChanged Parms{};

	Parms.JumpTarget = std::move(JumpTarget);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.OnMovementModeChanged
// (Final, Native, Private)
// Parameters:
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementMode                           PrevMovementMode                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   PreviousCustomMode                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosJumpComponent::OnMovementModeChanged(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "OnMovementModeChanged");

	Params::KosmosJumpComponent_OnMovementModeChanged Parms{};

	Parms.Character = Character;
	Parms.PrevMovementMode = PrevMovementMode;
	Parms.PreviousCustomMode = PreviousCustomMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosJumpComponent.IsTryJumping
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosJumpComponent::IsTryJumping() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosJumpComponent", "IsTryJumping");

	Params::KosmosJumpComponent_IsTryJumping Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosKeyBindingImage.RefreshKey
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosPlayerController*          InPlayerController                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsNegativeScale                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bNeedSwapIconInJapanese                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bAxisVariant                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosKeyBindingImage::RefreshKey(class AKosmosPlayerController* InPlayerController, bool bIsNegativeScale, bool bNeedSwapIconInJapanese, const bool bAxisVariant)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeyBindingImage", "RefreshKey");

	Params::KosmosKeyBindingImage_RefreshKey Parms{};

	Parms.InPlayerController = InPlayerController;
	Parms.bIsNegativeScale = bIsNegativeScale;
	Parms.bNeedSwapIconInJapanese = bNeedSwapIconInJapanese;
	Parms.bAxisVariant = bAxisVariant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKeyBindingTextBlock.SetMappingReferences
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<struct FSMGMappingReference>&InMappingReferences                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    InUpdateBlock                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InIsNegativeValue                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosKeyBindingTextBlock::SetMappingReferences(const TArray<struct FSMGMappingReference>& InMappingReferences, bool InUpdateBlock, bool InIsNegativeValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeyBindingTextBlock", "SetMappingReferences");

	Params::KosmosKeyBindingTextBlock_SetMappingReferences Parms{};

	Parms.InMappingReferences = std::move(InMappingReferences);
	Parms.InUpdateBlock = InUpdateBlock;
	Parms.InIsNegativeValue = InIsNegativeValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKeyBindingTextBlock.SetText
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InText                                                 (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InUpdateBlock                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosKeyBindingTextBlock::SetText(const class FString& InText, bool InUpdateBlock)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeyBindingTextBlock", "SetText");

	Params::KosmosKeyBindingTextBlock_SetText Parms{};

	Parms.InText = std::move(InText);
	Parms.InUpdateBlock = InUpdateBlock;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKeyBindingTextures.GetIconTexture
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKey&                      InKey                                                  (ConstParm, Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString*                          OutLabel                                               (Parm, OutParm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              InCanSwapInJapanese                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const bool                              bAxisVariant                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UKosmosKeyBindingTextures::GetIconTexture(class UObject* WorldContextObject, const struct FKey& InKey, class FString* OutLabel, const bool InCanSwapInJapanese, const bool bAxisVariant) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeyBindingTextures", "GetIconTexture");

	Params::KosmosKeyBindingTextures_GetIconTexture Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InKey = std::move(InKey);
	Parms.InCanSwapInJapanese = InCanSwapInJapanese;
	Parms.bAxisVariant = bAxisVariant;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutLabel != nullptr)
		*OutLabel = std::move(Parms.OutLabel);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosKeybindingButton.SetIsCurrentlyKeybinding
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InIsCurrentlyKeybinding                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosKeybindingButton::SetIsCurrentlyKeybinding(bool InIsCurrentlyKeybinding)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeybindingButton", "SetIsCurrentlyKeybinding");

	Params::KosmosKeybindingButton_SetIsCurrentlyKeybinding Parms{};

	Parms.InIsCurrentlyKeybinding = InIsCurrentlyKeybinding;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKeybindingButton.GetIsCurrentlyKeybinding
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosKeybindingButton::GetIsCurrentlyKeybinding() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeybindingButton", "GetIsCurrentlyKeybinding");

	Params::KosmosKeybindingButton_GetIsCurrentlyKeybinding Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosKeyTexture.GetTexture
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UWorld*                           InWorld                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UTexture2D*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UTexture2D* UKosmosKeyTexture::GetTexture(class UWorld* InWorld) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKeyTexture", "GetTexture");

	Params::KosmosKeyTexture_GetTexture Parms{};

	Parms.InWorld = InWorld;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosKnife.GetCurrentInteractable
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosKnife::GetCurrentInteractable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "GetCurrentInteractable");

	Params::KosmosKnife_GetCurrentInteractable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosKnife.Multicast_SetKnifeUsageState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// EKnifeUsage                             InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosKnife::Multicast_SetKnifeUsageState(EKnifeUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "Multicast_SetKnifeUsageState");

	Params::KosmosKnife_Multicast_SetKnifeUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKnife.OnHit
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosKnife::OnHit(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "OnHit");

	Params::KosmosKnife_OnHit Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKnife.Server_SetKnifeUsageState
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// EKnifeUsage                             InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosKnife::Server_SetKnifeUsageState(EKnifeUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "Server_SetKnifeUsageState");

	Params::KosmosKnife_Server_SetKnifeUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKnife.SetCurrentInteractable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosKnife::SetCurrentInteractable(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "SetCurrentInteractable");

	Params::KosmosKnife_SetCurrentInteractable Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosKnife.SetKnifeUsageState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKnifeUsage                             InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosKnife::SetKnifeUsageState(EKnifeUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosKnife", "SetKnifeUsageState");

	Params::KosmosKnife_SetKnifeUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLadder.AddGrabHelper
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class USceneComponent*                  AttachTransform                                        (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             AttachSocketName                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Scale3D                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosClimbableComponent*        ClimbableComponentParent                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UGrabHelper*                      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UGrabHelper* AKosmosLadder::AddGrabHelper(class USceneComponent* AttachTransform, class FName AttachSocketName, const struct FVector& Scale3D, class UKosmosClimbableComponent* ClimbableComponentParent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLadder", "AddGrabHelper");

	Params::KosmosLadder_AddGrabHelper Parms{};

	Parms.AttachTransform = AttachTransform;
	Parms.AttachSocketName = AttachSocketName;
	Parms.Scale3D = std::move(Scale3D);
	Parms.ClimbableComponentParent = ClimbableComponentParent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLadder.OnPropertyChannge
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             InPropertyName                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLadder::OnPropertyChannge(class FName InPropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLadder", "OnPropertyChannge");

	Params::KosmosLadder_OnPropertyChannge Parms{};

	Parms.InPropertyName = InPropertyName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosSwingablesNavLink.OnSwingableFail
// (Final, Native, Private)

void AKosmosSwingablesNavLink::OnSwingableFail()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwingablesNavLink", "OnSwingableFail");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSwingablesNavLink.OnSwingableFinish
// (Final, Native, Private)

void AKosmosSwingablesNavLink::OnSwingableFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwingablesNavLink", "OnSwingableFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLargeLever.OnRep_InputMode
// (Final, Native, Public)

void AKosmosLargeLever::OnRep_InputMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "OnRep_InputMode");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLargeLever.SetInitialState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// ELeverState                             NewInitialState                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLargeLever::SetInitialState(ELeverState NewInitialState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "SetInitialState");

	Params::KosmosLargeLever_SetInitialState Parms{};

	Parms.NewInitialState = NewInitialState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLargeLever.SetInputMode
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
// Parameters:
// ELeverInputMode                         NewInputMode                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLargeLever::SetInputMode(ELeverInputMode NewInputMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "SetInputMode");

	Params::KosmosLargeLever_SetInputMode Parms{};

	Parms.NewInputMode = NewInputMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLargeLever.UpdateVisualState
// (Event, Protected, BlueprintEvent)

void AKosmosLargeLever::UpdateVisualState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "UpdateVisualState");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosLargeLever.GetInitialProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosLargeLever::GetInitialProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "GetInitialProgress");

	Params::KosmosLargeLever_GetInitialProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLargeLever.GetLogicalProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosLargeLever::GetLogicalProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "GetLogicalProgress");

	Params::KosmosLargeLever_GetLogicalProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLargeLever.GetProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosLargeLever::GetProgress() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLargeLever", "GetProgress");

	Params::KosmosLargeLever_GetProgress Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLedgeClimbingInterface.ClimbFinished
// (Final, Native, Public, BlueprintCallable)

void UKosmosLedgeClimbingInterface::ClimbFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLedgeClimbingInterface", "ClimbFinished");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLedgeClimbingInterface.Multicast_CancelGrab
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private)

void UKosmosLedgeClimbingInterface::Multicast_CancelGrab()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLedgeClimbingInterface", "Multicast_CancelGrab");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLedgeClimbingInterface.OnAnimNotify
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FFlowControlAnimNotifyData&AnimNotify                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosLedgeClimbingInterface::OnAnimNotify(const struct FFlowControlAnimNotifyData& AnimNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLedgeClimbingInterface", "OnAnimNotify");

	Params::KosmosLedgeClimbingInterface_OnAnimNotify Parms{};

	Parms.AnimNotify = std::move(AnimNotify);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.AutomationBeginPlay
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAutomationFakeActor*       InAutomationFake                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::AutomationBeginPlay(class AKosmosBaseCharacter* InPlayer, class AKosmosBaseCharacter* InPlayPal, class AKosmosAutomationFakeActor* InAutomationFake)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "AutomationBeginPlay");

	Params::KosmosLevelScriptActor_AutomationBeginPlay Parms{};

	Parms.InPlayer = InPlayer;
	Parms.InPlayPal = InPlayPal;
	Parms.InAutomationFake = InAutomationFake;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.AutomationEndPlay
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAutomationFakeActor*       InAutomationFake                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::AutomationEndPlay(class AKosmosBaseCharacter* InPlayer, class AKosmosBaseCharacter* InPlayPal, class AKosmosAutomationFakeActor* InAutomationFake)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "AutomationEndPlay");

	Params::KosmosLevelScriptActor_AutomationEndPlay Parms{};

	Parms.InPlayer = InPlayer;
	Parms.InPlayPal = InPlayPal;
	Parms.InAutomationFake = InAutomationFake;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.AutomationTick
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAutomationFakeActor*       InAutomationFake                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosAutomationPathNode*        InCurrentPathNode                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::AutomationTick(float DeltaSeconds, class AKosmosBaseCharacter* InPlayer, class AKosmosBaseCharacter* InPlayPal, class AKosmosAutomationFakeActor* InAutomationFake, class AKosmosAutomationPathNode* InCurrentPathNode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "AutomationTick");

	Params::KosmosLevelScriptActor_AutomationTick Parms{};

	Parms.DeltaSeconds = DeltaSeconds;
	Parms.InPlayer = InPlayer;
	Parms.InPlayPal = InPlayPal;
	Parms.InAutomationFake = InAutomationFake;
	Parms.InCurrentPathNode = InCurrentPathNode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.HandleResume
// (Final, Native, Private)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "HandleResume");

	Params::KosmosLevelScriptActor_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.HandleSnapshot
// (Final, Native, Private)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "HandleSnapshot");

	Params::KosmosLevelScriptActor_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelScriptActor.OnCheckpointResume
// (Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointReader*          CheckpointReader                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::OnCheckpointResume(class UKosmosCheckpointReader* CheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "OnCheckpointResume");

	Params::KosmosLevelScriptActor_OnCheckpointResume Parms{};

	Parms.CheckpointReader = CheckpointReader;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.OnCheckpointSnapshot
// (Event, Public, BlueprintEvent)
// Parameters:
// class UKosmosCheckpointWriter*          CheckpointWriter                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::OnCheckpointSnapshot(class UKosmosCheckpointWriter* CheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "OnCheckpointSnapshot");

	Params::KosmosLevelScriptActor_OnCheckpointSnapshot Parms{};

	Parms.CheckpointWriter = CheckpointWriter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.PlaypalBeginPlay
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::PlaypalBeginPlay(class AKosmosBaseCharacter* InPlayPal, class AKosmosBaseCharacter* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PlaypalBeginPlay");

	Params::KosmosLevelScriptActor_PlaypalBeginPlay Parms{};

	Parms.InPlayPal = InPlayPal;
	Parms.InPlayer = InPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.PlaypalEndPlay
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::PlaypalEndPlay(class AKosmosBaseCharacter* InPlayPal, class AKosmosBaseCharacter* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PlaypalEndPlay");

	Params::KosmosLevelScriptActor_PlaypalEndPlay Parms{};

	Parms.InPlayPal = InPlayPal;
	Parms.InPlayer = InPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.PlaypalTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayPal                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             InPlayer                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::PlaypalTick(float DeltaSeconds, class AKosmosBaseCharacter* InPlayPal, class AKosmosBaseCharacter* InPlayer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PlaypalTick");

	Params::KosmosLevelScriptActor_PlaypalTick Parms{};

	Parms.DeltaSeconds = DeltaSeconds;
	Parms.InPlayPal = InPlayPal;
	Parms.InPlayer = InPlayer;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.PuzzleBeginPlay
// (Event, Public, BlueprintEvent)

void AKosmosLevelScriptActor::PuzzleBeginPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PuzzleBeginPlay");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosLevelScriptActor.PuzzleEndPlay
// (Event, Public, BlueprintEvent)
// Parameters:
// const EEndPlayReason                    EndPlayReason                                          (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::PuzzleEndPlay(const EEndPlayReason EndPlayReason)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PuzzleEndPlay");

	Params::KosmosLevelScriptActor_PuzzleEndPlay Parms{};

	Parms.EndPlayReason = EndPlayReason;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelScriptActor.PuzzleTick
// (Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaSeconds                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelScriptActor::PuzzleTick(float DeltaSeconds)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelScriptActor", "PuzzleTick");

	Params::KosmosLevelScriptActor_PuzzleTick Parms{};

	Parms.DeltaSeconds = DeltaSeconds;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLevelSequenceActor.Multicast_SetFrameRange
// (Final, Net, NetReliable, Native, Event, NetMulticast, Private, BlueprintCallable)
// Parameters:
// int32                                   StartFrame                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   Duration                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SubFrames                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLevelSequenceActor::Multicast_SetFrameRange(int32 StartFrame, int32 Duration, float SubFrames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelSequenceActor", "Multicast_SetFrameRange");

	Params::KosmosLevelSequenceActor_Multicast_SetFrameRange Parms{};

	Parms.StartFrame = StartFrame;
	Parms.Duration = Duration;
	Parms.SubFrames = SubFrames;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelSequenceActor.OnFinish
// (Final, Native, Protected)

void AKosmosLevelSequenceActor::OnFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelSequenceActor", "OnFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLevelSequenceActor.OnPlay
// (Final, Native, Protected)

void AKosmosLevelSequenceActor::OnPlay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLevelSequenceActor", "OnPlay");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaNavLink.ClearCommand
// (Final, Native, Private)

void AKosmosUmbrellaNavLink::ClearCommand()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaNavLink", "ClearCommand");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosToggleHintHUDWidget.ToggleCrouchIcon
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bEnabled                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosToggleHintHUDWidget::ToggleCrouchIcon(const bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosToggleHintHUDWidget", "ToggleCrouchIcon");

	Params::KosmosToggleHintHUDWidget_ToggleCrouchIcon Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosToggleHintHUDWidget.ToggleGrabIcon
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bEnabled                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosToggleHintHUDWidget::ToggleGrabIcon(const bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosToggleHintHUDWidget", "ToggleGrabIcon");

	Params::KosmosToggleHintHUDWidget_ToggleGrabIcon Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosToggleHintHUDWidget.ToggleSprintIcon
// (Event, Public, BlueprintEvent)
// Parameters:
// const bool                              bEnabled                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosToggleHintHUDWidget::ToggleSprintIcon(const bool bEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosToggleHintHUDWidget", "ToggleSprintIcon");

	Params::KosmosToggleHintHUDWidget_ToggleSprintIcon Parms{};

	Parms.bEnabled = bEnabled;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosLoadingHUDWidget.EventSaveFinished
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosLoadingHUDWidget::EventSaveFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLoadingHUDWidget", "EventSaveFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosLoadingHUDWidget.EventSaveStarted
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosLoadingHUDWidget::EventSaveStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLoadingHUDWidget", "EventSaveStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosTelemetryUtils.GenerateTelemetryGameID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::GenerateTelemetryGameID(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GenerateTelemetryGameID");

	Params::KosmosTelemetryUtils_GenerateTelemetryGameID Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.GenerateTelemetrySessionID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::GenerateTelemetrySessionID(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GenerateTelemetrySessionID");

	Params::KosmosTelemetryUtils_GenerateTelemetrySessionID Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.GenerateTelemetryUserID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::GenerateTelemetryUserID(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GenerateTelemetryUserID");

	Params::KosmosTelemetryUtils_GenerateTelemetryUserID Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.GetCurrentInputTypeString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosTelemetryUtils::GetCurrentInputTypeString(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GetCurrentInputTypeString");

	Params::KosmosTelemetryUtils_GetCurrentInputTypeString Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosTelemetryUtils.GetCurrentPlayTimeDuration
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosTelemetryUtils::GetCurrentPlayTimeDuration(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GetCurrentPlayTimeDuration");

	Params::KosmosTelemetryUtils_GetCurrentPlayTimeDuration Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosTelemetryUtils.GetTelemetryGameID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosTelemetryUtils::GetTelemetryGameID(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "GetTelemetryGameID");

	Params::KosmosTelemetryUtils_GetTelemetryGameID Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_AccessiblitySettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_AccessiblitySettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_AccessiblitySettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_AccessiblitySettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_AccessiblitySettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_AccessiblitySettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_AdvancedSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_AdvancedSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_AdvancedSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_AdvancedSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_AdvancedSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_AdvancedSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_AudioSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_AudioSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_AudioSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_AudioSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_AudioSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_AudioSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_BrightnessSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_BrightnessSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_BrightnessSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_BrightnessSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_BrightnessSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_BrightnessSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ChapterEnd
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ChapterEnd&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ChapterEnd(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ChapterEnd& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ChapterEnd");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ChapterEnd Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ChapterStart
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ChapterStart&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ChapterStart(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ChapterStart& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ChapterStart");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ChapterStart Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_CharacterDeath
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_Death&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_CharacterDeath(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_Death& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_CharacterDeath");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_CharacterDeath Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_CheckpointHit
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_CheckpointHit&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_CheckpointHit(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_CheckpointHit& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_CheckpointHit");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_CheckpointHit Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ClientStartGameSession
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ClientStartGameSession&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ClientStartGameSession(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ClientStartGameSession& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ClientStartGameSession");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ClientStartGameSession Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ClientTimeInGame
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ClientTimeInGame&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ClientTimeInGame(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ClientTimeInGame& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ClientTimeInGame");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ClientTimeInGame Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_Colllectable
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_CollectableCollected&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_Colllectable(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_CollectableCollected& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_Colllectable");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_Colllectable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ControllerSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ControllerSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ControllerSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ControllerSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ControllerSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ControllerSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_ControlSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_ControlSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_ControlSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_ControlSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_ControlSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_ControlSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_CostumeChange
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_CostumeChange&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_CostumeChange(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_CostumeChange& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_CostumeChange");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_CostumeChange Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_DeleteMyData
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_DeleteMyData(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_DeleteMyData");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_DeleteMyData Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_EndGameSession
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_EndGameSession&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_EndGameSession(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_EndGameSession& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_EndGameSession");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_EndGameSession Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_Entitlements
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_Entitlements&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_Entitlements(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_Entitlements& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_Entitlements");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_Entitlements Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_EntitlementsNyx
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_EntitlementsNyx&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_EntitlementsNyx(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_EntitlementsNyx& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_EntitlementsNyx");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_EntitlementsNyx Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_GameBoot
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_GameBoot(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_GameBoot");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_GameBoot Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_GameCompletion
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_GameCompletion&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_GameCompletion(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_GameCompletion& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_GameCompletion");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_GameCompletion Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_GeneralSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_GeneralSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_GeneralSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_GeneralSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_GeneralSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_GeneralSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_Gesture
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_Gesture&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_Gesture(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_Gesture& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_Gesture");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_Gesture Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_HeadFlashUsage
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_HeadFlashUsage&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_HeadFlashUsage(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_HeadFlashUsage& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_HeadFlashUsage");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_HeadFlashUsage Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_HudMenuSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_HudMenuSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_HudMenuSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_HudMenuSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_HudMenuSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_HudMenuSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_KeyboardSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_KeyboardSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_KeyboardSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_KeyboardSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_KeyboardSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_KeyboardSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_LanguageSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_LanguageSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_LanguageSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_LanguageSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_LanguageSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_LanguageSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_MonstersHit
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_MonstersHit&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_MonstersHit(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_MonstersHit& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_MonstersHit");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_MonstersHit Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_NewPlayer
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_NewPlayer(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_NewPlayer");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_NewPlayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_PlatformHardware
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_PlatformHardware(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_PlatformHardware");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_PlatformHardware Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_StartGameSession
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_StartGameSession&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_StartGameSession(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_StartGameSession& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_StartGameSession");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_StartGameSession Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_StorefrontTriggered
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_StorefrontTriggered&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_StorefrontTriggered(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_StorefrontTriggered& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_StorefrontTriggered");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_StorefrontTriggered Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_SwappedControllers
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_SwappedControllers&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_SwappedControllers(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_SwappedControllers& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_SwappedControllers");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_SwappedControllers Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_Tutorial
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_Tutorial&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_Tutorial(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_Tutorial& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_Tutorial");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_Tutorial Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_VideoSettings
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_VideoSettings&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_VideoSettings(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_VideoSettings& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_VideoSettings");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_VideoSettings Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.PostTelemetryEvent_WeaponAndTools
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosTelemetryEvent_WeaponAndTools&inEvent                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::PostTelemetryEvent_WeaponAndTools(class UObject* WorldContextObject, const struct FKosmosTelemetryEvent_WeaponAndTools& inEvent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "PostTelemetryEvent_WeaponAndTools");

	Params::KosmosTelemetryUtils_PostTelemetryEvent_WeaponAndTools Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.inEvent = std::move(inEvent);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.SetCurrentPlayTimeDuration
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   InTime                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::SetCurrentPlayTimeDuration(class UObject* WorldContextObject, float InTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "SetCurrentPlayTimeDuration");

	Params::KosmosTelemetryUtils_SetCurrentPlayTimeDuration Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InTime = InTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTelemetryUtils.SetTelemetryGameID
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InGameID                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosTelemetryUtils::SetTelemetryGameID(class UObject* WorldContextObject, const class FString& InGameID)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosTelemetryUtils", "SetTelemetryGameID");

	Params::KosmosTelemetryUtils_SetTelemetryGameID Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InGameID = std::move(InGameID);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLobbyWidget.DebugPrint
// (Final, Native, Public, BlueprintCallable)

void UKosmosLobbyWidget::DebugPrint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "DebugPrint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLobbyWidget.GetConnectedPlayers
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// TArray<struct FKosmosOnlinePlayerInfo>  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FKosmosOnlinePlayerInfo> UKosmosLobbyWidget::GetConnectedPlayers()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "GetConnectedPlayers");

	Params::KosmosLobbyWidget_GetConnectedPlayers Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLobbyWidget.IsHost
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosLobbyWidget::IsHost()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "IsHost");

	Params::KosmosLobbyWidget_IsHost Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLobbyWidget.IsLocalPlayerReady
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosLobbyWidget::IsLocalPlayerReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "IsLocalPlayerReady");

	Params::KosmosLobbyWidget_IsLocalPlayerReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLobbyWidget.IsSystemUIOpen
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosLobbyWidget::IsSystemUIOpen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "IsSystemUIOpen");

	Params::KosmosLobbyWidget_IsSystemUIOpen Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLobbyWidget.SendLobbyData
// (Final, Native, Public, BlueprintCallable)

void UKosmosLobbyWidget::SendLobbyData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "SendLobbyData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLobbyWidget.SetAlternatePlayer
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInIsAlternate                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosLobbyWidget::SetAlternatePlayer(bool bInIsAlternate)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "SetAlternatePlayer");

	Params::KosmosLobbyWidget_SetAlternatePlayer Parms{};

	Parms.bInIsAlternate = bInIsAlternate;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLobbyWidget.ShowSystemSendInviteMenu
// (Final, Native, Public, BlueprintCallable)

void UKosmosLobbyWidget::ShowSystemSendInviteMenu()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "ShowSystemSendInviteMenu");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLobbyWidget.ToggleLocalPlayerReady
// (Final, Native, Public, BlueprintCallable)

void UKosmosLobbyWidget::ToggleLocalPlayerReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLobbyWidget", "ToggleLocalPlayerReady");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPipelineStateSubsystem.SetPrecompileAllPipelines
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    shouldPprecompileAll                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPipelineStateSubsystem::SetPrecompileAllPipelines(bool shouldPprecompileAll)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPipelineStateSubsystem", "SetPrecompileAllPipelines");

	Params::KosmosPipelineStateSubsystem_SetPrecompileAllPipelines Parms{};

	Parms.shouldPprecompileAll = shouldPprecompileAll;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPipelineStateSubsystem.GetNumPrecompilesActive
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosPipelineStateSubsystem::GetNumPrecompilesActive() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPipelineStateSubsystem", "GetNumPrecompilesActive");

	Params::KosmosPipelineStateSubsystem_GetNumPrecompilesActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPipelineStateSubsystem.GetPrecompilePSOsRemaining
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosPipelineStateSubsystem::GetPrecompilePSOsRemaining() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPipelineStateSubsystem", "GetPrecompilePSOsRemaining");

	Params::KosmosPipelineStateSubsystem_GetPrecompilePSOsRemaining Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.CultureEnumToUnrealCulture
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECultureEnum                            cultureEnum                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString ULocalizationHelpers::CultureEnumToUnrealCulture(ECultureEnum cultureEnum)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "CultureEnumToUnrealCulture");

	Params::LocalizationHelpers_CultureEnumToUnrealCulture Parms{};

	Parms.cultureEnum = cultureEnum;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.GetCurrentCultureAsEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECultureEnum                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECultureEnum ULocalizationHelpers::GetCurrentCultureAsEnum()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "GetCurrentCultureAsEnum");

	Params::LocalizationHelpers_GetCurrentCultureAsEnum Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.GetDateTimeAsText
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FDateTime&                 DateTime                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    dateTimeFormat                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText ULocalizationHelpers::GetDateTimeAsText(const struct FDateTime& DateTime, const class FString& dateTimeFormat)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "GetDateTimeAsText");

	Params::LocalizationHelpers_GetDateTimeAsText Parms{};

	Parms.DateTime = std::move(DateTime);
	Parms.dateTimeFormat = std::move(dateTimeFormat);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.GetLocalizationConfigTable
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UDataTable*                       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UDataTable* ULocalizationHelpers::GetLocalizationConfigTable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "GetLocalizationConfigTable");

	Params::LocalizationHelpers_GetLocalizationConfigTable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.GetLocalizedLanguageNameFromCultureEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// ECultureEnum                            Culture                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FText                             ReturnValue                                            (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)

class FText ULocalizationHelpers::GetLocalizedLanguageNameFromCultureEnum(ECultureEnum Culture)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "GetLocalizedLanguageNameFromCultureEnum");

	Params::LocalizationHelpers_GetLocalizedLanguageNameFromCultureEnum Parms{};

	Parms.Culture = Culture;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.IsCurrentCultureRTL
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ULocalizationHelpers::IsCurrentCultureRTL()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "IsCurrentCultureRTL");

	Params::LocalizationHelpers_IsCurrentCultureRTL Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.LocalizationHelpers.UnrealCultureCodeToEnum
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class FString&                    unrealCode                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ECultureEnum                            ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ECultureEnum ULocalizationHelpers::UnrealCultureCodeToEnum(const class FString& unrealCode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("LocalizationHelpers", "UnrealCultureCodeToEnum");

	Params::LocalizationHelpers_UnrealCultureCodeToEnum Parms{};

	Parms.unrealCode = std::move(unrealCode);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosVFXTrigger.Client_Resume
// (Net, NetReliable, Native, Event, NetMulticast, Public)

void AKosmosVFXTrigger::Client_Resume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosVFXTrigger", "Client_Resume");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosVFXTrigger.HandleResume
// (Final, Native, Public)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosVFXTrigger::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosVFXTrigger", "HandleResume");

	Params::KosmosVFXTrigger_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosVFXTrigger.HandleSnapshot
// (Final, Native, Public)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosVFXTrigger::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosVFXTrigger", "HandleSnapshot");

	Params::KosmosVFXTrigger_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosVFXTrigger.ResetTrigger
// (Final, Native, Public, BlueprintCallable)

void AKosmosVFXTrigger::ResetTrigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosVFXTrigger", "ResetTrigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosVFXTrigger.TriggerEffect
// (Final, Native, Public, BlueprintCallable)

void AKosmosVFXTrigger::TriggerEffect()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosVFXTrigger", "TriggerEffect");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPlayerAnimInstance_WeaponTools.GetFlowControlComponent
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosFlowControlComponent*      ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosFlowControlComponent* UKosmosPlayerAnimInstance_WeaponTools::GetFlowControlComponent() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerAnimInstance_WeaponTools", "GetFlowControlComponent");

	Params::KosmosPlayerAnimInstance_WeaponTools_GetFlowControlComponent Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlayerAnimInstance_WeaponTools.ShouldIdle
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPlayerAnimInstance_WeaponTools::ShouldIdle() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerAnimInstance_WeaponTools", "ShouldIdle");

	Params::KosmosPlayerAnimInstance_WeaponTools_ShouldIdle Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlayerAnimInstance_WeaponTools.ShouldStrafeStandTurn
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPlayerAnimInstance_WeaponTools::ShouldStrafeStandTurn() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPlayerAnimInstance_WeaponTools", "ShouldStrafeStandTurn");

	Params::KosmosPlayerAnimInstance_WeaponTools_ShouldStrafeStandTurn Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosLookAtVolume.BeginOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLookAtVolume::BeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLookAtVolume", "BeginOverlap");

	Params::KosmosLookAtVolume_BeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLookAtVolume.EndOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLookAtVolume::EndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLookAtVolume", "EndOverlap");

	Params::KosmosLookAtVolume_EndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLookAtVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLookAtVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLookAtVolume", "SetBounds");

	Params::KosmosLookAtVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLookAtVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosLookAtVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLookAtVolume", "SetBoxExtent");

	Params::KosmosLookAtVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPhysicsAudioComponent.GetVertexPaintData
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// bool*                                   hasPaintData                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FColor*                          paintData                                              (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPhysicsAudioComponent::GetVertexPaintData(bool* hasPaintData, struct FColor* paintData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPhysicsAudioComponent", "GetVertexPaintData");

	Params::KosmosPhysicsAudioComponent_GetVertexPaintData Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (hasPaintData != nullptr)
		*hasPaintData = Parms.hasPaintData;

	if (paintData != nullptr)
		*paintData = std::move(Parms.paintData);
}


// Function Kosmos.KosmosPhysicsAudioComponent.OnPrimitiveHit
// (Final, Native, Private, HasOutParams, HasDefaults)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UKosmosPhysicsAudioComponent::OnPrimitiveHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPhysicsAudioComponent", "OnPrimitiveHit");

	Params::KosmosPhysicsAudioComponent_OnPrimitiveHit Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPhysicsAudioComponent.OnPrimitiveSleep
// (Final, Native, Private)
// Parameters:
// class UPrimitiveComponent*              SleepingComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPhysicsAudioComponent::OnPrimitiveSleep(class UPrimitiveComponent* SleepingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPhysicsAudioComponent", "OnPrimitiveSleep");

	Params::KosmosPhysicsAudioComponent_OnPrimitiveSleep Parms{};

	Parms.SleepingComponent = SleepingComponent;
	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPhysicsAudioComponent.OnPrimitiveWake
// (Final, Native, Private)
// Parameters:
// class UPrimitiveComponent*              SleepingComponent                                      (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             BoneName                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPhysicsAudioComponent::OnPrimitiveWake(class UPrimitiveComponent* SleepingComponent, class FName BoneName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPhysicsAudioComponent", "OnPrimitiveWake");

	Params::KosmosPhysicsAudioComponent_OnPrimitiveWake Parms{};

	Parms.SleepingComponent = SleepingComponent;
	Parms.BoneName = BoneName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPhysicsAudioComponent.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   FadeTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPhysicsAudioComponent::SetEnabled(bool inEnabled, float FadeTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPhysicsAudioComponent", "SetEnabled");

	Params::KosmosPhysicsAudioComponent_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;
	Parms.FadeTime = FadeTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLostUmbrella.LoadDataFromSave
// (Final, Native, Public, BlueprintCallable)

void AKosmosLostUmbrella::LoadDataFromSave()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLostUmbrella", "LoadDataFromSave");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosLostUmbrella.SaveWasAnimationPlayed
// (Final, Native, Public, BlueprintCallable)

void AKosmosLostUmbrella::SaveWasAnimationPlayed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosLostUmbrella", "SaveWasAnimationPlayed");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUtils.GetAudioManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosAudioManagerActor*         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosAudioManagerActor* UKosmosUtils::GetAudioManager(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "GetAudioManager");

	Params::KosmosUtils_GetAudioManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.GetComplienceLayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosComplianceLayer*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosComplianceLayer* UKosmosUtils::GetComplienceLayer(const class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "GetComplienceLayer");

	Params::KosmosUtils_GetComplienceLayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.GetDemoLevelString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosUtils::GetDemoLevelString(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "GetDemoLevelString");

	Params::KosmosUtils_GetDemoLevelString Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.GetOnlineSessionManager
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosOnlineSessionManager*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosOnlineSessionManager* UKosmosUtils::GetOnlineSessionManager(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "GetOnlineSessionManager");

	Params::KosmosUtils_GetOnlineSessionManager Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsDemoBuild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsDemoBuild(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsDemoBuild");

	Params::KosmosUtils_IsDemoBuild Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsDemoMultiplayer
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsDemoMultiplayer(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsDemoMultiplayer");

	Params::KosmosUtils_IsDemoMultiplayer Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsDemoTrial
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsDemoTrial(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsDemoTrial");

	Params::KosmosUtils_IsDemoTrial Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsEOSBuild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsEOSBuild(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsEOSBuild");

	Params::KosmosUtils_IsEOSBuild Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsGOGBuild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsGOGBuild(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsGOGBuild");

	Params::KosmosUtils_IsGOGBuild Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsInView
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Radius                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsInView(class UObject* WorldContextObject, const struct FVector& Location, const float Radius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsInView");

	Params::KosmosUtils_IsInView Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Location = std::move(Location);
	Parms.Radius = Radius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUtils.IsSteamBuild
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUtils::IsSteamBuild(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosUtils", "IsSteamBuild");

	Params::KosmosUtils_IsSteamBuild Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMemoryAnalysisGameMode.Pause
// (Final, Native, Public, BlueprintCallable)

void AKosmosMemoryAnalysisGameMode::Pause()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMemoryAnalysisGameMode", "Pause");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMemoryAnalysisGameMode.PostProcess
// (Final, Native, Public, BlueprintCallable)

void AKosmosMemoryAnalysisGameMode::PostProcess()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMemoryAnalysisGameMode", "PostProcess");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMemoryAnalysisGameMode.Start
// (Final, Native, Public, BlueprintCallable)

void AKosmosMemoryAnalysisGameMode::Start()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMemoryAnalysisGameMode", "Start");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMemoryAnalysisGameMode.Stop
// (Final, Native, Public, BlueprintCallable)

void AKosmosMemoryAnalysisGameMode::Stop()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMemoryAnalysisGameMode", "Stop");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMetaGameStatsBlueprintLibrary.DecrementStat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosMetaStatName                     InStatName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IncrementalValue                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMetaGameStatsBlueprintLibrary::DecrementStat(class UObject* WorldContextObject, EKosmosMetaStatName InStatName, int32 IncrementalValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameStatsBlueprintLibrary", "DecrementStat");

	Params::KosmosMetaGameStatsBlueprintLibrary_DecrementStat Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InStatName = InStatName;
	Parms.IncrementalValue = IncrementalValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMetaGameStatsBlueprintLibrary.GetStat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosMetaStatName                     InStatName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosMetaGameStatsBlueprintLibrary::GetStat(class UObject* WorldContextObject, EKosmosMetaStatName InStatName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameStatsBlueprintLibrary", "GetStat");

	Params::KosmosMetaGameStatsBlueprintLibrary_GetStat Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InStatName = InStatName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameStatsBlueprintLibrary.IncrementStat
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosMetaStatName                     InStatName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   IncrementalValue                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMetaGameStatsBlueprintLibrary::IncrementStat(class UObject* WorldContextObject, EKosmosMetaStatName InStatName, int32 IncrementalValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameStatsBlueprintLibrary", "IncrementStat");

	Params::KosmosMetaGameStatsBlueprintLibrary_IncrementStat Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InStatName = InStatName;
	Parms.IncrementalValue = IncrementalValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMetaGameStatsBlueprintLibrary.QueryStats
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMetaGameStatsBlueprintLibrary::QueryStats(class UObject* WorldContextObject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameStatsBlueprintLibrary", "QueryStats");

	Params::KosmosMetaGameStatsBlueprintLibrary_QueryStats Parms{};

	Parms.WorldContextObject = WorldContextObject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.CollectCollectable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&InCollectableNameRef                                   (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::CollectCollectable(class UObject* WorldContextObject, const struct FKosmosCollectableNameReference& InCollectableNameRef, bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "CollectCollectable");

	Params::KosmosMetaGameBlueprintLibrary_CollectCollectable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCollectableNameRef = std::move(InCollectableNameRef);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.CollectWearable
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&InWearableName                                         (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::CollectWearable(class UObject* WorldContextObject, const struct FKosmosCollectableNameReference& InWearableName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "CollectWearable");

	Params::KosmosMetaGameBlueprintLibrary_CollectWearable Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InWearableName = std::move(InWearableName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.GetCollectableSaveKey
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&InCollectableNameRef                                   (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosMetaGameBlueprintLibrary::GetCollectableSaveKey(class UObject* WorldContextObject, const struct FKosmosCollectableNameReference& InCollectableNameRef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "GetCollectableSaveKey");

	Params::KosmosMetaGameBlueprintLibrary_GetCollectableSaveKey Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCollectableNameRef = std::move(InCollectableNameRef);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.GetMetaSlotSaveBool
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::GetMetaSlotSaveBool(class UObject* WorldContextObject, const class FString& InFormattedKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "GetMetaSlotSaveBool");

	Params::KosmosMetaGameBlueprintLibrary_GetMetaSlotSaveBool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InFormattedKey = std::move(InFormattedKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.GetMetaSlotSaveString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosMetaGameBlueprintLibrary::GetMetaSlotSaveString(class UObject* WorldContextObject, const class FString& InFormattedKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "GetMetaSlotSaveString");

	Params::KosmosMetaGameBlueprintLibrary_GetMetaSlotSaveString Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InFormattedKey = std::move(InFormattedKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.GetSaveSlotValueBool
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosPersistence                      Persistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::GetSaveSlotValueBool(class UObject* WorldContextObject, EKosmosPersistence Persistance, const class FString& InFormattedKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "GetSaveSlotValueBool");

	Params::KosmosMetaGameBlueprintLibrary_GetSaveSlotValueBool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Persistance = Persistance;
	Parms.InFormattedKey = std::move(InFormattedKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.GetSaveSlotValueString
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EKosmosPersistence                      Persistance                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosMetaGameBlueprintLibrary::GetSaveSlotValueString(class UObject* WorldContextObject, EKosmosPersistence Persistance, const class FString& InFormattedKey)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "GetSaveSlotValueString");

	Params::KosmosMetaGameBlueprintLibrary_GetSaveSlotValueString Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Persistance = Persistance;
	Parms.InFormattedKey = std::move(InFormattedKey);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.IsAllCollecatablesCollected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosCollectableListDataAsset*  InCollectablesNameList                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::IsAllCollecatablesCollected(class UObject* WorldContextObject, class UKosmosCollectableListDataAsset* InCollectablesNameList)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "IsAllCollecatablesCollected");

	Params::KosmosMetaGameBlueprintLibrary_IsAllCollecatablesCollected Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCollectablesNameList = InCollectablesNameList;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.IsCollectableCollected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosCollectableNameReference&InCollectableNameRef                                   (Parm, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMetaGameBlueprintLibrary::IsCollectableCollected(class UObject* WorldContextObject, const struct FKosmosCollectableNameReference& InCollectableNameRef)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "IsCollectableCollected");

	Params::KosmosMetaGameBlueprintLibrary_IsCollectableCollected Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InCollectableNameRef = std::move(InCollectableNameRef);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.SetMetaSlotSaveBool
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMetaGameBlueprintLibrary::SetMetaSlotSaveBool(class UObject* WorldContextObject, const class FString& InFormattedKey, bool inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "SetMetaSlotSaveBool");

	Params::KosmosMetaGameBlueprintLibrary_SetMetaSlotSaveBool Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InFormattedKey = std::move(InFormattedKey);
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMetaGameBlueprintLibrary.SetMetaSlotSaveString
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InFormattedKey                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    inValue                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMetaGameBlueprintLibrary::SetMetaSlotSaveString(class UObject* WorldContextObject, const class FString& InFormattedKey, const class FString& inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMetaGameBlueprintLibrary", "SetMetaSlotSaveString");

	Params::KosmosMetaGameBlueprintLibrary_SetMetaSlotSaveString Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InFormattedKey = std::move(InFormattedKey);
	Parms.inValue = std::move(inValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMonsterController.SetStopMovementOnFinish
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosMonsterController::SetStopMovementOnFinish(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMonsterController", "SetStopMovementOnFinish");

	Params::KosmosMonsterController_SetStopMovementOnFinish Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMonsterController.SetupBehaviourTree
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UBehaviorTree*                    InTree                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosMonsterController::SetupBehaviourTree(class UBehaviorTree* InTree)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMonsterController", "SetupBehaviourTree");

	Params::KosmosMonsterController_SetupBehaviourTree Parms{};

	Parms.InTree = InTree;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMonsterController.StopBehaviorTree
// (Final, Native, Public, BlueprintCallable)

void AKosmosMonsterController::StopBehaviorTree()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMonsterController", "StopBehaviorTree");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMonsterController.IsCurrentlyUsingNavigationLink
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosMonsterController::IsCurrentlyUsingNavigationLink() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMonsterController", "IsCurrentlyUsingNavigationLink");

	Params::KosmosMonsterController_IsCurrentlyUsingNavigationLink Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMonsterController.SetAISightPerceptionViewPoint
// (Event, Public, HasOutParams, HasDefaults, BlueprintEvent, Const)
// Parameters:
// struct FVector*                         out_Location                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FRotator*                        out_Rotation                                           (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosMonsterController::SetAISightPerceptionViewPoint(struct FVector* out_Location, struct FRotator* out_Rotation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMonsterController", "SetAISightPerceptionViewPoint");

	Params::KosmosMonsterController_SetAISightPerceptionViewPoint Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (out_Location != nullptr)
		*out_Location = std::move(Parms.out_Location);

	if (out_Rotation != nullptr)
		*out_Rotation = std::move(Parms.out_Rotation);
}


// Function Kosmos.KosmosUserWidget.SynchronizeAccessibilityOptions
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)

void UKosmosUserWidget::SynchronizeAccessibilityOptions()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUserWidget", "SynchronizeAccessibilityOptions");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.AdjustInputDuringMovement
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   NewInput                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::AdjustInputDuringMovement(const struct FVector& NewInput, float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "AdjustInputDuringMovement");

	Params::KosmosMovement_AdjustInputDuringMovement Parms{};

	Parms.NewInput = std::move(NewInput);
	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.ForceSwitchToFalling
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   ApexBoost                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::ForceSwitchToFalling(float ApexBoost)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "ForceSwitchToFalling");

	Params::KosmosMovement_ForceSwitchToFalling Parms{};

	Parms.ApexBoost = ApexBoost;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.GetCurrentWalkType
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// EWalkTransitionType                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EWalkTransitionType UKosmosMovement::GetCurrentWalkType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetCurrentWalkType");

	Params::KosmosMovement_GetCurrentWalkType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.GetStartFallPosition
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosMovement::GetStartFallPosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetStartFallPosition");

	Params::KosmosMovement_GetStartFallPosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.OnAnimNotify
// (Final, Native, Protected, HasOutParams)
// Parameters:
// const struct FFlowControlAnimNotifyData&AnimNotify                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosMovement::OnAnimNotify(const struct FFlowControlAnimNotifyData& AnimNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "OnAnimNotify");

	Params::KosmosMovement_OnAnimNotify Parms{};

	Parms.AnimNotify = std::move(AnimNotify);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.OnRep_KosmosSimProxyData
// (Final, Native, Protected)

void UKosmosMovement::OnRep_KosmosSimProxyData()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "OnRep_KosmosSimProxyData");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.ResetFallingPosition
// (Final, Native, Public, BlueprintCallable)

void UKosmosMovement::ResetFallingPosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "ResetFallingPosition");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.SetDesiredFacingDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Direction                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    snap                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::SetDesiredFacingDirection(const struct FVector& Direction, bool snap)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetDesiredFacingDirection");

	Params::KosmosMovement_SetDesiredFacingDirection Parms{};

	Parms.Direction = std::move(Direction);
	Parms.snap = snap;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.SetDirectionToFace
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FRotator&                  InRotator                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosMovement::SetDirectionToFace(const struct FRotator& InRotator)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetDirectionToFace");

	Params::KosmosMovement_SetDirectionToFace Parms{};

	Parms.InRotator = std::move(InRotator);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.SetDirectionToFaceByVector
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InVector                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::SetDirectionToFaceByVector(const struct FVector& InVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetDirectionToFaceByVector");

	Params::KosmosMovement_SetDirectionToFaceByVector Parms{};

	Parms.InVector = std::move(InVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.SetDriftVelocity
// (Final, Native, Private, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector2D&                 DriftVel                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::SetDriftVelocity(const struct FVector2D& DriftVel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetDriftVelocity");

	Params::KosmosMovement_SetDriftVelocity Parms{};

	Parms.DriftVel = std::move(DriftVel);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.SetFallLimits
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EKosmosFallType                         inFallType                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMovement::SetFallLimits(EKosmosFallType inFallType, float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetFallLimits");

	Params::KosmosMovement_SetFallLimits Parms{};

	Parms.inFallType = inFallType;
	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.SetLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InLocation                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosMovement::SetLocation(const struct FVector& InLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "SetLocation");

	Params::KosmosMovement_SetLocation Parms{};

	Parms.InLocation = std::move(InLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosMovement.GetInputDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosMovement::GetInputDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetInputDirection");

	Params::KosmosMovement_GetInputDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.GetInputSpeed
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovement::GetInputSpeed() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetInputSpeed");

	Params::KosmosMovement_GetInputSpeed Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.GetLastValidLookInputDirection
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosMovement::GetLastValidLookInputDirection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetLastValidLookInputDirection");

	Params::KosmosMovement_GetLastValidLookInputDirection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.GetSprintRatio
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovement::GetSprintRatio() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetSprintRatio");

	Params::KosmosMovement_GetSprintRatio Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.GetWalkStartIndex
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UKosmosMovement::GetWalkStartIndex() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "GetWalkStartIndex");

	Params::KosmosMovement_GetWalkStartIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.IsInputEnoughToStartWalk
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMovement::IsInputEnoughToStartWalk() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "IsInputEnoughToStartWalk");

	Params::KosmosMovement_IsInputEnoughToStartWalk Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.IsSprinting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosMovement::IsSprinting() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "IsSprinting");

	Params::KosmosMovement_IsSprinting Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovement.K2_GetTurnVelocity
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovement::K2_GetTurnVelocity() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosMovement", "K2_GetTurnVelocity");

	Params::KosmosMovement_K2_GetTurnVelocity Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovementBlueprintLibrary.GetMovementSpeedInterval
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosMovementParams&     InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   InAlpha                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovementBlueprintLibrary::GetMovementSpeedInterval(const struct FKosmosMovementParams& InParams, float InAlpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMovementBlueprintLibrary", "GetMovementSpeedInterval");

	Params::KosmosMovementBlueprintLibrary_GetMovementSpeedInterval Parms{};

	Parms.InParams = std::move(InParams);
	Parms.InAlpha = InAlpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovementBlueprintLibrary.GetMovementSpeedMax
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosMovementParams&     InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovementBlueprintLibrary::GetMovementSpeedMax(const struct FKosmosMovementParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMovementBlueprintLibrary", "GetMovementSpeedMax");

	Params::KosmosMovementBlueprintLibrary_GetMovementSpeedMax Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovementBlueprintLibrary.GetMovementSpeedMin
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosMovementParams&     InParams                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosMovementBlueprintLibrary::GetMovementSpeedMin(const struct FKosmosMovementParams& InParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMovementBlueprintLibrary", "GetMovementSpeedMin");

	Params::KosmosMovementBlueprintLibrary_GetMovementSpeedMin Parms{};

	Parms.InParams = std::move(InParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosMovementBlueprintLibrary.LerpMovementParams
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosMovementParams&     A                                                      (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// const struct FKosmosMovementParams&     B                                                      (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// float                                   Alpha                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosMovementParams            ReturnValue                                            (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)

struct FKosmosMovementParams UKosmosMovementBlueprintLibrary::LerpMovementParams(const struct FKosmosMovementParams& A, const struct FKosmosMovementParams& B, float Alpha)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosMovementBlueprintLibrary", "LerpMovementParams");

	Params::KosmosMovementBlueprintLibrary_LerpMovementParams Parms{};

	Parms.A = std::move(A);
	Parms.B = std::move(B);
	Parms.Alpha = Alpha;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.CheckOverlapping
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::CheckOverlapping(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "CheckOverlapping");

	Params::KosmosZipline_CheckOverlapping Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.ClearCharacterFromData
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::ClearCharacterFromData(class UKosmosHangableComponent* hangable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "ClearCharacterFromData");

	Params::KosmosZipline_ClearCharacterFromData Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.CompareHangable1AndHangable2
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKosmosZipline::CompareHangable1AndHangable2()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "CompareHangable1AndHangable2");

	Params::KosmosZipline_CompareHangable1AndHangable2 Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.DebugPrintString
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class FString&                    inString                                               (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::DebugPrintString(const class FString& inString)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "DebugPrintString");

	Params::KosmosZipline_DebugPrintString Parms{};

	Parms.inString = std::move(inString);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.FindClosestPointOnZipline
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   LocationOffset                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosZipline::FindClosestPointOnZipline(const class UKosmosHangableComponent* hangable, const struct FVector& LocationOffset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "FindClosestPointOnZipline");

	Params::KosmosZipline_FindClosestPointOnZipline Parms{};

	Parms.hangable = hangable;
	Parms.LocationOffset = std::move(LocationOffset);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.ForceRelease
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::ForceRelease(class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "ForceRelease");

	Params::KosmosZipline_ForceRelease Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.GetEndOffset
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosZipline::GetEndOffset(const class UKosmosHangableComponent* hangable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetEndOffset");

	Params::KosmosZipline_GetEndOffset Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetTotalDistance
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosZipline::GetTotalDistance(const class UKosmosHangableComponent* hangable)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetTotalDistance");

	Params::KosmosZipline_GetTotalDistance Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetZiplineDataBP
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosZiplineRuntimeData*       ZiplineData                                            (Parm, OutParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosZipline::GetZiplineDataBP(const class UKosmosHangableComponent* hangable, struct FKosmosZiplineRuntimeData* ZiplineData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetZiplineDataBP");

	Params::KosmosZipline_GetZiplineDataBP Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (ZiplineData != nullptr)
		*ZiplineData = std::move(Parms.ZiplineData);
}


// Function Kosmos.KosmosZipline.HangableGrabEnd
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::HangableGrabEnd(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "HangableGrabEnd");

	Params::KosmosZipline_HangableGrabEnd Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.HangableGrabStart
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::HangableGrabStart(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "HangableGrabStart");

	Params::KosmosZipline_HangableGrabStart Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.HangableTransitionStart
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::HangableTransitionStart(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "HangableTransitionStart");

	Params::KosmosZipline_HangableTransitionStart Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.OnCharacterDestroyed
// (Native, Event, Protected, BlueprintEvent)
// Parameters:
// class AActor*                           DestroyedActor                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::OnCharacterDestroyed(class AActor* DestroyedActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "OnCharacterDestroyed");

	Params::KosmosZipline_OnCharacterDestroyed Parms{};

	Parms.DestroyedActor = DestroyedActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.OnDetectVolumeOverlap
// (Final, Native, Protected, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosZipline::OnDetectVolumeOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "OnDetectVolumeOverlap");

	Params::KosmosZipline_OnDetectVolumeOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.Playpal_GetLocationAndRotation
// (Event, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector*                         OutLocation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutRotation                                            (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::Playpal_GetLocationAndRotation(struct FVector* OutLocation, struct FVector* OutRotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "Playpal_GetLocationAndRotation");

	Params::KosmosZipline_Playpal_GetLocationAndRotation Parms{};

	UObject::ProcessEvent(Func, &Parms);

	if (OutLocation != nullptr)
		*OutLocation = std::move(Parms.OutLocation);

	if (OutRotation != nullptr)
		*OutRotation = std::move(Parms.OutRotation);
}


// Function Kosmos.KosmosZipline.RemoveReleaseGrabbingRestriction
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::RemoveReleaseGrabbingRestriction(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "RemoveReleaseGrabbingRestriction");

	Params::KosmosZipline_RemoveReleaseGrabbingRestriction Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.SetReleaseGrabbingRestriction
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZipline::SetReleaseGrabbingRestriction(const class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "SetReleaseGrabbingRestriction");

	Params::KosmosZipline_SetReleaseGrabbingRestriction Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.SetZiplineData
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosZiplineRuntimeData& NewValue                                               (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosZipline::SetZiplineData(class UKosmosHangableComponent* hangable, const struct FKosmosZiplineRuntimeData& NewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "SetZiplineData");

	Params::KosmosZipline_SetZiplineData Parms{};

	Parms.hangable = hangable;
	Parms.NewValue = std::move(NewValue);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipline.FindClosestPointOnLine
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   TargetLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StartLocation                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   EndLocation                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosZipline::FindClosestPointOnLine(const struct FVector& TargetLocation, const struct FVector& StartLocation, const struct FVector& EndLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "FindClosestPointOnLine");

	Params::KosmosZipline_FindClosestPointOnLine Parms{};

	Parms.TargetLocation = std::move(TargetLocation);
	Parms.StartLocation = std::move(StartLocation);
	Parms.EndLocation = std::move(EndLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetAnotherHangable
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosHangableComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosHangableComponent* AKosmosZipline::GetAnotherHangable(const class UKosmosHangableComponent* hangable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetAnotherHangable");

	Params::KosmosZipline_GetAnotherHangable Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetEndZiplineWorldLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosZipline::GetEndZiplineWorldLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetEndZiplineWorldLocation");

	Params::KosmosZipline_GetEndZiplineWorldLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetHangableByCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosHangableComponent*         ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosHangableComponent* AKosmosZipline::GetHangableByCharacter(const class AKosmosBaseCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetHangableByCharacter");

	Params::KosmosZipline_GetHangableByCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetHangableDistanceFromStart
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosZipline::GetHangableDistanceFromStart(const class UKosmosHangableComponent* hangable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetHangableDistanceFromStart");

	Params::KosmosZipline_GetHangableDistanceFromStart Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetStartZiplineWorldLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosZipline::GetStartZiplineWorldLocation() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetStartZiplineWorldLocation");

	Params::KosmosZipline_GetStartZiplineWorldLocation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetZiplineAbilityByCharacter
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TSubclassOf<class UGameplayAbility>     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)

TSubclassOf<class UGameplayAbility> AKosmosZipline::GetZiplineAbilityByCharacter(const class AKosmosBaseCharacter* Character) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetZiplineAbilityByCharacter");

	Params::KosmosZipline_GetZiplineAbilityByCharacter Parms{};

	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipline.GetZiplineTrailParticle
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UKosmosHangableComponent*   hangable                                               (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNiagaraComponent*                ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNiagaraComponent* AKosmosZipline::GetZiplineTrailParticle(const class UKosmosHangableComponent* hangable) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipline", "GetZiplineTrailParticle");

	Params::KosmosZipline_GetZiplineTrailParticle Parms{};

	Parms.hangable = hangable;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNavigationSystem.FilterNavDataNotInSelectedLevel
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class ANavigationData*>&   InNavData                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class ANavigationData*>*         OutNavData                                             (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UWorld*                           InWorldToCheck                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosNavigationSystem::FilterNavDataNotInSelectedLevel(class UObject* WorldContextObject, const TArray<class ANavigationData*>& InNavData, TArray<class ANavigationData*>* OutNavData, class UWorld* InWorldToCheck)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosNavigationSystem", "FilterNavDataNotInSelectedLevel");

	Params::KosmosNavigationSystem_FilterNavDataNotInSelectedLevel Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InNavData = std::move(InNavData);
	Parms.InWorldToCheck = InWorldToCheck;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutNavData != nullptr)
		*OutNavData = std::move(Parms.OutNavData);
}


// Function Kosmos.KosmosNavigationSystem.MakeFindMainDataIfMissing
// (Final, Native, Public, BlueprintCallable)

void UKosmosNavigationSystem::MakeFindMainDataIfMissing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavigationSystem", "MakeFindMainDataIfMissing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavigationSystem.MakeSureRightData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class ANavigationData*>&   InNavData                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UKosmosNavigationSystem::MakeSureRightData(const TArray<class ANavigationData*>& InNavData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavigationSystem", "MakeSureRightData");

	Params::KosmosNavigationSystem_MakeSureRightData Parms{};

	Parms.InNavData = std::move(InNavData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavigationSystem.SetNavData
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const TArray<class ANavigationData*>&   InNavData                                              (Parm, ZeroConstructor, NativeAccessSpecifierPublic)

void UKosmosNavigationSystem::SetNavData(const TArray<class ANavigationData*>& InNavData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavigationSystem", "SetNavData");

	Params::KosmosNavigationSystem_SetNavData Parms{};

	Parms.InNavData = std::move(InNavData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavigationSystem.ShouldBeDynamic
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInValue                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosNavigationSystem::ShouldBeDynamic(bool bInValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavigationSystem", "ShouldBeDynamic");

	Params::KosmosNavigationSystem_ShouldBeDynamic Parms{};

	Parms.bInValue = bInValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavigationSystem.GetNavDataForCharacter
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class ACharacter*                       InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class ANavigationData*            ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class ANavigationData* UKosmosNavigationSystem::GetNavDataForCharacter(class ACharacter* InCharacter) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavigationSystem", "GetNavDataForCharacter");

	Params::KosmosNavigationSystem_GetNavDataForCharacter Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.SwarmComponent.AvoidExclusionPoints
// (Net, NetReliable, Native, Event, NetMulticast, Protected, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   ExclusionPoint                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ExclusionRange                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void USwarmComponent::AvoidExclusionPoints(const struct FVector& ExclusionPoint, float ExclusionRange)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwarmComponent", "AvoidExclusionPoints");

	Params::SwarmComponent_AvoidExclusionPoints Parms{};

	Parms.ExclusionPoint = std::move(ExclusionPoint);
	Parms.ExclusionRange = ExclusionRange;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.SwarmComponent.Init
// (Final, Native, Protected, BlueprintCallable)

void USwarmComponent::Init()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("SwarmComponent", "Init");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavLink.GetRunPoint
// (Event, Public, HasDefaults, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector AKosmosNavLink::GetRunPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "GetRunPoint");

	Params::KosmosNavLink_GetRunPoint Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNavLink.HasRunPoint
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosNavLink::HasRunPoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "HasRunPoint");

	Params::KosmosNavLink_HasRunPoint Parms{};

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNavLink.OnPropertyChannge
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class FName                             InPropertyName                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNavLink::OnPropertyChannge(class FName InPropertyName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "OnPropertyChannge");

	Params::KosmosNavLink_OnPropertyChannge Parms{};

	Parms.InPropertyName = InPropertyName;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosNavLink.SetLinkData
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   RelativeStart                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   RelativeEnd                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// ENavLinkDirection                       Direction                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNavLink::SetLinkData(const struct FVector& RelativeStart, const struct FVector& RelativeEnd, ENavLinkDirection Direction)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "SetLinkData");

	Params::KosmosNavLink_SetLinkData Parms{};

	Parms.RelativeStart = std::move(RelativeStart);
	Parms.RelativeEnd = std::move(RelativeEnd);
	Parms.Direction = Direction;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavLink.SetWaitOnLink
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNavLink::SetWaitOnLink(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "SetWaitOnLink");

	Params::KosmosNavLink_SetWaitOnLink Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNavLink.Update
// (Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNavLink::Update(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNavLink", "Update");

	Params::KosmosNavLink_Update Parms{};

	Parms.DeltaTime = DeltaTime;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosNetBlueprintLibrary.AddNetInterpSample
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
// Parameters:
// struct FKosmosNetInterpSamplesBuffer&   Samples                                                (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   Value                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosNetBlueprintLibrary::AddNetInterpSample(struct FKosmosNetInterpSamplesBuffer& Samples, float Value)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosNetBlueprintLibrary", "AddNetInterpSample");

	Params::KosmosNetBlueprintLibrary_AddNetInterpSample Parms{};

	Parms.Samples = std::move(Samples);
	Parms.Value = Value;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Samples = std::move(Parms.Samples);
}


// Function Kosmos.KosmosNetBlueprintLibrary.ClearNetInterpSamples
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable)
// Parameters:
// struct FKosmosNetInterpSamplesBuffer&   Samples                                                (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosNetBlueprintLibrary::ClearNetInterpSamples(struct FKosmosNetInterpSamplesBuffer& Samples)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosNetBlueprintLibrary", "ClearNetInterpSamples");

	Params::KosmosNetBlueprintLibrary_ClearNetInterpSamples Parms{};

	Parms.Samples = std::move(Samples);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	Samples = std::move(Parms.Samples);
}


// Function Kosmos.KosmosNetBlueprintLibrary.GetAverageNetInterpSample
// (Final, Native, Static, Private, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FKosmosNetInterpSamplesBuffer&Samples                                                (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosNetBlueprintLibrary::GetAverageNetInterpSample(const struct FKosmosNetInterpSamplesBuffer& Samples)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosNetBlueprintLibrary", "GetAverageNetInterpSample");

	Params::KosmosNetBlueprintLibrary_GetAverageNetInterpSample Parms{};

	Parms.Samples = std::move(Samples);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNetBlueprintLibrary.GetPlayerInput
// (Final, Native, Static, Private, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AKosmosBaseCharacter*       Character                                              (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TurningPoint                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   PlayerInput                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosNetBlueprintLibrary::GetPlayerInput(const class AKosmosBaseCharacter* Character, const struct FVector& TurningPoint, const struct FVector& PlayerInput)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosNetBlueprintLibrary", "GetPlayerInput");

	Params::KosmosNetBlueprintLibrary_GetPlayerInput Parms{};

	Parms.Character = Character;
	Parms.TurningPoint = std::move(TurningPoint);
	Parms.PlayerInput = std::move(PlayerInput);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNomeSpline.Client_HandleSplineResume
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// const bool                              InReachedEnd                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             InAdvancedStage                                        (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<bool>&                     StageVisibilities                                      (ConstParm, Parm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void AKosmosNomeSpline::Client_HandleSplineResume(const bool InReachedEnd, const int32 InAdvancedStage, const TArray<bool>& StageVisibilities)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "Client_HandleSplineResume");

	Params::KosmosNomeSpline_Client_HandleSplineResume Parms{};

	Parms.InReachedEnd = InReachedEnd;
	Parms.InAdvancedStage = InAdvancedStage;
	Parms.StageVisibilities = std::move(StageVisibilities);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNomeSpline.Client_PostFinishHug
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AKosmosNomeSpline::Client_PostFinishHug()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "Client_PostFinishHug");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNomeSpline.Client_Trigger
// (Net, NetReliable, Native, Event, NetMulticast, Public, BlueprintCallable)

void AKosmosNomeSpline::Client_Trigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "Client_Trigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNomeSpline.GetActivationAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAnimSequence*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequence* AKosmosNomeSpline::GetActivationAnimation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "GetActivationAnimation");

	Params::KosmosNomeSpline_GetActivationAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNomeSpline.GetFinalAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAnimSequence*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequence* AKosmosNomeSpline::GetFinalAnimation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "GetFinalAnimation");

	Params::KosmosNomeSpline_GetFinalAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNomeSpline.GetIdleAnimation
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class UAnimSequence*                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UAnimSequence* AKosmosNomeSpline::GetIdleAnimation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "GetIdleAnimation");

	Params::KosmosNomeSpline_GetIdleAnimation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosNomeSpline.NomeHugged
// (Final, Native, Public)
// Parameters:
// class AActor*                           Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNomeSpline::NomeHugged(class AActor* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "NomeHugged");

	Params::KosmosNomeSpline_NomeHugged Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNomeSpline.OnTriggerVolumeHit
// (Final, Native, Public)
// Parameters:
// class APawn*                            Pawn                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosNomeSpline::OnTriggerVolumeHit(class APawn* Pawn)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "OnTriggerVolumeHit");

	Params::KosmosNomeSpline_OnTriggerVolumeHit Parms{};

	Parms.Pawn = Pawn;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosNomeSpline.Trigger
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosNomeSpline::Trigger()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosNomeSpline", "Trigger");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionManager.HideLoadingScreen
// (Final, Native, Public, BlueprintCallable)

void UKosmosOnlineSessionManager::HideLoadingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOnlineSessionManager", "HideLoadingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionManager.SetUserDismissLowConnection
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const bool                              bValue                                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOnlineSessionManager::SetUserDismissLowConnection(const bool bValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOnlineSessionManager", "SetUserDismissLowConnection");

	Params::KosmosOnlineSessionManager_SetUserDismissLowConnection Parms{};

	Parms.bValue = bValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionManager.ShowLoadingScreen
// (Final, Native, Public, BlueprintCallable)

void UKosmosOnlineSessionManager::ShowLoadingScreen()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOnlineSessionManager", "ShowLoadingScreen");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOnlineSessionManager.GetSentToFrontEndForLowConnection
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosOnlineSessionManager::GetSentToFrontEndForLowConnection() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOnlineSessionManager", "GetSentToFrontEndForLowConnection");

	Params::KosmosOnlineSessionManager_GetSentToFrontEndForLowConnection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosOutfitComponent.CheckOutfitOnEntitlementUpdate
// (Final, Native, Protected)

void UKosmosOutfitComponent::CheckOutfitOnEntitlementUpdate()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "CheckOutfitOnEntitlementUpdate");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.Multicast_TriggerCostumeChange
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const class FString&                    InOutfitVariation                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::Multicast_TriggerCostumeChange(const class FString& InOutfitVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "Multicast_TriggerCostumeChange");

	Params::KosmosOutfitComponent_Multicast_TriggerCostumeChange Parms{};

	Parms.InOutfitVariation = std::move(InOutfitVariation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.OnCharacterSpawned
// (Final, Native, Protected)

void UKosmosOutfitComponent::OnCharacterSpawned()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "OnCharacterSpawned");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.OnRep_CharVariantChange
// (Final, Native, Protected)

void UKosmosOutfitComponent::OnRep_CharVariantChange()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "OnRep_CharVariantChange");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.PreviewOutfit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Variant                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InCharacterTag                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::PreviewOutfit(const class FString& Variant, const class FString& InCharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "PreviewOutfit");

	Params::KosmosOutfitComponent_PreviewOutfit Parms{};

	Parms.Variant = std::move(Variant);
	Parms.InCharacterTag = std::move(InCharacterTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.ResetOutfit
// (Final, Native, Public, BlueprintCallable)

void UKosmosOutfitComponent::ResetOutfit()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "ResetOutfit");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.Server_TriggerCostumeChange
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// const class FString&                    InOutfitVariation                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::Server_TriggerCostumeChange(const class FString& InOutfitVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "Server_TriggerCostumeChange");

	Params::KosmosOutfitComponent_Server_TriggerCostumeChange Parms{};

	Parms.InOutfitVariation = std::move(InOutfitVariation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.SetCharacterTag
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InCharacterTag                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::SetCharacterTag(const class FString& InCharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "SetCharacterTag");

	Params::KosmosOutfitComponent_SetCharacterTag Parms{};

	Parms.InCharacterTag = std::move(InCharacterTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.SetOutfitVariations
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class UKosmosWearableItems*             InVariantAsset                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::SetOutfitVariations(class UKosmosWearableItems* InVariantAsset)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "SetOutfitVariations");

	Params::KosmosOutfitComponent_SetOutfitVariations Parms{};

	Parms.InVariantAsset = InVariantAsset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.SetSelectedVariation
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InOutfitVariation                                      (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::SetSelectedVariation(const class FString& InOutfitVariation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "SetSelectedVariation");

	Params::KosmosOutfitComponent_SetSelectedVariation Parms{};

	Parms.InOutfitVariation = std::move(InOutfitVariation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.UpdateClothSim
// (Final, Native, Public, BlueprintCallable)

void UKosmosOutfitComponent::UpdateClothSim()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "UpdateClothSim");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosOutfitComponent.UpdateOutfit
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const class FString&                    Variant                                                (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    InCharacterTag                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosOutfitComponent::UpdateOutfit(const class FString& Variant, const class FString& InCharacterTag)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosOutfitComponent", "UpdateOutfit");

	Params::KosmosOutfitComponent_UpdateOutfit Parms{};

	Parms.Variant = std::move(Variant);
	Parms.InCharacterTag = std::move(InCharacterTag);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementSubsystem.SetIsLocallyPaused
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInPaused                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementSubsystem::SetIsLocallyPaused(bool bInPaused)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "SetIsLocallyPaused");

	Params::KosmosPauseManagementSubsystem_SetIsLocallyPaused Parms{};

	Parms.bInPaused = bInPaused;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementSubsystem.SetIsPausingBlocked
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bInBlocked                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPauseManagementSubsystem::SetIsPausingBlocked(bool bInBlocked)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "SetIsPausingBlocked");

	Params::KosmosPauseManagementSubsystem_SetIsPausingBlocked Parms{};

	Parms.bInBlocked = bInBlocked;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPauseManagementSubsystem.GetIsLocallyPaused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPauseManagementSubsystem::GetIsLocallyPaused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "GetIsLocallyPaused");

	Params::KosmosPauseManagementSubsystem_GetIsLocallyPaused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPauseManagementSubsystem.GetIsPaused
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPauseManagementSubsystem::GetIsPaused() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "GetIsPaused");

	Params::KosmosPauseManagementSubsystem_GetIsPaused Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPauseManagementSubsystem.GetIsPausingBlocked
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPauseManagementSubsystem::GetIsPausingBlocked() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "GetIsPausingBlocked");

	Params::KosmosPauseManagementSubsystem_GetIsPausingBlocked Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPauseManagementSubsystem.GetIsWaitingOnOtherPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPauseManagementSubsystem::GetIsWaitingOnOtherPlayer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPauseManagementSubsystem", "GetIsWaitingOnOtherPlayer");

	Params::KosmosPauseManagementSubsystem_GetIsWaitingOnOtherPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.PhysicalReactionComponent.OnPhysicalReactionFinished
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhysicalReactionComponent::OnPhysicalReactionFinished(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalReactionComponent", "OnPhysicalReactionFinished");

	Params::PhysicalReactionComponent_OnPhysicalReactionFinished Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.PhysicalReactionComponent.OnPhysicalReactionStarted
// (Final, Native, Private, HasOutParams)
// Parameters:
// class AActor*                           notifier                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName&                      NotifyName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UAnimMetaData*>&     AnimMetaData                                           (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UPhysicalReactionComponent::OnPhysicalReactionStarted(class AActor* notifier, const class FName& NotifyName, const TArray<class UAnimMetaData*>& AnimMetaData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("PhysicalReactionComponent", "OnPhysicalReactionStarted");

	Params::PhysicalReactionComponent_OnPhysicalReactionStarted Parms{};

	Parms.notifier = notifier;
	Parms.NotifyName = NotifyName;
	Parms.AnimMetaData = std::move(AnimMetaData);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CalculateThrowData
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosThrowSettings&      ThrowSettings                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// struct FVector*                         OutTargetLocation                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector*                         OutThrowDirection                                      (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CalculateThrowData(class AKosmosBaseCharacter* InHolder, const struct FKosmosThrowSettings& ThrowSettings, struct FVector* OutTargetLocation, struct FVector* OutThrowDirection)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CalculateThrowData");

	Params::KosmosPickupComponent_CalculateThrowData Parms{};

	Parms.InHolder = InHolder;
	Parms.ThrowSettings = std::move(ThrowSettings);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTargetLocation != nullptr)
		*OutTargetLocation = std::move(Parms.OutTargetLocation);

	if (OutThrowDirection != nullptr)
		*OutThrowDirection = std::move(Parms.OutThrowDirection);
}


// Function Kosmos.KosmosPickupComponent.CallOnCarriableAttackStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnCarriableAttackStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnCarriableAttackStartedEvent");

	Params::KosmosPickupComponent_CallOnCarriableAttackStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnForceDrop
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnForceDrop(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnForceDrop");

	Params::KosmosPickupComponent_CallOnForceDrop Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPickupAttachEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPickupAttachEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPickupAttachEvent");

	Params::KosmosPickupComponent_CallOnPickupAttachEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPickupFinishedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPickupFinishedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPickupFinishedEvent");

	Params::KosmosPickupComponent_CallOnPickupFinishedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPickupSpawnedInInventory
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPickupSpawnedInInventory(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPickupSpawnedInInventory");

	Params::KosmosPickupComponent_CallOnPickupSpawnedInInventory Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPickupStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPickupStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPickupStartedEvent");

	Params::KosmosPickupComponent_CallOnPickupStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPutdownDetachEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPutdownDetachEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPutdownDetachEvent");

	Params::KosmosPickupComponent_CallOnPutdownDetachEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPutdownFinishedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPutdownFinishedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPutdownFinishedEvent");

	Params::KosmosPickupComponent_CallOnPutdownFinishedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnPutdownStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnPutdownStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnPutdownStartedEvent");

	Params::KosmosPickupComponent_CallOnPutdownStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnStashingInPocketFinishedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnStashingInPocketFinishedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnStashingInPocketFinishedEvent");

	Params::KosmosPickupComponent_CallOnStashingInPocketFinishedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnStashingInPocketStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnStashingInPocketStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnStashingInPocketStartedEvent");

	Params::KosmosPickupComponent_CallOnStashingInPocketStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnTakingFromPocketFinishedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnTakingFromPocketFinishedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnTakingFromPocketFinishedEvent");

	Params::KosmosPickupComponent_CallOnTakingFromPocketFinishedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnTakingFromPocketStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnTakingFromPocketStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnTakingFromPocketStartedEvent");

	Params::KosmosPickupComponent_CallOnTakingFromPocketStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnThrow
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   ThrowVector                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnThrow(class AKosmosBaseCharacter* InHolder, const struct FVector& ThrowVector)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnThrow");

	Params::KosmosPickupComponent_CallOnThrow Parms{};

	Parms.InHolder = InHolder;
	Parms.ThrowVector = std::move(ThrowVector);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnThrowFinishedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnThrowFinishedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnThrowFinishedEvent");

	Params::KosmosPickupComponent_CallOnThrowFinishedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CallOnThrowStartedEvent
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::CallOnThrowStartedEvent(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CallOnThrowStartedEvent");

	Params::KosmosPickupComponent_CallOnThrowStartedEvent Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.CanPutDown
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::CanPutDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CanPutDown");

	Params::KosmosPickupComponent_CanPutDown Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.DetachFromSlot
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    bShouldEject                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::DetachFromSlot(bool bShouldEject)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "DetachFromSlot");

	Params::KosmosPickupComponent_DetachFromSlot Parms{};

	Parms.bShouldEject = bShouldEject;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.OnRep_CurrentTarget
// (Final, Native, Protected)

void UKosmosPickupComponent::OnRep_CurrentTarget()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "OnRep_CurrentTarget");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.ResetIKTasks
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::ResetIKTasks(class AKosmosBaseCharacter* InHolder)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "ResetIKTasks");

	Params::KosmosPickupComponent_ResetIKTasks Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.Server_SetCurrentTarget
// (Net, NetReliable, Native, Event, Protected, NetServer)
// Parameters:
// class UKosmosTargetComponent*           NewCurrentTarget                                       (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::Server_SetCurrentTarget(class UKosmosTargetComponent* NewCurrentTarget)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "Server_SetCurrentTarget");

	Params::KosmosPickupComponent_Server_SetCurrentTarget Parms{};

	Parms.NewCurrentTarget = NewCurrentTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::SetEnabled(bool InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "SetEnabled");

	Params::KosmosPickupComponent_SetEnabled Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.SetGrabbableActorLocationAndRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   Location                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FRotator&                  Rotation                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::SetGrabbableActorLocationAndRotation(const struct FVector& Location, const struct FRotator& Rotation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "SetGrabbableActorLocationAndRotation");

	Params::KosmosPickupComponent_SetGrabbableActorLocationAndRotation Parms{};

	Parms.Location = std::move(Location);
	Parms.Rotation = std::move(Rotation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.SetHandEffectorTransform
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// EKosmosPickupHandType                   handType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FTransform&                NewTransform                                           (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosPickupComponent::SetHandEffectorTransform(EKosmosPickupHandType handType, const struct FTransform& NewTransform)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "SetHandEffectorTransform");

	Params::KosmosPickupComponent_SetHandEffectorTransform Parms{};

	Parms.handType = handType;
	Parms.NewTransform = std::move(NewTransform);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPickupComponent.Throw
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosThrowSettings&      ThrowSettings                                          (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// const struct FVector&                   ThrowTargetLocation                                    (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosPickupComponent::Throw(class AKosmosBaseCharacter* InHolder, const struct FKosmosThrowSettings& ThrowSettings, const struct FVector& ThrowTargetLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "Throw");

	Params::KosmosPickupComponent_Throw Parms{};

	Parms.InHolder = InHolder;
	Parms.ThrowSettings = std::move(ThrowSettings);
	Parms.ThrowTargetLocation = std::move(ThrowTargetLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.CanBeDroppedOnStumble
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::CanBeDroppedOnStumble() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "CanBeDroppedOnStumble");

	Params::KosmosPickupComponent_CanBeDroppedOnStumble Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetCurrentThrowTarget
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class AKosmosBaseCharacter*       InHolder                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   throwStart                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FKosmosThrowParameters&    Parameters                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// class UKosmosTargetComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosTargetComponent* UKosmosPickupComponent::GetCurrentThrowTarget(const class AKosmosBaseCharacter* InHolder, const struct FVector& throwStart, const struct FKosmosThrowParameters& Parameters) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetCurrentThrowTarget");

	Params::KosmosPickupComponent_GetCurrentThrowTarget Parms{};

	Parms.InHolder = InHolder;
	Parms.throwStart = std::move(throwStart);
	Parms.Parameters = std::move(Parameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetHandEffector
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosPickupHandType                   handType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform                       ReturnValue                                            (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FTransform UKosmosPickupComponent::GetHandEffector(EKosmosPickupHandType handType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetHandEffector");

	Params::KosmosPickupComponent_GetHandEffector Parms{};

	Parms.handType = handType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetPickUpPointLocation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           Holder_0                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosPickupComponent::GetPickUpPointLocation(class AActor* Holder_0) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetPickUpPointLocation");

	Params::KosmosPickupComponent_GetPickUpPointLocation Parms{};

	Parms.Holder_0 = Holder_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetPickUpTargetDirection
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   holderLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosPickupComponent::GetPickUpTargetDirection(const struct FVector& holderLocation) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetPickUpTargetDirection");

	Params::KosmosPickupComponent_GetPickUpTargetDirection Parms{};

	Parms.holderLocation = std::move(holderLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetTargetActor
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosTargetComponent*           ReturnValue                                            (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosTargetComponent* UKosmosPickupComponent::GetTargetActor() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetTargetActor");

	Params::KosmosPickupComponent_GetTargetActor Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.GetTargetToLerpTo
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AKosmosBaseCharacter*             InHolder                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FTransform*                      OutTargetToLerpTo                                      (Parm, OutParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::GetTargetToLerpTo(class AKosmosBaseCharacter* InHolder, struct FTransform* OutTargetToLerpTo) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "GetTargetToLerpTo");

	Params::KosmosPickupComponent_GetTargetToLerpTo Parms{};

	Parms.InHolder = InHolder;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutTargetToLerpTo != nullptr)
		*OutTargetToLerpTo = std::move(Parms.OutTargetToLerpTo);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.HasHandEffector
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// EKosmosPickupHandType                   handType                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::HasHandEffector(EKosmosPickupHandType handType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "HasHandEffector");

	Params::KosmosPickupComponent_HasHandEffector Parms{};

	Parms.handType = handType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.IsCurrentlyHeld
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::IsCurrentlyHeld() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "IsCurrentlyHeld");

	Params::KosmosPickupComponent_IsCurrentlyHeld Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "IsEnabled");

	Params::KosmosPickupComponent_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPickupComponent.IsInActiveState
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPickupComponent::IsInActiveState() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPickupComponent", "IsInActiveState");

	Params::KosmosPickupComponent_IsInActiveState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPIPManager.GetTargetPIP
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AKosmosPlaypalInteractionPoint*   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosPlaypalInteractionPoint* UKosmosPIPManager::GetTargetPIP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPIPManager", "GetTargetPIP");

	Params::KosmosPIPManager_GetTargetPIP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPIPManager.ShouldCancelTargetPIP
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosPIPManager::ShouldCancelTargetPIP()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPIPManager", "ShouldCancelTargetPIP");

	Params::KosmosPIPManager_ShouldCancelTargetPIP Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPIPMontage.OnMontageNotifyReceived
// (Final, Native, Private, HasOutParams)
// Parameters:
// class FName                             NotifyName                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FBranchingPointNotifyPayload&BranchingPointNotifyPayload                            (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)

void AKosmosPIPMontage::OnMontageNotifyReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPIPMontage", "OnMontageNotifyReceived");

	Params::KosmosPIPMontage_OnMontageNotifyReceived Parms{};

	Parms.NotifyName = NotifyName;
	Parms.BranchingPointNotifyPayload = std::move(BranchingPointNotifyPayload);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPIPMontage.PlaySequence
// (Event, Protected, BlueprintEvent)
// Parameters:
// class ALevelSequenceActor*              LevelSequence                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPIPMontage::PlaySequence(class ALevelSequenceActor* LevelSequence)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPIPMontage", "PlaySequence");

	Params::KosmosPIPMontage_PlaySequence Parms{};

	Parms.LevelSequence = LevelSequence;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalFlashlightAim
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           ActorToAimAt                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   AimLocation                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalFlashlightAim(class UObject* WorldContextObject, class AActor* ActorToAimAt, const struct FVector& AimLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalFlashlightAim");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalFlashlightAim Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ActorToAimAt = ActorToAimAt;
	Parms.AimLocation = std::move(AimLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalFlashlightToggle
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bShouldEquipped                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalFlashlightToggle(class UObject* WorldContextObject, bool bShouldEquipped)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalFlashlightToggle");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalFlashlightToggle Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.bShouldEquipped = bShouldEquipped;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalUmbrella
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldOpen                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalUmbrella(class UObject* WorldContextObject, bool ShouldOpen)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalUmbrella");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalUmbrella Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShouldOpen = ShouldOpen;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalWeaponAttack
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           Standpoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   StandLocation                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           TargetToHit                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   TargetLocation                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldStashOnFinish                                    (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   NumberOfAttacks                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   GoalRadius                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalWeaponAttack(class UObject* WorldContextObject, class AActor* Standpoint, const struct FVector& StandLocation, class AActor* TargetToHit, const struct FVector& TargetLocation, bool ShouldStashOnFinish, int32 NumberOfAttacks, float GoalRadius)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalWeaponAttack");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalWeaponAttack Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.Standpoint = Standpoint;
	Parms.StandLocation = std::move(StandLocation);
	Parms.TargetToHit = TargetToHit;
	Parms.TargetLocation = std::move(TargetLocation);
	Parms.ShouldStashOnFinish = ShouldStashOnFinish;
	Parms.NumberOfAttacks = NumberOfAttacks;
	Parms.GoalRadius = GoalRadius;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalWeaponShowHide
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ShouldShow                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalWeaponShowHide(class UObject* WorldContextObject, bool ShouldShow)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalWeaponShowHide");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalWeaponShowHide Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.ShouldShow = ShouldShow;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPlaypalCommandsWeaponTools.PlaypalWrenchLever
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosEnvironmentInteractable*   WrenchLever                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TargetProgress                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   HoldTime                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UKosmosPlaypalCommandsWeaponTools*ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosPlaypalCommandsWeaponTools* UKosmosPlaypalCommandsWeaponTools::PlaypalWrenchLever(class UObject* WorldContextObject, class AKosmosEnvironmentInteractable* WrenchLever, float TargetProgress, float HoldTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosPlaypalCommandsWeaponTools", "PlaypalWrenchLever");

	Params::KosmosPlaypalCommandsWeaponTools_PlaypalWrenchLever Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.WrenchLever = WrenchLever;
	Parms.TargetProgress = TargetProgress;
	Parms.HoldTime = HoldTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.AllPuppetsAreDead
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::AllPuppetsAreDead()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "AllPuppetsAreDead");

	Params::KosmosPuppetEncounterVolume_AllPuppetsAreDead Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.BeginEncounter
// (Final, Native, Public, BlueprintCallable)

void AKosmosPuppetEncounterVolume::BeginEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "BeginEncounter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.FindPathToSafety
// (Final, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure)
// Parameters:
// TArray<struct FVector>*                 OutPathPoints                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class AKosmosAIController*              PlaypalController                                      (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::FindPathToSafety(TArray<struct FVector>* OutPathPoints, class AKosmosAIController* PlaypalController)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "FindPathToSafety");

	Params::KosmosPuppetEncounterVolume_FindPathToSafety Parms{};

	Parms.PlaypalController = PlaypalController;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPathPoints != nullptr)
		*OutPathPoints = std::move(Parms.OutPathPoints);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.FinishEncounter
// (Final, Native, Public, BlueprintCallable)

void AKosmosPuppetEncounterVolume::FinishEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "FinishEncounter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.GetNumPuppets
// (Native, Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 AKosmosPuppetEncounterVolume::GetNumPuppets()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "GetNumPuppets");

	Params::KosmosPuppetEncounterVolume_GetNumPuppets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.GetPuppetInfo
// (Native, Event, Protected, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Index_0                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FKosmosPuppetEncounterAgents*    OutPuppetData                                          (Parm, OutParm, NativeAccessSpecifierPublic)

void AKosmosPuppetEncounterVolume::GetPuppetInfo(int32 Index_0, struct FKosmosPuppetEncounterAgents* OutPuppetData)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "GetPuppetInfo");

	Params::KosmosPuppetEncounterVolume_GetPuppetInfo Parms{};

	Parms.Index_0 = Index_0;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPuppetData != nullptr)
		*OutPuppetData = std::move(Parms.OutPuppetData);
}


// Function Kosmos.KosmosPuppetEncounterVolume.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPuppetEncounterVolume::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "HandleResume");

	Params::KosmosPuppetEncounterVolume_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPuppetEncounterVolume::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "HandleSnapshot");

	Params::KosmosPuppetEncounterVolume_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.IsZoneSafe
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// const struct FVector&                   Location                                               (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::IsZoneSafe(const struct FVector& Location)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "IsZoneSafe");

	Params::KosmosPuppetEncounterVolume_IsZoneSafe Parms{};

	Parms.Location = std::move(Location);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.OnNullAreaUpdated
// (Final, Native, Protected)
// Parameters:
// class FName                             EditAreaName                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class FName                             DebugShapeName                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPuppetEncounterVolume::OnNullAreaUpdated(class FName EditAreaName, class FName DebugShapeName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "OnNullAreaUpdated");

	Params::KosmosPuppetEncounterVolume_OnNullAreaUpdated Parms{};

	Parms.EditAreaName = EditAreaName;
	Parms.DebugShapeName = DebugShapeName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.PuppetSpawn
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// class ACharacter*                       Puppet                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   SpawnPoint                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   SpawnTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosPuppetEncounterVolume::PuppetSpawn(class ACharacter* Puppet, const struct FVector& SpawnPoint, float SpawnTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "PuppetSpawn");

	Params::KosmosPuppetEncounterVolume_PuppetSpawn Parms{};

	Parms.Puppet = Puppet;
	Parms.SpawnPoint = std::move(SpawnPoint);
	Parms.SpawnTime = SpawnTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.ResetEncounter
// (Final, Native, Public, BlueprintCallable)

void AKosmosPuppetEncounterVolume::ResetEncounter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "ResetEncounter");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosPuppetEncounterVolume.AllHeadlessPuppetsAreTargeting
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           PuppetsTarget                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::AllHeadlessPuppetsAreTargeting(class AActor* PuppetsTarget) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "AllHeadlessPuppetsAreTargeting");

	Params::KosmosPuppetEncounterVolume_AllHeadlessPuppetsAreTargeting Parms{};

	Parms.PuppetsTarget = PuppetsTarget;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.FindPath
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const struct FVector&                   From                                                   (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   To                                                     (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<struct FVector>*                 OutPathPoints                                          (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::FindPath(const struct FVector& From, const struct FVector& To, TArray<struct FVector>* OutPathPoints) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "FindPath");

	Params::KosmosPuppetEncounterVolume_FindPath Parms{};

	Parms.From = std::move(From);
	Parms.To = std::move(To);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutPathPoints != nullptr)
		*OutPathPoints = std::move(Parms.OutPathPoints);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.GetAlertedPuppetWithHead
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosPuppetEncounterVolume::GetAlertedPuppetWithHead() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "GetAlertedPuppetWithHead");

	Params::KosmosPuppetEncounterVolume_GetAlertedPuppetWithHead Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.GetHeadlessPuppet
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosPuppetEncounterVolume::GetHeadlessPuppet() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "GetHeadlessPuppet");

	Params::KosmosPuppetEncounterVolume_GetHeadlessPuppet Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.HasBeenAlertedTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class AActor*                           Puppet                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   MinTime                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::HasBeenAlertedTime(class AActor* Puppet, float MinTime) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "HasBeenAlertedTime");

	Params::KosmosPuppetEncounterVolume_HasBeenAlertedTime Parms{};

	Parms.Puppet = Puppet;
	Parms.MinTime = MinTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.HasHeadlessPuppets
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::HasHeadlessPuppets() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "HasHeadlessPuppets");

	Params::KosmosPuppetEncounterVolume_HasHeadlessPuppets Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.IsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::IsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "IsEnabled");

	Params::KosmosPuppetEncounterVolume_IsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosPuppetEncounterVolume.IsEncounterAlerted
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosPuppetEncounterVolume::IsEncounterAlerted() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosPuppetEncounterVolume", "IsEncounterAlerted");

	Params::KosmosPuppetEncounterVolume_IsEncounterAlerted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQuicksand.CharacterEndSinking
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::CharacterEndSinking(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "CharacterEndSinking");

	Params::KosmosQuicksand_CharacterEndSinking Parms{};

	Parms.InCharacter = InCharacter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosQuicksand.CharacterIsSinking
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             Progress                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::CharacterIsSinking(class AKosmosBaseCharacter* InCharacter, const float Progress)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "CharacterIsSinking");

	Params::KosmosQuicksand_CharacterIsSinking Parms{};

	Parms.InCharacter = InCharacter;
	Parms.Progress = Progress;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosQuicksand.CharacterStartSinking
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::CharacterStartSinking(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "CharacterStartSinking");

	Params::KosmosQuicksand_CharacterStartSinking Parms{};

	Parms.InCharacter = InCharacter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosQuicksand.GetSinkingProgress
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// const class AKosmosBaseCharacter*       InCharacter                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosQuicksand::GetSinkingProgress(const class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "GetSinkingProgress");

	Params::KosmosQuicksand_GetSinkingProgress Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosQuicksand.KillPlayer
// (Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::KillPlayer(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "KillPlayer");

	Params::KosmosQuicksand_KillPlayer Parms{};

	Parms.InCharacter = InCharacter;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosQuicksand.NotifyBeginOverlap
// (Native, Protected, HasOutParams, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosQuicksand::NotifyBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "NotifyBeginOverlap");

	Params::KosmosQuicksand_NotifyBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQuicksand.NotifyEndOverlap
// (Native, Protected, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::NotifyEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "NotifyEndOverlap");

	Params::KosmosQuicksand_NotifyEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosQuicksand.NotifyOnLanded
// (Native, Protected, HasOutParams)
// Parameters:
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosQuicksand::NotifyOnLanded(const struct FHitResult& Hit, class AKosmosBaseCharacter* Character)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosQuicksand", "NotifyOnLanded");

	Params::KosmosQuicksand_NotifyOnLanded Parms{};

	Parms.Hit = std::move(Hit);
	Parms.Character = Character;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.CheckpointResumeBP
// (Event, Protected, BlueprintEvent)
// Parameters:
// const bool                              IsCompleted                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::CheckpointResumeBP(const bool IsCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "CheckpointResumeBP");

	Params::KosmosRetractable_CheckpointResumeBP Parms{};

	Parms.IsCompleted = IsCompleted;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosRetractable.HandleResume
// (Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "HandleResume");

	Params::KosmosRetractable_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.HandleSnapshot
// (Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "HandleSnapshot");

	Params::KosmosRetractable_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.Multicast_CheckpointResume
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const bool                              IsCompleted                                            (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::Multicast_CheckpointResume(const bool IsCompleted)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "Multicast_CheckpointResume");

	Params::KosmosRetractable_Multicast_CheckpointResume Parms{};

	Parms.IsCompleted = IsCompleted;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.OnHangable2EndGrabEvent
// (Native, Protected)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::OnHangable2EndGrabEvent(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "OnHangable2EndGrabEvent");

	Params::KosmosRetractable_OnHangable2EndGrabEvent Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.OnHangable2StartGrabEvent
// (Native, Protected)
// Parameters:
// class UKosmosHangableComponent*         hangable                                               (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UKosmosBaseGrabberInterface*grabber                                                (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRetractable::OnHangable2StartGrabEvent(class UKosmosHangableComponent* hangable, const class UKosmosBaseGrabberInterface* grabber)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "OnHangable2StartGrabEvent");

	Params::KosmosRetractable_OnHangable2StartGrabEvent Parms{};

	Parms.hangable = hangable;
	Parms.grabber = grabber;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRetractable.PlayTimeline
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosRetractable::PlayTimeline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "PlayTimeline");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosRetractable.ResetTimeline
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosRetractable::ResetTimeline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "ResetTimeline");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosRetractable.ReverseTimeline
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosRetractable::ReverseTimeline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "ReverseTimeline");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosRetractable.StopTimeline
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosRetractable::StopTimeline()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRetractable", "StopTimeline");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosRoomComponent.GetKosmosRoom
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UKosmosRoom*                      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UKosmosRoom* UKosmosRoomComponent::GetKosmosRoom() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomComponent", "GetKosmosRoom");

	Params::KosmosRoomComponent_GetKosmosRoom Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoomComponent.IsRoomLoaded
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosRoomComponent::IsRoomLoaded() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomComponent", "IsRoomLoaded");

	Params::KosmosRoomComponent_IsRoomLoaded Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoomCondition.FilterConnectivity
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UKosmosRoom*>&       InRooms                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UKosmosRoom*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UKosmosRoom*> UKosmosRoomCondition::FilterConnectivity(const class UObject* WorldContextObject, const TArray<class UKosmosRoom*>& InRooms) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomCondition", "FilterConnectivity");

	Params::KosmosRoomCondition_FilterConnectivity Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRooms = std::move(InRooms);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoomCondition.FilterNavigation
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UKosmosRoom*>&       InRooms                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UKosmosRoom*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UKosmosRoom*> UKosmosRoomCondition::FilterNavigation(const class UObject* WorldContextObject, const TArray<class UKosmosRoom*>& InRooms) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomCondition", "FilterNavigation");

	Params::KosmosRoomCondition_FilterNavigation Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRooms = std::move(InRooms);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoomCondition.FilterVisibility
// (Native, Event, Public, HasOutParams, BlueprintEvent, Const)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const TArray<class UKosmosRoom*>&       InRooms                                                (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<class UKosmosRoom*>              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UKosmosRoom*> UKosmosRoomCondition::FilterVisibility(const class UObject* WorldContextObject, const TArray<class UKosmosRoom*>& InRooms) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomCondition", "FilterVisibility");

	Params::KosmosRoomCondition_FilterVisibility Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.InRooms = std::move(InRooms);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosRoomStreamingVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRoomStreamingVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomStreamingVolume", "SetBounds");

	Params::KosmosRoomStreamingVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosRoomStreamingVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosRoomStreamingVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosRoomStreamingVolume", "SetBoxExtent");

	Params::KosmosRoomStreamingVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveGameBackgroundService.WaitForPendingSaveActions
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    WorldContextObject                                     (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FLatentActionInfo&         LatentInfo                                             (Parm, NoDestructor, NativeAccessSpecifierPublic)

void UKosmosSaveGameBackgroundService::WaitForPendingSaveActions(const class UObject* WorldContextObject, const struct FLatentActionInfo& LatentInfo)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveGameBackgroundService", "WaitForPendingSaveActions");

	Params::KosmosSaveGameBackgroundService_WaitForPendingSaveActions Parms{};

	Parms.WorldContextObject = WorldContextObject;
	Parms.LatentInfo = std::move(LatentInfo);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_AcceptedDataProtection
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_AcceptedDataProtection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_AcceptedDataProtection");

	Params::KosmosSaveDataKeys_SavesKey_AcceptedDataProtection Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_AcceptedEULA
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_AcceptedEULA()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_AcceptedEULA");

	Params::KosmosSaveDataKeys_SavesKey_AcceptedEULA Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Accessibility_DyslexicFont
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Accessibility_DyslexicFont()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Accessibility_DyslexicFont");

	Params::KosmosSaveDataKeys_SavesKey_Accessibility_DyslexicFont Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Accessibility_PlatformButtons
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Accessibility_PlatformButtons()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Accessibility_PlatformButtons");

	Params::KosmosSaveDataKeys_SavesKey_Accessibility_PlatformButtons Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Accessibility_TutorialBackgroundAlpha
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Accessibility_TutorialBackgroundAlpha()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Accessibility_TutorialBackgroundAlpha");

	Params::KosmosSaveDataKeys_SavesKey_Accessibility_TutorialBackgroundAlpha Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Accessibility_TutorialTextSizeScalar
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Accessibility_TutorialTextSizeScalar()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Accessibility_TutorialTextSizeScalar");

	Params::KosmosSaveDataKeys_SavesKey_Accessibility_TutorialTextSizeScalar Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_AmbientOcclusionQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_AmbientOcclusionQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_AmbientOcclusionQuality");

	Params::KosmosSaveDataKeys_SavesKey_AmbientOcclusionQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_AntiAliasingQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_AntiAliasingQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_AntiAliasingQuality");

	Params::KosmosSaveDataKeys_SavesKey_AntiAliasingQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_AppliedFirstTimeDefaultSettings
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_AppliedFirstTimeDefaultSettings()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_AppliedFirstTimeDefaultSettings");

	Params::KosmosSaveDataKeys_SavesKey_AppliedFirstTimeDefaultSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_BloomQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_BloomQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_BloomQuality");

	Params::KosmosSaveDataKeys_SavesKey_BloomQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_DepthOfFieldQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_DepthOfFieldQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_DepthOfFieldQuality");

	Params::KosmosSaveDataKeys_SavesKey_DepthOfFieldQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_EffectsQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_EffectsQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_EffectsQuality");

	Params::KosmosSaveDataKeys_SavesKey_EffectsQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_FrontendLeveltoShow
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_FrontendLeveltoShow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_FrontendLeveltoShow");

	Params::KosmosSaveDataKeys_SavesKey_FrontendLeveltoShow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_LastUsedSaveSlotName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_LastUsedSaveSlotName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_LastUsedSaveSlotName");

	Params::KosmosSaveDataKeys_SavesKey_LastUsedSaveSlotName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_MasterAudioVolume
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_MasterAudioVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_MasterAudioVolume");

	Params::KosmosSaveDataKeys_SavesKey_MasterAudioVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_NumTimesGameComplete
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_NumTimesGameComplete()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_NumTimesGameComplete");

	Params::KosmosSaveDataKeys_SavesKey_NumTimesGameComplete Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_PCFirstTimeLaunch
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_PCFirstTimeLaunch()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_PCFirstTimeLaunch");

	Params::KosmosSaveDataKeys_SavesKey_PCFirstTimeLaunch Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_PostProcessingQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_PostProcessingQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_PostProcessingQuality");

	Params::KosmosSaveDataKeys_SavesKey_PostProcessingQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_QualityBeautyMode
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_QualityBeautyMode()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_QualityBeautyMode");

	Params::KosmosSaveDataKeys_SavesKey_QualityBeautyMode Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_RayTracingQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_RayTracingQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_RayTracingQuality");

	Params::KosmosSaveDataKeys_SavesKey_RayTracingQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_SelectedDisplay
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_SelectedDisplay()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_SelectedDisplay");

	Params::KosmosSaveDataKeys_SavesKey_SelectedDisplay Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_ShadowQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_ShadowQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_ShadowQuality");

	Params::KosmosSaveDataKeys_SavesKey_ShadowQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Telemetry_TimeStartChapter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Telemetry_TimeStartChapter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Telemetry_TimeStartChapter");

	Params::KosmosSaveDataKeys_SavesKey_Telemetry_TimeStartChapter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Telemetry_TimeStartCheckpoint
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Telemetry_TimeStartCheckpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Telemetry_TimeStartCheckpoint");

	Params::KosmosSaveDataKeys_SavesKey_Telemetry_TimeStartCheckpoint Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Telemetry_TimeSwapCostume
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Telemetry_TimeSwapCostume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Telemetry_TimeSwapCostume");

	Params::KosmosSaveDataKeys_SavesKey_Telemetry_TimeSwapCostume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Telemetry_TimeTotalSlotTime
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Telemetry_TimeTotalSlotTime()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Telemetry_TimeTotalSlotTime");

	Params::KosmosSaveDataKeys_SavesKey_Telemetry_TimeTotalSlotTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_TextureQuality
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_TextureQuality()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_TextureQuality");

	Params::KosmosSaveDataKeys_SavesKey_TextureQuality Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_AcceptedInvite
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_AcceptedInvite()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_AcceptedInvite");

	Params::KosmosSaveDataKeys_SavesKey_Transient_AcceptedInvite Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_CreatingSession
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_CreatingSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_CreatingSession");

	Params::KosmosSaveDataKeys_SavesKey_Transient_CreatingSession Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_CurrentChapterIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_CurrentChapterIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_CurrentChapterIndex");

	Params::KosmosSaveDataKeys_SavesKey_Transient_CurrentChapterIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_CurrentChapterName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_CurrentChapterName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_CurrentChapterName");

	Params::KosmosSaveDataKeys_SavesKey_Transient_CurrentChapterName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_CurrentDlcSelectedIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_CurrentDlcSelectedIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_CurrentDlcSelectedIndex");

	Params::KosmosSaveDataKeys_SavesKey_Transient_CurrentDlcSelectedIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_DebugLevelName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_DebugLevelName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_DebugLevelName");

	Params::KosmosSaveDataKeys_SavesKey_Transient_DebugLevelName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_ErrorOccured
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_ErrorOccured()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_ErrorOccured");

	Params::KosmosSaveDataKeys_SavesKey_Transient_ErrorOccured Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_FailedToJoinSession
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_FailedToJoinSession()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_FailedToJoinSession");

	Params::KosmosSaveDataKeys_SavesKey_Transient_FailedToJoinSession Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_FrontendWearableCharacter
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_FrontendWearableCharacter()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_FrontendWearableCharacter");

	Params::KosmosSaveDataKeys_SavesKey_Transient_FrontendWearableCharacter Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_HasEnteredLobby
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_HasEnteredLobby()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_HasEnteredLobby");

	Params::KosmosSaveDataKeys_SavesKey_Transient_HasEnteredLobby Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_HasJustFinishedTrial
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_HasJustFinishedTrial()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_HasJustFinishedTrial");

	Params::KosmosSaveDataKeys_SavesKey_Transient_HasJustFinishedTrial Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_InitialUserSelected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_InitialUserSelected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_InitialUserSelected");

	Params::KosmosSaveDataKeys_SavesKey_Transient_InitialUserSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsBothPlayersReady
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsBothPlayersReady()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsBothPlayersReady");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsBothPlayersReady Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsChapterSelected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsChapterSelected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsChapterSelected");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsChapterSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsControllerDisconnected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsControllerDisconnected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsControllerDisconnected");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsControllerDisconnected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsLobbyFull
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsLobbyFull()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsLobbyFull");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsLobbyFull Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsPlaythroughSelected
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsPlaythroughSelected()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsPlaythroughSelected");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsPlaythroughSelected Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_IsRestartCheckpointDisabled
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_IsRestartCheckpointDisabled()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_IsRestartCheckpointDisabled");

	Params::KosmosSaveDataKeys_SavesKey_Transient_IsRestartCheckpointDisabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_JustAcceptedInvite
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_JustAcceptedInvite()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_JustAcceptedInvite");

	Params::KosmosSaveDataKeys_SavesKey_Transient_JustAcceptedInvite Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_LocalUserName
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_LocalUserName()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_LocalUserName");

	Params::KosmosSaveDataKeys_SavesKey_Transient_LocalUserName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_SavePlaythroughType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_SavePlaythroughType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_SavePlaythroughType");

	Params::KosmosSaveDataKeys_SavesKey_Transient_SavePlaythroughType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_SelectedGameplayType
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_SelectedGameplayType()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_SelectedGameplayType");

	Params::KosmosSaveDataKeys_SavesKey_Transient_SelectedGameplayType Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_SelectedSaveSlotIndex
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_SelectedSaveSlotIndex()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_SelectedSaveSlotIndex");

	Params::KosmosSaveDataKeys_SavesKey_Transient_SelectedSaveSlotIndex Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_Transient_SessionCreatedSuccessfully
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_Transient_SessionCreatedSuccessfully()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_Transient_SessionCreatedSuccessfully");

	Params::KosmosSaveDataKeys_SavesKey_Transient_SessionCreatedSuccessfully Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_UserGamma
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_UserGamma()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_UserGamma");

	Params::KosmosSaveDataKeys_SavesKey_UserGamma Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSaveDataKeys.SavesKey_UserLanguage
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UKosmosSaveDataKeys::SavesKey_UserLanguage()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("KosmosSaveDataKeys", "SavesKey_UserLanguage");

	Params::KosmosSaveDataKeys_SavesKey_UserLanguage Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSavingHUDWidget.EventSaveFinished
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosSavingHUDWidget::EventSaveFinished()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSavingHUDWidget", "EventSaveFinished");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSavingHUDWidget.EventSaveStarted
// (Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosSavingHUDWidget::EventSaveStarted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSavingHUDWidget", "EventSaveStarted");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSceneSequencePlayer.SetPlaybackPositionAndResetVelocity
// (Final, Native, Private, BlueprintCallable)
// Parameters:
// const struct FMovieSceneSequencePlaybackParams&PlaybackParams                                         (Parm, NativeAccessSpecifierPublic)

void UKosmosSceneSequencePlayer::SetPlaybackPositionAndResetVelocity(const struct FMovieSceneSequencePlaybackParams& PlaybackParams)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSceneSequencePlayer", "SetPlaybackPositionAndResetVelocity");

	Params::KosmosSceneSequencePlayer_SetPlaybackPositionAndResetVelocity Parms{};

	Parms.PlaybackParams = std::move(PlaybackParams);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.AdjustSliderValue
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// const float                             inNewValueAdjustment                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlider::AdjustSliderValue(const float inNewValueAdjustment)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "AdjustSliderValue");

	Params::KosmosSlider_AdjustSliderValue Parms{};

	Parms.inNewValueAdjustment = inNewValueAdjustment;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.ClearCurrentInput
// (Final, Native, Public, BlueprintCallable)

void UKosmosSlider::ClearCurrentInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "ClearCurrentInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.ConvertRatio_RangeValueToSliderValue
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSlider::ConvertRatio_RangeValueToSliderValue(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "ConvertRatio_RangeValueToSliderValue");

	Params::KosmosSlider_ConvertRatio_RangeValueToSliderValue Parms{};

	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSlider.ConvertRatio_SliderValueToRangeValue
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// float                                   inValue                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSlider::ConvertRatio_SliderValueToRangeValue(float inValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "ConvertRatio_SliderValueToRangeValue");

	Params::KosmosSlider_ConvertRatio_SliderValueToRangeValue Parms{};

	Parms.inValue = inValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSlider.GetAxis
// (Event, Protected, HasOutParams, BlueprintEvent)
// Parameters:
// const class FName&                      InAxisName                                             (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSlider::GetAxis(const class FName& InAxisName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "GetAxis");

	Params::KosmosSlider_GetAxis Parms{};

	Parms.InAxisName = InAxisName;

	UObject::ProcessEvent(Func, &Parms);

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosSlider.OnButtonHovered
// (Event, Public, BlueprintEvent)

void UKosmosSlider::OnButtonHovered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonHovered");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSlider.OnButtonHovered_Internal
// (Native, Public, BlueprintCallable)

void UKosmosSlider::OnButtonHovered_Internal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonHovered_Internal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.OnButtonPressed
// (Event, Public, BlueprintEvent)

void UKosmosSlider::OnButtonPressed()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonPressed");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSlider.OnButtonPressed_Internal
// (Native, Public, BlueprintCallable)

void UKosmosSlider::OnButtonPressed_Internal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonPressed_Internal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.OnButtonUnhovered
// (Event, Public, BlueprintEvent)

void UKosmosSlider::OnButtonUnhovered()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonUnhovered");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSlider.OnButtonUnhovered_Internal
// (Native, Public, BlueprintCallable)

void UKosmosSlider::OnButtonUnhovered_Internal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnButtonUnhovered_Internal");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.OnSliderValueChanged
// (Event, Protected, BlueprintEvent)
// Parameters:
// const float                             inNewValue                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlider::OnSliderValueChanged(const float inNewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnSliderValueChanged");

	Params::KosmosSlider_OnSliderValueChanged Parms{};

	Parms.inNewValue = inNewValue;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosSlider.OnSliderValueChanged_Internal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// const float                             inNewValue                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlider::OnSliderValueChanged_Internal(const float inNewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "OnSliderValueChanged_Internal");

	Params::KosmosSlider_OnSliderValueChanged_Internal Parms{};

	Parms.inNewValue = inNewValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.SetSliderValue
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
// Parameters:
// const float                             inNewValue                                             (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosSlider::SetSliderValue(const float inNewValue)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "SetSliderValue");

	Params::KosmosSlider_SetSliderValue Parms{};

	Parms.inNewValue = inNewValue;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSlider.GetSliderValue
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float UKosmosSlider::GetSliderValue() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSlider", "GetSliderValue");

	Params::KosmosSlider_GetSliderValue Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosStrafingComponent.OnWeaponAnimNotify
// (Final, Native, Public, HasOutParams)
// Parameters:
// const struct FFlowControlAnimNotifyData&AnimNotify                                             (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosStrafingComponent::OnWeaponAnimNotify(const struct FFlowControlAnimNotifyData& AnimNotify)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStrafingComponent", "OnWeaponAnimNotify");

	Params::KosmosStrafingComponent_OnWeaponAnimNotify Parms{};

	Parms.AnimNotify = std::move(AnimNotify);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosStrafingComponent.StartStrafing
// (Final, Native, Protected, BlueprintCallable)

void UKosmosStrafingComponent::StartStrafing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStrafingComponent", "StartStrafing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosStrafingComponent.StopStrafing
// (Final, Native, Protected, BlueprintCallable)

void UKosmosStrafingComponent::StopStrafing()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStrafingComponent", "StopStrafing");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosStumbleComponent.OnLimbColliderHit
// (Final, Native, Protected, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   NormalImpulse                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void UKosmosStumbleComponent::OnLimbColliderHit(class UPrimitiveComponent* HitComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStumbleComponent", "OnLimbColliderHit");

	Params::KosmosStumbleComponent_OnLimbColliderHit Parms{};

	Parms.HitComponent = HitComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.NormalImpulse = std::move(NormalImpulse);
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosStumbleComponent.Server_ApplyAnimationOverride
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UKosmosStumbleComponent::Server_ApplyAnimationOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStumbleComponent", "Server_ApplyAnimationOverride");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosStumbleComponent.Server_ClearAnimationOverride
// (Final, Net, NetReliable, Native, Event, Private, NetServer)

void UKosmosStumbleComponent::Server_ClearAnimationOverride()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosStumbleComponent", "Server_ClearAnimationOverride");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSunburnVolume.OnVolumeBeginOverlap
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bFromSweep                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                SweepResult                                            (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosSunburnVolume::OnVolumeBeginOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSunburnVolume", "OnVolumeBeginOverlap");

	Params::KosmosSunburnVolume_OnVolumeBeginOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.bFromSweep = bFromSweep;
	Parms.SweepResult = std::move(SweepResult);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSunburnVolume.OnVolumeEndOverlap
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              OverlappedComponent                                    (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosSunburnVolume::OnVolumeEndOverlap(class UPrimitiveComponent* OverlappedComponent, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSunburnVolume", "OnVolumeEndOverlap");

	Params::KosmosSunburnVolume_OnVolumeEndOverlap Parms{};

	Parms.OverlappedComponent = OverlappedComponent;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosSwimComponent.DiveDown
// (Event, Public, BlueprintEvent)

void UKosmosSwimComponent::DiveDown()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwimComponent", "DiveDown");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSwimComponent.StartSwimming
// (Event, Public, BlueprintEvent)

void UKosmosSwimComponent::StartSwimming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwimComponent", "StartSwimming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSwimComponent.StopSwimming
// (Event, Public, BlueprintEvent)

void UKosmosSwimComponent::StopSwimming()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwimComponent", "StopSwimming");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosSwimComponent.TakeBreath
// (Event, Public, BlueprintEvent)

void UKosmosSwimComponent::TakeBreath()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosSwimComponent", "TakeBreath");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosTargetComponent.Disable
// (Final, Native, Public, BlueprintCallable)

void UKosmosTargetComponent::Disable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTargetComponent", "Disable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTargetComponent.Enable
// (Final, Native, Public, BlueprintCallable)

void UKosmosTargetComponent::Enable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTargetComponent", "Enable");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTargetComponent.GetPrecisePosition
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FVector                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

struct FVector UKosmosTargetComponent::GetPrecisePosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTargetComponent", "GetPrecisePosition");

	Params::KosmosTargetComponent_GetPrecisePosition Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosTargetComponent.GetPreciseRotation
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
// Parameters:
// struct FRotator                         ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)

struct FRotator UKosmosTargetComponent::GetPreciseRotation()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTargetComponent", "GetPreciseRotation");

	Params::KosmosTargetComponent_GetPreciseRotation Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosThrowPrepareVolume.BeginOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosThrowPrepareVolume::BeginOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosThrowPrepareVolume", "BeginOverlap");

	Params::KosmosThrowPrepareVolume_BeginOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosThrowPrepareVolume.EndOverlap
// (Final, Native, Public)
// Parameters:
// class AActor*                           OverlappedActor                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosThrowPrepareVolume::EndOverlap(class AActor* OverlappedActor, class AActor* OtherActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosThrowPrepareVolume", "EndOverlap");

	Params::KosmosThrowPrepareVolume_EndOverlap Parms{};

	Parms.OverlappedActor = OverlappedActor;
	Parms.OtherActor = OtherActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosThrowPrepareVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosThrowPrepareVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosThrowPrepareVolume", "SetBounds");

	Params::KosmosThrowPrepareVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosThrowPrepareVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosThrowPrepareVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosThrowPrepareVolume", "SetBoxExtent");

	Params::KosmosThrowPrepareVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.CheckButtonMappings
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const TArray<struct FSMGMappingReference>&ButtonMapping                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// TArray<struct FSMGMappingReference>     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<struct FSMGMappingReference> AKosmosTutorialTrigger::CheckButtonMappings(const TArray<struct FSMGMappingReference>& ButtonMapping)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "CheckButtonMappings");

	Params::KosmosTutorialTrigger_CheckButtonMappings Parms{};

	Parms.ButtonMapping = std::move(ButtonMapping);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosTutorialTrigger.Client_HandleResume
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// bool                                    hasBeenTriggered                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::Client_HandleResume(bool hasBeenTriggered)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "Client_HandleResume");

	Params::KosmosTutorialTrigger_Client_HandleResume Parms{};

	Parms.hasBeenTriggered = hasBeenTriggered;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.ForceTriggerTutorial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::ForceTriggerTutorial(class APawn* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "ForceTriggerTutorial");

	Params::KosmosTutorialTrigger_ForceTriggerTutorial Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.HandleResume
// (Final, Native, Public)
// Parameters:
// class UKosmosCheckpointReader*          InCheckpointReader                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::HandleResume(class UKosmosCheckpointReader* InCheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "HandleResume");

	Params::KosmosTutorialTrigger_HandleResume Parms{};

	Parms.InCheckpointReader = InCheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.HandleSnapshot
// (Final, Native, Public)
// Parameters:
// class UKosmosCheckpointWriter*          InCheckpointWriter                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::HandleSnapshot(class UKosmosCheckpointWriter* InCheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "HandleSnapshot");

	Params::KosmosTutorialTrigger_HandleSnapshot Parms{};

	Parms.InCheckpointWriter = InCheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.ResetTrigger
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    FastFadeOut                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::ResetTrigger(bool FastFadeOut)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "ResetTrigger");

	Params::KosmosTutorialTrigger_ResetTrigger Parms{};

	Parms.FastFadeOut = FastFadeOut;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.StopTutorial
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class APawn*                            InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    FastFadeOut                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::StopTutorial(class APawn* InCharacter, bool FastFadeOut)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "StopTutorial");

	Params::KosmosTutorialTrigger_StopTutorial Parms{};

	Parms.InCharacter = InCharacter;
	Parms.FastFadeOut = FastFadeOut;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosTutorialTrigger.TriggerTutorial
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class APawn*                            InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      TutorialText                                           (Parm, NativeAccessSpecifierPublic)
// const TArray<struct FSMGMappingReference>&ButtonMapping                                          (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    bIsKeyAxisNegativeValue                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   TimeBeforeTutorialPlays                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    IgnoreTimeout                                          (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// float                                   Timeout                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FText&                      InToggleModeTutorialText                               (Parm, NativeAccessSpecifierPublic)

void AKosmosTutorialTrigger::TriggerTutorial(class APawn* InCharacter, const class FText& TutorialText, const TArray<struct FSMGMappingReference>& ButtonMapping, bool bIsKeyAxisNegativeValue, float TimeBeforeTutorialPlays, bool IgnoreTimeout, float Timeout, const class FText& InToggleModeTutorialText)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosTutorialTrigger", "TriggerTutorial");

	Params::KosmosTutorialTrigger_TriggerTutorial Parms{};

	Parms.InCharacter = InCharacter;
	Parms.TutorialText = std::move(TutorialText);
	Parms.ButtonMapping = std::move(ButtonMapping);
	Parms.bIsKeyAxisNegativeValue = bIsKeyAxisNegativeValue;
	Parms.TimeBeforeTutorialPlays = TimeBeforeTutorialPlays;
	Parms.IgnoreTimeout = IgnoreTimeout;
	Parms.Timeout = Timeout;
	Parms.InToggleModeTutorialText = std::move(InToggleModeTutorialText);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUISettingsSection.ClearWidgetInput
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosUISettingsSection::ClearWidgetInput()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsSection", "ClearWidgetInput");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUISettingsSection.ResetWidgetValues
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosUISettingsSection::ResetWidgetValues()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsSection", "ResetWidgetValues");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUISettingsSection.SectionUpdateValues
// (Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const struct FKosmosSaveDataValues&     SaveDataValues                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUISettingsSection::SectionUpdateValues(const struct FKosmosSaveDataValues& SaveDataValues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsSection", "SectionUpdateValues");

	Params::KosmosUISettingsSection_SectionUpdateValues Parms{};

	Parms.SaveDataValues = std::move(SaveDataValues);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUISettingsSection.StoreWidgetValues
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void UKosmosUISettingsSection::StoreWidgetValues()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsSection", "StoreWidgetValues");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUISettingsWidget.UpdateExtraSettings
// (Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FKosmosSaveDataValues&     SaveDataValues                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosUISettingsWidget::UpdateExtraSettings(const struct FKosmosSaveDataValues& SaveDataValues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsWidget", "UpdateExtraSettings");

	Params::KosmosUISettingsWidget_UpdateExtraSettings Parms{};

	Parms.SaveDataValues = std::move(SaveDataValues);

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosUISettingsWidget.UpdateInitialSettingsToCurrent
// (Native, Public, BlueprintCallable)

void UKosmosUISettingsWidget::UpdateInitialSettingsToCurrent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsWidget", "UpdateInitialSettingsToCurrent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUISettingsWidget.UpdateSectionsValues
// (Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const struct FKosmosSaveDataValues&     SaveDataValues                                         (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)

void UKosmosUISettingsWidget::UpdateSectionsValues(const struct FKosmosSaveDataValues& SaveDataValues)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUISettingsWidget", "UpdateSectionsValues");

	Params::KosmosUISettingsWidget_UpdateSectionsValues Parms{};

	Parms.SaveDataValues = std::move(SaveDataValues);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrella.ChangeUmbrellaState
// (Final, Native, Protected, BlueprintCallable)
// Parameters:
// EUmbrellaState                          NewState                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrella::ChangeUmbrellaState(EUmbrellaState NewState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "ChangeUmbrellaState");

	Params::KosmosUmbrella_ChangeUmbrellaState Parms{};

	Parms.NewState = NewState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrella.ClosedUmbrella
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bInWind                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrella::ClosedUmbrella(const bool bInWind)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "ClosedUmbrella");

	Params::KosmosUmbrella_ClosedUmbrella Parms{};

	Parms.bInWind = bInWind;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosUmbrella.FinishedGliding
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosUmbrella::FinishedGliding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "FinishedGliding");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosUmbrella.FinishedGlidingInActiveWind
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosUmbrella::FinishedGlidingInActiveWind()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "FinishedGlidingInActiveWind");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosUmbrella.GetState
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// EUmbrellaState                          ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EUmbrellaState AKosmosUmbrella::GetState()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "GetState");

	Params::KosmosUmbrella_GetState Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUmbrella.IsInActiveWindVolume
// (Final, Native, Protected, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosUmbrella::IsInActiveWindVolume()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "IsInActiveWindVolume");

	Params::KosmosUmbrella_IsInActiveWindVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUmbrella.OpenedUmbrella
// (Event, Protected, BlueprintCallable, BlueprintEvent)
// Parameters:
// const bool                              bInWind                                                (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrella::OpenedUmbrella(const bool bInWind)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "OpenedUmbrella");

	Params::KosmosUmbrella_OpenedUmbrella Parms{};

	Parms.bInWind = bInWind;

	UObject::ProcessEvent(Func, &Parms);
}


// Function Kosmos.KosmosUmbrella.StartedGliding
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosUmbrella::StartedGliding()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "StartedGliding");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosUmbrella.StartedGlidingInActiveWind
// (Event, Protected, BlueprintCallable, BlueprintEvent)

void AKosmosUmbrella::StartedGlidingInActiveWind()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "StartedGlidingInActiveWind");

	UObject::ProcessEvent(Func, nullptr);
}


// Function Kosmos.KosmosUmbrella.StateChanged
// (Final, Native, Protected)
// Parameters:
// const EUmbrellaState                    NewState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EUmbrellaState                    OldState                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrella::StateChanged(const EUmbrellaState NewState, const EUmbrellaState OldState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "StateChanged");

	Params::KosmosUmbrella_StateChanged Parms{};

	Parms.NewState = NewState;
	Parms.OldState = OldState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrella.IsCharacterInAir
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosUmbrella::IsCharacterInAir() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrella", "IsCharacterInAir");

	Params::KosmosUmbrella_IsCharacterInAir Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUmbrellaWindInteractComponent.OnMovementModeChanged
// (Final, Native, Protected)
// Parameters:
// class ACharacter*                       Character                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EMovementMode                           PrevMovementMode                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// uint8                                   PreviousCustomMode                                     (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UKosmosUmbrellaWindInteractComponent::OnMovementModeChanged(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindInteractComponent", "OnMovementModeChanged");

	Params::KosmosUmbrellaWindInteractComponent_OnMovementModeChanged Parms{};

	Parms.Character = Character;
	Parms.PrevMovementMode = PrevMovementMode;
	Parms.PreviousCustomMode = PreviousCustomMode;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindInteractComponent.IsInActiveVolume
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UKosmosUmbrellaWindInteractComponent::IsInActiveVolume() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindInteractComponent", "IsInActiveVolume");

	Params::KosmosUmbrellaWindInteractComponent_IsInActiveVolume Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosUmbrellaWindVolume.CalculateWindDirection
// (Final, Native, Public, BlueprintCallable)

void AKosmosUmbrellaWindVolume::CalculateWindDirection()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "CalculateWindDirection");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.EnterBobbingVolume
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::EnterBobbingVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "EnterBobbingVolume");

	Params::KosmosUmbrellaWindVolume_EnterBobbingVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.EnterWindVolume
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::EnterWindVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "EnterWindVolume");

	Params::KosmosUmbrellaWindVolume_EnterWindVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.ExitBobbingVolume
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::ExitBobbingVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "ExitBobbingVolume");

	Params::KosmosUmbrellaWindVolume_ExitBobbingVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.ExitWindVolume
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::ExitWindVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "ExitWindVolume");

	Params::KosmosUmbrellaWindVolume_ExitWindVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.InvertWind
// (Final, Native, Public, BlueprintCallable)

void AKosmosUmbrellaWindVolume::InvertWind()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "InvertWind");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "SetBounds");

	Params::KosmosUmbrellaWindVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "SetBoxExtent");

	Params::KosmosUmbrellaWindVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::SetEnabled(bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "SetEnabled");

	Params::KosmosUmbrellaWindVolume_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.SetInvertWindPosition
// (Final, Native, Public, BlueprintCallable)

void AKosmosUmbrellaWindVolume::SetInvertWindPosition()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "SetInvertWindPosition");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.SetWindVolumeWidthScale
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// float                                   InScale                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosUmbrellaWindVolume::SetWindVolumeWidthScale(float InScale)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "SetWindVolumeWidthScale");

	Params::KosmosUmbrellaWindVolume_SetWindVolumeWidthScale Parms{};

	Parms.InScale = InScale;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.UpdateInternalBoxes
// (Native, Public, BlueprintCallable)

void AKosmosUmbrellaWindVolume::UpdateInternalBoxes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "UpdateInternalBoxes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosUmbrellaWindVolume.GetIsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosUmbrellaWindVolume::GetIsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosUmbrellaWindVolume", "GetIsEnabled");

	Params::KosmosUmbrellaWindVolume_GetIsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosEditorTickInterface.OnEditorTick
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// float                                   DeltaTime                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosEditorTickInterface::OnEditorTick(float DeltaTime)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosEditorTickInterface", "OnEditorTick");

	Params::KosmosEditorTickInterface_OnEditorTick Parms{};

	Parms.DeltaTime = DeltaTime;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnBowProjectileBeginOverlap
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FKosmosBowProjectilePayload&OutProjectilePayload                                   (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class AKosmosBowProjectile*             Projectile                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnBowProjectileBeginOverlap(const struct FKosmosBowProjectilePayload& OutProjectilePayload, class AKosmosBowProjectile* Projectile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnBowProjectileBeginOverlap");

	Params::KosmosWeaponReactInterface_OnBowProjectileBeginOverlap Parms{};

	Parms.OutProjectilePayload = std::move(OutProjectilePayload);
	Parms.Projectile = Projectile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnBowProjectileHit
// (Native, Event, Public, HasOutParams, BlueprintEvent)
// Parameters:
// const struct FKosmosBowProjectilePayload&OutProjectilePayload                                   (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
// class AKosmosBowProjectile*             Projectile                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnBowProjectileHit(const struct FKosmosBowProjectilePayload& OutProjectilePayload, class AKosmosBowProjectile* Projectile)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnBowProjectileHit");

	Params::KosmosWeaponReactInterface_OnBowProjectileHit Parms{};

	Parms.OutProjectilePayload = std::move(OutProjectilePayload);
	Parms.Projectile = Projectile;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnCarriableWeaponBeginOverlap
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AKosmosCarriable*                 InWeapon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnCarriableWeaponBeginOverlap(class AKosmosCarriable* InWeapon, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnCarriableWeaponBeginOverlap");

	Params::KosmosWeaponReactInterface_OnCarriableWeaponBeginOverlap Parms{};

	Parms.InWeapon = InWeapon;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnCarriableWeaponHit
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AKosmosCarriable*                 InWeapon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnCarriableWeaponHit(class AKosmosCarriable* InWeapon, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnCarriableWeaponHit");

	Params::KosmosWeaponReactInterface_OnCarriableWeaponHit Parms{};

	Parms.InWeapon = InWeapon;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnFlashlightBeginOverlap
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosFlashlight*                InFlashlight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnFlashlightBeginOverlap(class AKosmosFlashlight* InFlashlight, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnFlashlightBeginOverlap");

	Params::KosmosWeaponReactInterface_OnFlashlightBeginOverlap Parms{};

	Parms.InFlashlight = InFlashlight;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnFlashlightEndOverlap
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosFlashlight*                InFlashlight                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnFlashlightEndOverlap(class AKosmosFlashlight* InFlashlight, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnFlashlightEndOverlap");

	Params::KosmosWeaponReactInterface_OnFlashlightEndOverlap Parms{};

	Parms.InFlashlight = InFlashlight;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnFlashlightHit
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosFlashlight*                InWrench                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnFlashlightHit(class AKosmosFlashlight* InWrench, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnFlashlightHit");

	Params::KosmosWeaponReactInterface_OnFlashlightHit Parms{};

	Parms.InWrench = InWrench;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnKnifeBeginOverlap
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosKnife*                     InKnife                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnKnifeBeginOverlap(class AKosmosKnife* InKnife, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnKnifeBeginOverlap");

	Params::KosmosWeaponReactInterface_OnKnifeBeginOverlap Parms{};

	Parms.InKnife = InKnife;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnKnifeHit
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosKnife*                     InKnife                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnKnifeHit(class AKosmosKnife* InKnife, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnKnifeHit");

	Params::KosmosWeaponReactInterface_OnKnifeHit Parms{};

	Parms.InKnife = InKnife;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnWrenchBeginOverlap
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosWrench*                    InWrench                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnWrenchBeginOverlap(class AKosmosWrench* InWrench, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnWrenchBeginOverlap");

	Params::KosmosWeaponReactInterface_OnWrenchBeginOverlap Parms{};

	Parms.InWrench = InWrench;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWeaponReactInterface.OnWrenchHit
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// class AKosmosWrench*                    InWrench                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              HitComponent                                           (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void IKosmosWeaponReactInterface::OnWrenchHit(class AKosmosWrench* InWrench, class UPrimitiveComponent* HitComponent)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = AsUObject()->Class->GetFunction("KosmosWeaponReactInterface", "OnWrenchHit");

	Params::KosmosWeaponReactInterface_OnWrenchHit Parms{};

	Parms.InWrench = InWrench;
	Parms.HitComponent = HitComponent;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	AsUObject()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWorld.ExportToEndpoint
// (Final, Native, Public)

void UKosmosWorld::ExportToEndpoint()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWorld", "ExportToEndpoint");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.CalculateRecoilAnimStartTime
// (Final, Native, Public, HasOutParams, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   ImpactLocation                                         (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::CalculateRecoilAnimStartTime(const struct FVector& ImpactLocation)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "CalculateRecoilAnimStartTime");

	Params::KosmosWrench_CalculateRecoilAnimStartTime Parms{};

	Parms.ImpactLocation = std::move(ImpactLocation);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.GetCurrentInteractable
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AActor*                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AActor* AKosmosWrench::GetCurrentInteractable()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "GetCurrentInteractable");

	Params::KosmosWrench_GetCurrentInteractable Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWrench.Multicast_SetWrenchUsageState
// (Net, NetReliable, Native, Event, NetMulticast, Public)
// Parameters:
// EWrenchUsage                            InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::Multicast_SetWrenchUsageState(EWrenchUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "Multicast_SetWrenchUsageState");

	Params::KosmosWrench_Multicast_SetWrenchUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.OnHit
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosWrench::OnHit(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "OnHit");

	Params::KosmosWrench_OnHit Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.Server_SetWrenchUsageState
// (Net, NetReliable, Native, Event, Public, NetServer)
// Parameters:
// EWrenchUsage                            InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::Server_SetWrenchUsageState(EWrenchUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "Server_SetWrenchUsageState");

	Params::KosmosWrench_Server_SetWrenchUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.SetCurrentInteractable
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// class AActor*                           InActor                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::SetCurrentInteractable(class AActor* InActor)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "SetCurrentInteractable");

	Params::KosmosWrench_SetCurrentInteractable Parms{};

	Parms.InActor = InActor;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.SetWrenchUsageState
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWrenchUsage                            InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::SetWrenchUsageState(EWrenchUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "SetWrenchUsageState");

	Params::KosmosWrench_SetWrenchUsageState Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.SetWrenchUsageStateLocal
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// EWrenchUsage                            InState                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrench::SetWrenchUsageStateLocal(EWrenchUsage InState)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "SetWrenchUsageStateLocal");

	Params::KosmosWrench_SetWrenchUsageStateLocal Parms{};

	Parms.InState = InState;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrench.GetRecoilAnimStartTime
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// float                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

float AKosmosWrench::GetRecoilAnimStartTime() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrench", "GetRecoilAnimStartTime");

	Params::KosmosWrench_GetRecoilAnimStartTime Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosWrenchBreakable.Destroy
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)

void AKosmosWrenchBreakable::Destroy()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "Destroy");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.HandleResume
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointReader*          CheckpointReader                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::HandleResume(class UKosmosCheckpointReader* CheckpointReader)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "HandleResume");

	Params::KosmosWrenchBreakable_HandleResume Parms{};

	Parms.CheckpointReader = CheckpointReader;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.HandleSnapshot
// (Final, Native, Protected)
// Parameters:
// class UKosmosCheckpointWriter*          CheckpointWriter                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::HandleSnapshot(class UKosmosCheckpointWriter* CheckpointWriter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "HandleSnapshot");

	Params::KosmosWrenchBreakable_HandleSnapshot Parms{};

	Parms.CheckpointWriter = CheckpointWriter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.Hit
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AActor*                           InWeapon                                               (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::Hit(class AActor* InWeapon)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "Hit");

	Params::KosmosWrenchBreakable_Hit Parms{};

	Parms.InWeapon = InWeapon;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.Multicast_RestoreCheckpoint
// (Net, NetReliable, Native, Event, NetMulticast, Protected)
// Parameters:
// const int32                             Hits                                                   (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::Multicast_RestoreCheckpoint(const int32 Hits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "Multicast_RestoreCheckpoint");

	Params::KosmosWrenchBreakable_Multicast_RestoreCheckpoint Parms{};

	Parms.Hits = Hits;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.OnRep_AuthorityHits
// (Final, Native, Protected)

void AKosmosWrenchBreakable::OnRep_AuthorityHits()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "OnRep_AuthorityHits");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.Restore
// (Native, Event, Public, BlueprintCallable, BlueprintEvent)
// Parameters:
// int32                                   Hits                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::Restore(int32 Hits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "Restore");

	Params::KosmosWrenchBreakable_Restore Parms{};

	Parms.Hits = Hits;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.UpdateHitsNumber
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// int32                                   Hits                                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosWrenchBreakable::UpdateHitsNumber(int32 Hits)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "UpdateHitsNumber");

	Params::KosmosWrenchBreakable_UpdateHitsNumber Parms{};

	Parms.Hits = Hits;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosWrenchBreakable.CanBeBroken
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosWrenchBreakable::CanBeBroken() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosWrenchBreakable", "CanBeBroken");

	Params::KosmosWrenchBreakable_CanBeBroken Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZeroGravityVolume.EnterZeroGravityVolume
// (Final, Native, Public, HasOutParams)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    InFromSweep                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FHitResult&                Hit                                                    (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

void AKosmosZeroGravityVolume::EnterZeroGravityVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool InFromSweep, const struct FHitResult& Hit)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "EnterZeroGravityVolume");

	Params::KosmosZeroGravityVolume_EnterZeroGravityVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;
	Parms.InFromSweep = InFromSweep;
	Parms.Hit = std::move(Hit);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.ExitZeroGravityVolume
// (Final, Native, Public)
// Parameters:
// class UPrimitiveComponent*              HitComp                                                (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AActor*                           OtherActor                                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UPrimitiveComponent*              OtherComp                                              (Parm, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   OtherBodyIndex                                         (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZeroGravityVolume::ExitZeroGravityVolume(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "ExitZeroGravityVolume");

	Params::KosmosZeroGravityVolume_ExitZeroGravityVolume Parms{};

	Parms.HitComp = HitComp;
	Parms.OtherActor = OtherActor;
	Parms.OtherComp = OtherComp;
	Parms.OtherBodyIndex = OtherBodyIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.SetBounds
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InMin                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FVector&                   InMax                                                  (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZeroGravityVolume::SetBounds(const struct FVector& InMin, const struct FVector& InMax)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "SetBounds");

	Params::KosmosZeroGravityVolume_SetBounds Parms{};

	Parms.InMin = std::move(InMin);
	Parms.InMax = std::move(InMax);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.SetBoxExtent
// (Final, Native, Public, HasDefaults, BlueprintCallable)
// Parameters:
// const struct FVector&                   InBoxExtent                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bUpdateOverlaps                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZeroGravityVolume::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "SetBoxExtent");

	Params::KosmosZeroGravityVolume_SetBoxExtent Parms{};

	Parms.InBoxExtent = std::move(InBoxExtent);
	Parms.bUpdateOverlaps = bUpdateOverlaps;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.SetEnabled
// (Final, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    inEnabled                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void AKosmosZeroGravityVolume::SetEnabled(bool inEnabled)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "SetEnabled");

	Params::KosmosZeroGravityVolume_SetEnabled Parms{};

	Parms.inEnabled = inEnabled;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.UpdateInternalBoxes
// (Native, Public, BlueprintCallable)

void AKosmosZeroGravityVolume::UpdateInternalBoxes()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "UpdateInternalBoxes");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZeroGravityVolume.GetIsEnabled
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosZeroGravityVolume::GetIsEnabled() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "GetIsEnabled");

	Params::KosmosZeroGravityVolume_GetIsEnabled Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZeroGravityVolume.IsPoitionInVolume
// (Final, Native, Public, HasOutParams, HasDefaults, Const)
// Parameters:
// const struct FVector&                   InPositon                                              (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool AKosmosZeroGravityVolume::IsPoitionInVolume(const struct FVector& InPositon) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZeroGravityVolume", "IsPoitionInVolume");

	Params::KosmosZeroGravityVolume_IsPoitionInVolume Parms{};

	Parms.InPositon = std::move(InPositon);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.KosmosZipLineNavLink.OnZiplineFail
// (Final, Native, Private)

void AKosmosZipLineNavLink::OnZiplineFail()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipLineNavLink", "OnZiplineFail");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.KosmosZipLineNavLink.OnZiplineFinish
// (Final, Native, Private)

void AKosmosZipLineNavLink::OnZiplineFinish()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("KosmosZipLineNavLink", "OnZiplineFinish");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.NetSyncGameEvent.WaitForNetSync
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UObject*                          WorldContextObject_0                                   (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FName                       UniqueId                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const float                             TimeoutInSec                                           (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UNetSyncGameEvent*                ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UNetSyncGameEvent* UNetSyncGameEvent::WaitForNetSync(class UObject* WorldContextObject_0, const class FName UniqueId, const float TimeoutInSec)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("NetSyncGameEvent", "WaitForNetSync");

	Params::NetSyncGameEvent_WaitForNetSync Parms{};

	Parms.WorldContextObject_0 = WorldContextObject_0;
	Parms.UniqueId = UniqueId;
	Parms.TimeoutInSec = TimeoutInSec;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NetSyncGameEvent.Cancel
// (Native, Public, BlueprintCallable)

void UNetSyncGameEvent::Cancel()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetSyncGameEvent", "Cancel");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.NetSyncGameEvent.CheckRemoteActor
// (Final, Native, Private)

void UNetSyncGameEvent::CheckRemoteActor()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetSyncGameEvent", "CheckRemoteActor");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.NetSyncGameEvent.GlobalTimedOutEvent
// (Final, Native, Private)

void UNetSyncGameEvent::GlobalTimedOutEvent()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetSyncGameEvent", "GlobalTimedOutEvent");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.NetSyncGameEvent.InvokeNetSyncEvent
// (Final, Native, Private)
// Parameters:
// ENetSyncEventResult                     Result                                                 (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UNetSyncGameEvent::InvokeNetSyncEvent(ENetSyncEventResult Result)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NetSyncGameEvent", "InvokeNetSyncEvent");

	Params::NetSyncGameEvent_InvokeNetSyncEvent Parms{};

	Parms.Result = Result;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function Kosmos.NyxLevelScriptActor.GetAlone
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* ANyxLevelScriptActor::GetAlone()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetAlone");

	Params::NyxLevelScriptActor_GetAlone Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.GetLow
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* ANyxLevelScriptActor::GetLow()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetLow");

	Params::NyxLevelScriptActor_GetLow Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.GetOtherCharacter
// (Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             InCharacter                                            (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* ANyxLevelScriptActor::GetOtherCharacter(class AKosmosBaseCharacter* InCharacter)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetOtherCharacter");

	Params::NyxLevelScriptActor_GetOtherCharacter Parms{};

	Parms.InCharacter = InCharacter;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.GetPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* ANyxLevelScriptActor::GetPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetPlayer");

	Params::NyxLevelScriptActor_GetPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.GetPlayPal
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// class AKosmosBaseCharacter*             ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class AKosmosBaseCharacter* ANyxLevelScriptActor::GetPlayPal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetPlayPal");

	Params::NyxLevelScriptActor_GetPlayPal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.GetWhoAutomationControls
// (Native, Event, Public, BlueprintEvent)
// Parameters:
// ENyxCharacter                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

ENyxCharacter ANyxLevelScriptActor::GetWhoAutomationControls()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "GetWhoAutomationControls");

	Params::NyxLevelScriptActor_GetWhoAutomationControls Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.IsAlonePlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ANyxLevelScriptActor::IsAlonePlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "IsAlonePlayer");

	Params::NyxLevelScriptActor_IsAlonePlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.IsAlonePlayPal
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ANyxLevelScriptActor::IsAlonePlayPal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "IsAlonePlayPal");

	Params::NyxLevelScriptActor_IsAlonePlayPal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.IsLowPlayer
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ANyxLevelScriptActor::IsLowPlayer()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "IsLowPlayer");

	Params::NyxLevelScriptActor_IsLowPlayer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function Kosmos.NyxLevelScriptActor.IsLowPlayPal
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool ANyxLevelScriptActor::IsLowPlayPal()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("NyxLevelScriptActor", "IsLowPlayPal");

	Params::NyxLevelScriptActor_IsLowPlayPal Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}

}