#pragma once

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

// Package: AnimGraphRuntime

#include "Basic.hpp"

#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "AnimGraphRuntime_structs.hpp"
#include "CoreUObject_classes.hpp"


namespace SDK
{

// Class AnimGraphRuntime.AnimNotify_PlayMontageNotifyWindow
// 0x0008 (0x0038 - 0x0030)
class UAnimNotify_PlayMontageNotifyWindow final : public UAnimNotifyState
{
public:
	class FName                                   NotifyName;                                        // 0x0030(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimNotify_PlayMontageNotifyWindow")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimNotify_PlayMontageNotifyWindow")
	}
	static class UAnimNotify_PlayMontageNotifyWindow* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_PlayMontageNotifyWindow>();
	}
};
DUMPER7_ASSERTS_UAnimNotify_PlayMontageNotifyWindow;

// Class AnimGraphRuntime.AnimNodeRigidBodyLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimNodeRigidBodyLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FRigidBodyAnimNodeReference ConvertToRigidBodyAnimNode(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToRigidBodyAnimNodePure(const struct FAnimNodeReference& Node, struct FRigidBodyAnimNodeReference* RigidBodyAnimNode, bool* Result);
	static class UPhysicsAsset* GetCurrentPhysicsAsset(const struct FRigidBodyAnimNodeReference& Node);
	static void ResetDynamics(const struct FRigidBodyAnimNodeReference& Node, ETeleportType TeleportType);
	static struct FRigidBodyAnimNodeReference SetOverridePhysicsAsset(const struct FRigidBodyAnimNodeReference& Node, class UPhysicsAsset* PhysicsAsset);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimNodeRigidBodyLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimNodeRigidBodyLibrary")
	}
	static class UAnimNodeRigidBodyLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNodeRigidBodyLibrary>();
	}
};
DUMPER7_ASSERTS_UAnimNodeRigidBodyLibrary;

// Class AnimGraphRuntime.BlendSpaceLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlendSpaceLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FBlendSpaceReference ConvertToBlendSpace(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToBlendSpacePure(const struct FAnimNodeReference& Node, struct FBlendSpaceReference* BlendSpace, bool* Result);
	static struct FVector GetFilteredPosition(const struct FBlendSpaceReference& BlendSpace);
	static struct FVector GetPosition(const struct FBlendSpaceReference& BlendSpace);
	static void SnapToPosition(const struct FBlendSpaceReference& BlendSpace, const struct FVector& NewPosition);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("BlendSpaceLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"BlendSpaceLibrary")
	}
	static class UBlendSpaceLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendSpaceLibrary>();
	}
};
DUMPER7_ASSERTS_UBlendSpaceLibrary;

// Class AnimGraphRuntime.SequencerAnimationOverride
// 0x0000 (0x0000 - 0x0000)
class ISequencerAnimationOverride final
{
public:
	bool AllowsCinematicOverride() const;
	TArray<class FName> GetSequencerAnimSlotNames() const;

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("SequencerAnimationOverride")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"SequencerAnimationOverride")
	}
	static class ISequencerAnimationOverride* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISequencerAnimationOverride>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_ISequencerAnimationOverride;

// Class AnimGraphRuntime.AnimationStateMachineLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimationStateMachineLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void ConvertToAnimationStateMachine(const struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToAnimationStateMachinePure(const struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, bool* Result);
	static void ConvertToAnimationStateResult(const struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToAnimationStateResultPure(const struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, bool* Result);
	static float GetRelevantAnimTime(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static float GetRelevantAnimTimeFraction(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static float GetRelevantAnimTimeRemaining(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static float GetRelevantAnimTimeRemainingFraction(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static class FName GetState(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateMachineReference& Node);
	static bool IsStateBlendingIn(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static bool IsStateBlendingOut(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateResultReference& Node);
	static void SetState(const struct FAnimUpdateContext& UpdateContext, const struct FAnimationStateMachineReference& Node, class FName TargetState, float duration, ETransitionLogicType BlendType, class UBlendProfile* BlendProfile, EAlphaBlendOption AlphaBlendOption, class UCurveFloat* CustomBlendCurve);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimationStateMachineLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimationStateMachineLibrary")
	}
	static class UAnimationStateMachineLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimationStateMachineLibrary>();
	}
};
DUMPER7_ASSERTS_UAnimationStateMachineLibrary;

// Class AnimGraphRuntime.AnimSequencerInstance
// 0x0000 (0x0370 - 0x0370)
class UAnimSequencerInstance final : public UAnimInstance
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimSequencerInstance")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimSequencerInstance")
	}
	static class UAnimSequencerInstance* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimSequencerInstance>();
	}
};
DUMPER7_ASSERTS_UAnimSequencerInstance;

// Class AnimGraphRuntime.AnimExecutionContextLibrary
// 0x0000 (0x0028 - 0x0028)
class UAnimExecutionContextLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FAnimComponentSpacePoseContext ConvertToComponentSpacePoseContext(const struct FAnimExecutionContext& Context, EAnimExecutionContextConversionResult* Result);
	static struct FAnimInitializationContext ConvertToInitializationContext(const struct FAnimExecutionContext& Context, EAnimExecutionContextConversionResult* Result);
	static struct FAnimPoseContext ConvertToPoseContext(const struct FAnimExecutionContext& Context, EAnimExecutionContextConversionResult* Result);
	static struct FAnimUpdateContext ConvertToUpdateContext(const struct FAnimExecutionContext& Context, EAnimExecutionContextConversionResult* Result);
	static class UAnimInstance* GetAnimInstance(const struct FAnimExecutionContext& Context);
	static struct FAnimNodeReference GetAnimNodeReference(class UAnimInstance* Instance, int32 Index_0);
	static float GetCurrentWeight(const struct FAnimUpdateContext& Context);
	static float GetDeltaTime(const struct FAnimUpdateContext& Context);
	static bool IsActive(const struct FAnimExecutionContext& Context);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimExecutionContextLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimExecutionContextLibrary")
	}
	static class UAnimExecutionContextLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimExecutionContextLibrary>();
	}
};
DUMPER7_ASSERTS_UAnimExecutionContextLibrary;

// Class AnimGraphRuntime.AnimNotify_PlayMontageNotify
// 0x0008 (0x0040 - 0x0038)
class UAnimNotify_PlayMontageNotify final : public UAnimNotify
{
public:
	class FName                                   NotifyName;                                        // 0x0038(0x0008)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("AnimNotify_PlayMontageNotify")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"AnimNotify_PlayMontageNotify")
	}
	static class UAnimNotify_PlayMontageNotify* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAnimNotify_PlayMontageNotify>();
	}
};
DUMPER7_ASSERTS_UAnimNotify_PlayMontageNotify;

// Class AnimGraphRuntime.BlendListBaseLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlendListBaseLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FBlendListBaseReference ConvertToBlendListBase(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ResetNode(const struct FBlendListBaseReference& BlendListBase);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("BlendListBaseLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"BlendListBaseLibrary")
	}
	static class UBlendListBaseLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendListBaseLibrary>();
	}
};
DUMPER7_ASSERTS_UBlendListBaseLibrary;

// Class AnimGraphRuntime.BlendSpacePlayerLibrary
// 0x0000 (0x0028 - 0x0028)
class UBlendSpacePlayerLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FBlendSpacePlayerReference ConvertToBlendSpacePlayer(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToBlendSpacePlayerPure(const struct FAnimNodeReference& Node, struct FBlendSpacePlayerReference* BlendSpacePlayer, bool* Result);
	static class UBlendSpace* GetBlendSpace(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static bool GetLoop(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static float GetPlayRate(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static struct FVector GetPosition(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static float GetStartPosition(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static struct FBlendSpacePlayerReference SetBlendSpace(const struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace);
	static struct FBlendSpacePlayerReference SetBlendSpaceWithInertialBlending(const struct FAnimUpdateContext& UpdateContext, const struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace, float BlendTime);
	static struct FBlendSpacePlayerReference SetLoop(const struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bLoop);
	static struct FBlendSpacePlayerReference SetPlayRate(const struct FBlendSpacePlayerReference& BlendSpacePlayer, float PlayRate);
	static struct FBlendSpacePlayerReference SetResetPlayTimeWhenBlendSpaceChanges(const struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bReset);
	static bool ShouldResetPlayTimeWhenBlendSpaceChanges(const struct FBlendSpacePlayerReference& BlendSpacePlayer);
	static void SnapToPosition(const struct FBlendSpacePlayerReference& BlendSpacePlayer, const struct FVector& NewPosition);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("BlendSpacePlayerLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"BlendSpacePlayerLibrary")
	}
	static class UBlendSpacePlayerLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UBlendSpacePlayerLibrary>();
	}
};
DUMPER7_ASSERTS_UBlendSpacePlayerLibrary;

// Class AnimGraphRuntime.KismetAnimationLibrary
// 0x0000 (0x0028 - 0x0028)
class UKismetAnimationLibrary final : public UBlueprintFunctionLibrary
{
public:
	static float CalculateDirection(const struct FVector& Velocity, const struct FRotator& BaseRotation);
	static float K2_CalculateVelocityFromPositionHistory(float DeltaSeconds, const struct FVector& position, struct FPositionHistory& History, int32 NumberOfSamples, float VelocityMin, float VelocityMax);
	static float K2_CalculateVelocityFromSockets(float DeltaSeconds, class USkeletalMeshComponent* Component, const class FName SocketOrBoneName, const class FName ReferenceSocketOrBone, ERelativeTransformSpace SocketSpace, const struct FVector& OffsetInBoneSpace, struct FPositionHistory& History, int32 NumberOfSamples, float VelocityMin, float VelocityMax, EEasingFuncType EasingType, const struct FRuntimeFloatCurve& CustomCurve);
	static struct FVector K2_DirectionBetweenSockets(const class USkeletalMeshComponent* Component, const class FName SocketOrBoneNameFrom, const class FName SocketOrBoneNameTo);
	static float K2_DistanceBetweenTwoSocketsAndMapRange(const class USkeletalMeshComponent* Component, const class FName SocketOrBoneNameA, ERelativeTransformSpace SocketSpaceA, const class FName SocketOrBoneNameB, ERelativeTransformSpace SocketSpaceB, bool bRemapRange, float InRangeMin, float InRangeMax, float OutRangeMin, float OutRangeMax);
	static float K2_EndProfilingTimer(bool bLog, const class FString& LogPrefix);
	static struct FTransform K2_LookAt(const struct FTransform& CurrentTransform, const struct FVector& TargetPosition, const struct FVector& LookAtVector, bool bUseUpVector, const struct FVector& UpVector, float ClampConeInDegree);
	static float K2_MakePerlinNoiseAndRemap(float Value, float RangeOutMin, float RangeOutMax);
	static struct FVector K2_MakePerlinNoiseVectorAndRemap(float X, float Y, float Z, float RangeOutMinX, float RangeOutMaxX, float RangeOutMinY, float RangeOutMaxY, float RangeOutMinZ, float RangeOutMaxZ);
	static void K2_StartProfilingTimer();
	static void K2_TwoBoneIK(const struct FVector& RootPos, const struct FVector& JointPos, const struct FVector& EndPos, const struct FVector& JointTarget, const struct FVector& Effector, struct FVector* OutJointPos, struct FVector* OutEndPos, bool bAllowStretching, float StartStretchRatio, float MaxStretchScale);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("KismetAnimationLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"KismetAnimationLibrary")
	}
	static class UKismetAnimationLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UKismetAnimationLibrary>();
	}
};
DUMPER7_ASSERTS_UKismetAnimationLibrary;

// Class AnimGraphRuntime.LayeredBoneBlendLibrary
// 0x0000 (0x0028 - 0x0028)
class ULayeredBoneBlendLibrary final : public UBlueprintFunctionLibrary
{
public:
	static void ConvertToLayeredBlendPerBonePure(const struct FAnimNodeReference& Node, struct FLayeredBoneBlendReference* LayeredBoneBlend, bool* Result);
	static struct FLayeredBoneBlendReference ConvertToLayeredBoneBlend(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static int32 GetNumPoses(const struct FLayeredBoneBlendReference& LayeredBoneBlend);
	static struct FLayeredBoneBlendReference SetBlendMask(const struct FAnimUpdateContext& UpdateContext, const struct FLayeredBoneBlendReference& LayeredBoneBlend, int32 PoseIndex, class FName BlendMaskName);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("LayeredBoneBlendLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"LayeredBoneBlendLibrary")
	}
	static class ULayeredBoneBlendLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULayeredBoneBlendLibrary>();
	}
};
DUMPER7_ASSERTS_ULayeredBoneBlendLibrary;

// Class AnimGraphRuntime.LinkedAnimGraphLibrary
// 0x0000 (0x0028 - 0x0028)
class ULinkedAnimGraphLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FLinkedAnimGraphReference ConvertToLinkedAnimGraph(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToLinkedAnimGraphPure(const struct FAnimNodeReference& Node, struct FLinkedAnimGraphReference* LinkedAnimGraph, bool* Result);
	static class UAnimInstance* GetLinkedAnimInstance(const struct FLinkedAnimGraphReference& Node);
	static bool HasLinkedAnimInstance(const struct FLinkedAnimGraphReference& Node);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("LinkedAnimGraphLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"LinkedAnimGraphLibrary")
	}
	static class ULinkedAnimGraphLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<ULinkedAnimGraphLibrary>();
	}
};
DUMPER7_ASSERTS_ULinkedAnimGraphLibrary;

// Class AnimGraphRuntime.MirrorAnimLibrary
// 0x0000 (0x0028 - 0x0028)
class UMirrorAnimLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FMirrorAnimNodeReference ConvertToMirrorNode(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToMirrorNodePure(const struct FAnimNodeReference& Node, struct FMirrorAnimNodeReference* MirrorNode, bool* Result);
	static bool GetMirror(const struct FMirrorAnimNodeReference& MirrorNode);
	static class UMirrorDataTable* GetMirrorDataTable(const struct FMirrorAnimNodeReference& MirrorNode);
	static float GetMirrorTransitionBlendTime(const struct FMirrorAnimNodeReference& MirrorNode);
	static struct FMirrorAnimNodeReference SetMirror(const struct FMirrorAnimNodeReference& MirrorNode, bool bInMirror);
	static struct FMirrorAnimNodeReference SetMirrorTransitionBlendTime(const struct FMirrorAnimNodeReference& MirrorNode, float InBlendTime);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("MirrorAnimLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"MirrorAnimLibrary")
	}
	static class UMirrorAnimLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMirrorAnimLibrary>();
	}
};
DUMPER7_ASSERTS_UMirrorAnimLibrary;

// Class AnimGraphRuntime.ModifyCurveAnimLibrary
// 0x0000 (0x0028 - 0x0028)
class UModifyCurveAnimLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FModifyCurveAnimNodeReference ConvertToModifyCurveNode(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToModifyCurveNodePure(const struct FAnimNodeReference& Node, struct FModifyCurveAnimNodeReference* ModifyCurveNode, bool* Result);
	static float GetAlpha(const struct FModifyCurveAnimNodeReference& ModifyCurveNode);
	static EModifyCurveApplyMode GetApplyMode(const struct FModifyCurveAnimNodeReference& ModifyCurveNode);
	static struct FModifyCurveAnimNodeReference SetAlpha(const struct FModifyCurveAnimNodeReference& ModifyCurveNode, float InAlpha);
	static struct FModifyCurveAnimNodeReference SetApplyMode(const struct FModifyCurveAnimNodeReference& ModifyCurveNode, EModifyCurveApplyMode InMode);
	static struct FModifyCurveAnimNodeReference SetCurveMap(const struct FModifyCurveAnimNodeReference& ModifyCurveNode, const TMap<class FName, float>& InCurveMap);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("ModifyCurveAnimLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"ModifyCurveAnimLibrary")
	}
	static class UModifyCurveAnimLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UModifyCurveAnimLibrary>();
	}
};
DUMPER7_ASSERTS_UModifyCurveAnimLibrary;

// Class AnimGraphRuntime.PlayMontageCallbackProxy
// 0x0080 (0x00A8 - 0x0028)
class UPlayMontageCallbackProxy final : public UObject
{
public:
	TMulticastInlineDelegate<void(class FName NotifyName)> OnCompleted;                              // 0x0028(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName NotifyName)> OnBlendOut;                               // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName NotifyName)> OnInterrupted;                            // 0x0048(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName NotifyName)> OnNotifyBegin;                            // 0x0058(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class FName NotifyName)> OnNotifyEnd;                              // 0x0068(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x30];                                      // 0x0078(0x0030)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UPlayMontageCallbackProxy* CreateProxyObjectForPlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, class FName StartingSection);

	void OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted);
	void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
	void OnNotifyBeginReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
	void OnNotifyEndReceived(class FName NotifyName, const struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("PlayMontageCallbackProxy")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"PlayMontageCallbackProxy")
	}
	static class UPlayMontageCallbackProxy* GetDefaultObj()
	{
		return GetDefaultObjImpl<UPlayMontageCallbackProxy>();
	}
};
DUMPER7_ASSERTS_UPlayMontageCallbackProxy;

// Class AnimGraphRuntime.SequenceEvaluatorLibrary
// 0x0000 (0x0028 - 0x0028)
class USequenceEvaluatorLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FSequenceEvaluatorReference AdvanceTime(const struct FAnimUpdateContext& UpdateContext, const struct FSequenceEvaluatorReference& SequenceEvaluator, float PlayRate);
	static struct FSequenceEvaluatorReference ConvertToSequenceEvaluator(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToSequenceEvaluatorPure(const struct FAnimNodeReference& Node, struct FSequenceEvaluatorReference* SequenceEvaluator, bool* Result);
	static float GetAccumulatedTime(const struct FSequenceEvaluatorReference& SequenceEvaluator);
	static class UAnimSequenceBase* GetSequence(const struct FSequenceEvaluatorReference& SequenceEvaluator);
	static struct FSequenceEvaluatorReference SetExplicitFrame(const struct FSequenceEvaluatorReference& SequenceEvaluator, int32 Frame);
	static struct FSequenceEvaluatorReference SetExplicitTime(const struct FSequenceEvaluatorReference& SequenceEvaluator, float Time);
	static struct FSequenceEvaluatorReference SetSequence(const struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence);
	static struct FSequenceEvaluatorReference SetSequenceWithInertialBlending(const struct FAnimUpdateContext& UpdateContext, const struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence, float BlendTime);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("SequenceEvaluatorLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"SequenceEvaluatorLibrary")
	}
	static class USequenceEvaluatorLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<USequenceEvaluatorLibrary>();
	}
};
DUMPER7_ASSERTS_USequenceEvaluatorLibrary;

// Class AnimGraphRuntime.SequencePlayerLibrary
// 0x0000 (0x0028 - 0x0028)
class USequencePlayerLibrary final : public UBlueprintFunctionLibrary
{
public:
	static float ComputePlayRateFromDuration(const struct FSequencePlayerReference& SequencePlayer, float duration);
	static struct FSequencePlayerReference ConvertToSequencePlayer(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToSequencePlayerPure(const struct FAnimNodeReference& Node, struct FSequencePlayerReference* SequencePlayer, bool* Result);
	static float GetAccumulatedTime(const struct FSequencePlayerReference& SequencePlayer);
	static bool GetLoopAnimation(const struct FSequencePlayerReference& SequencePlayer);
	static float GetPlayRate(const struct FSequencePlayerReference& SequencePlayer);
	static struct FSequencePlayerReference GetSequence(const struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase*& SequenceBase);
	static class UAnimSequenceBase* GetSequencePure(const struct FSequencePlayerReference& SequencePlayer);
	static float GetStartPosition(const struct FSequencePlayerReference& SequencePlayer);
	static struct FSequencePlayerReference SetAccumulatedTime(const struct FSequencePlayerReference& SequencePlayer, float Time);
	static struct FSequencePlayerReference SetPlayRate(const struct FSequencePlayerReference& SequencePlayer, float PlayRate);
	static struct FSequencePlayerReference SetSequence(const struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence);
	static struct FSequencePlayerReference SetSequenceWithInertialBlending(const struct FAnimUpdateContext& UpdateContext, const struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence, float BlendTime);
	static struct FSequencePlayerReference SetStartPosition(const struct FSequencePlayerReference& SequencePlayer, float StartPosition);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("SequencePlayerLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"SequencePlayerLibrary")
	}
	static class USequencePlayerLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<USequencePlayerLibrary>();
	}
};
DUMPER7_ASSERTS_USequencePlayerLibrary;

// Class AnimGraphRuntime.SequencerAnimationSupport
// 0x0000 (0x0000 - 0x0000)
class ISequencerAnimationSupport final
{
public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("SequencerAnimationSupport")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"SequencerAnimationSupport")
	}
	static class ISequencerAnimationSupport* GetDefaultObj()
	{
		return GetDefaultObjImpl<ISequencerAnimationSupport>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
DUMPER7_ASSERTS_ISequencerAnimationSupport;

// Class AnimGraphRuntime.SkeletalControlLibrary
// 0x0000 (0x0028 - 0x0028)
class USkeletalControlLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FSkeletalControlReference ConvertToSkeletalControl(const struct FAnimNodeReference& Node, EAnimNodeReferenceConversionResult* Result);
	static void ConvertToSkeletalControlPure(const struct FAnimNodeReference& Node, struct FSkeletalControlReference* SkeletalControl, bool* Result);
	static float GetAlpha(const struct FSkeletalControlReference& SkeletalControl);
	static struct FSkeletalControlReference SetAlpha(const struct FSkeletalControlReference& SkeletalControl, float Alpha);

public:
	static class UClass* StaticClass()
	{
		STATIC_CLASS_IMPL("SkeletalControlLibrary")
	}
	static const class FName& StaticName()
	{
		STATIC_NAME_IMPL(L"SkeletalControlLibrary")
	}
	static class USkeletalControlLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<USkeletalControlLibrary>();
	}
};
DUMPER7_ASSERTS_USkeletalControlLibrary;

}