#pragma once

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

// Package: GameplayAbilities

#include "Basic.hpp"

#include "Engine_structs.hpp"
#include "Engine_classes.hpp"
#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "GameplayTasks_classes.hpp"
#include "GameplayAbilities_structs.hpp"
#include "GameplayTags_structs.hpp"
#include "MovieScene_classes.hpp"


namespace SDK
{

// Class GameplayAbilities.GameplayAbilityBlueprint
// 0x0000 (0x00A0 - 0x00A0)
class UGameplayAbilityBlueprint final : public UBlueprint
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityBlueprint">();
	}
	static class UGameplayAbilityBlueprint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayAbilityBlueprint>();
	}
};
static_assert(alignof(UGameplayAbilityBlueprint) == 0x000008, "Wrong alignment on UGameplayAbilityBlueprint");
static_assert(sizeof(UGameplayAbilityBlueprint) == 0x0000A0, "Wrong size on UGameplayAbilityBlueprint");

// Class GameplayAbilities.AbilityAsync
// 0x0008 (0x0038 - 0x0030)
class UAbilityAsync : public UBlueprintAsyncActionBase
{
public:
	uint8                                         Pad_30[0x8];                                       // 0x0030(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void EndAction();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync">();
	}
	static class UAbilityAsync* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync>();
	}
};
static_assert(alignof(UAbilityAsync) == 0x000008, "Wrong alignment on UAbilityAsync");
static_assert(sizeof(UAbilityAsync) == 0x000038, "Wrong size on UAbilityAsync");

// Class GameplayAbilities.AbilitySystemComponent
// 0x11E8 (0x1308 - 0x0120)
class UAbilitySystemComponent : public UGameplayTasksComponent
{
public:
	uint8                                         Pad_120[0x10];                                     // 0x0120(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FAttributeDefaults>             DefaultStartingData;                               // 0x0130(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<class UAttributeSet*>                  SpawnedAttributes;                                 // 0x0140(0x0010)(ExportObject, Net, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	class FName                                   AffectedAnimInstanceTag;                           // 0x0150(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_158[0x198];                                    // 0x0158(0x0198)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         OutgoingDuration;                                  // 0x02F0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         IncomingDuration;                                  // 0x02F4(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2F8[0x20];                                     // 0x02F8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FString>                         ClientDebugStrings;                                // 0x0318(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPublic)
	TArray<class FString>                         ServerDebugStrings;                                // 0x0328(0x0010)(Net, ZeroConstructor, RepNotify, NativeAccessSpecifierPublic)
	uint8                                         Pad_338[0x58];                                     // 0x0338(0x0058)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          UserAbilityActivationInhibited;                    // 0x0390(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          ReplicationProxyEnabled;                           // 0x0391(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSuppressGrantAbility;                             // 0x0392(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSuppressGameplayCues;                             // 0x0393(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_394[0x4];                                      // 0x0394(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class AGameplayAbilityTargetActor*>    SpawnedTargetActors;                               // 0x0398(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_3A8[0x28];                                     // 0x03A8(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 OwnerActor;                                        // 0x03D0(0x0008)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class AActor*                                 AvatarActor;                                       // 0x03D8(0x0008)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3E0[0x10];                                     // 0x03E0(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayAbilitySpecContainer          ActivatableAbilities;                              // 0x03F0(0x0120)(BlueprintVisible, BlueprintReadOnly, Net, RepNotify, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_510[0x30];                                     // 0x0510(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UGameplayAbility*>               AllReplicatedInstancedAbilities;                   // 0x0540(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_550[0x200];                                    // 0x0550(0x0200)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayAbilityRepAnimMontage         RepAnimMontageInfo;                                // 0x0750(0x0030)(Net, RepNotify, NoDestructor, Protected, NativeAccessSpecifierProtected)
	bool                                          bCachedIsNetSimulated;                             // 0x0780(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bPendingMontageRep;                                // 0x0781(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_782[0x6];                                      // 0x0782(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayAbilityLocalAnimMontage       LocalAnimMontageInfo;                              // 0x0788(0x0028)(NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_7B0[0xA0];                                     // 0x07B0(0x00A0)(Fixing Size After Last Property [ Dumper-7 ])
	struct FActiveGameplayEffectsContainer        ActiveGameplayEffects;                             // 0x0850(0x0478)(Net, Protected, NativeAccessSpecifierProtected)
	struct FActiveGameplayCueContainer            ActiveGameplayCues;                                // 0x0CC8(0x0128)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	struct FActiveGameplayCueContainer            MinimalReplicationGameplayCues;                    // 0x0DF0(0x0128)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_F18[0x128];                                    // 0x0F18(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<uint8>                                 BlockedAbilityBindings;                            // 0x1040(0x0010)(Net, ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_1050[0x128];                                   // 0x1050(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMinimalReplicationTagCountMap         MinimalReplicationTags;                            // 0x1178(0x0060)(Net, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_11D8[0x18];                                    // 0x11D8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	struct FReplicatedPredictionKeyMap            ReplicatedPredictionKeyMap;                        // 0x11F0(0x0118)(Net, NativeAccessSpecifierPublic)

public:
	struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectSpecToSelf(const struct FGameplayEffectSpecHandle& SpecHandle);
	struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectSpecToTarget(const struct FGameplayEffectSpecHandle& SpecHandle, class UAbilitySystemComponent* Target);
	struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToSelf(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& EffectContext);
	struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToTarget(TSubclassOf<class UGameplayEffect> GameplayEffectClass, class UAbilitySystemComponent* Target, float Level, const struct FGameplayEffectContextHandle& Context);
	void ClientActivateAbilityFailed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, int16 PredictionKey);
	void ClientActivateAbilitySucceed(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey);
	void ClientActivateAbilitySucceedWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData);
	void ClientCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo);
	void ClientEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo);
	void ClientPrintDebug_Response(const TArray<class FString>& Strings, int32 GameFlags);
	void ClientSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey);
	void ClientTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate);
	int32 GetGameplayEffectCount(TSubclassOf<class UGameplayEffect> SourceGameplayEffect, class UAbilitySystemComponent* OptionalInstigatorFilterComponent, bool bEnforceOnGoingCheck);
	void K2_InitStats(TSubclassOf<class UAttributeSet> Attributes, const class UDataTable* DataTable);
	void NetMulticast_InvokeGameplayCueAdded(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
	void NetMulticast_InvokeGameplayCueAdded_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& Parameters);
	void NetMulticast_InvokeGameplayCueAddedAndWhileActive_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey);
	void NetMulticast_InvokeGameplayCueAddedAndWhileActive_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
	void NetMulticast_InvokeGameplayCueExecuted(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
	void NetMulticast_InvokeGameplayCueExecuted_FromSpec(const struct FGameplayEffectSpecForRPC& Spec, const struct FPredictionKey& PredictionKey);
	void NetMulticast_InvokeGameplayCueExecuted_WithParams(const struct FGameplayTag& GameplayCueTag, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
	void NetMulticast_InvokeGameplayCuesAddedAndWhileActive_WithParams(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
	void NetMulticast_InvokeGameplayCuesExecuted(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayEffectContextHandle& EffectContext);
	void NetMulticast_InvokeGameplayCuesExecuted_WithParams(const struct FGameplayTagContainer& GameplayCueTags, const struct FPredictionKey& PredictionKey, const struct FGameplayCueParameters& GameplayCueParameters);
	void OnRep_ActivateAbilities();
	void OnRep_ClientDebugString();
	void OnRep_OwningActor();
	void OnRep_ReplicatedAnimMontage();
	void OnRep_ServerDebugString();
	int32 RemoveActiveEffectsWithAppliedTags(const struct FGameplayTagContainer& Tags);
	int32 RemoveActiveEffectsWithGrantedTags(const struct FGameplayTagContainer& Tags);
	int32 RemoveActiveEffectsWithSourceTags(const struct FGameplayTagContainer& Tags);
	int32 RemoveActiveEffectsWithTags(const struct FGameplayTagContainer& Tags);
	bool RemoveActiveGameplayEffect(const struct FActiveGameplayEffectHandle& Handle, int32 StacksToRemove);
	void RemoveActiveGameplayEffectBySourceEffect(TSubclassOf<class UGameplayEffect> GameplayEffect, class UAbilitySystemComponent* InstigatorAbilitySystemComponent, int32 StacksToRemove);
	void ServerAbilityRPCBatch(const struct GameplayAbilities::FServerAbilityRPCBatch& BatchInfo);
	void ServerCancelAbility(const struct FGameplayAbilitySpecHandle& AbilityToCancel, const struct FGameplayAbilityActivationInfo& ActivationInfo);
	void ServerCurrentMontageJumpToSectionName(class UAnimMontage* ClientAnimMontage, class FName SectionName);
	void ServerCurrentMontageSetNextSectionName(class UAnimMontage* ClientAnimMontage, float ClientPosition, class FName SectionName, class FName NextSectionName);
	void ServerCurrentMontageSetPlayRate(class UAnimMontage* ClientAnimMontage, float InPlayRate);
	void ServerEndAbility(const struct FGameplayAbilitySpecHandle& AbilityToEnd, const struct FGameplayAbilityActivationInfo& ActivationInfo, const struct FPredictionKey& PredictionKey);
	void ServerPrintDebug_Request();
	void ServerPrintDebug_RequestWithStrings(const TArray<class FString>& Strings);
	void ServerSetInputPressed(const struct FGameplayAbilitySpecHandle& AbilityHandle);
	void ServerSetInputReleased(const struct FGameplayAbilitySpecHandle& AbilityHandle);
	void ServerSetReplicatedEvent(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey);
	void ServerSetReplicatedEventWithPayload(EAbilityGenericReplicatedEvent EventType, const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey, const struct FVector_NetQuantize100& VectorPayload);
	void ServerSetReplicatedTargetData(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FGameplayAbilityTargetDataHandle& ReplicatedTargetDataHandle, const struct FGameplayTag& ApplicationTag, const struct FPredictionKey& CurrentPredictionKey);
	void ServerSetReplicatedTargetDataCancelled(const struct FGameplayAbilitySpecHandle& AbilityHandle, const struct FPredictionKey& AbilityOriginalPredictionKey, const struct FPredictionKey& CurrentPredictionKey);
	void ServerTryActivateAbility(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey);
	void ServerTryActivateAbilityWithEventData(const struct FGameplayAbilitySpecHandle& AbilityToActivate, bool InputPressed, const struct FPredictionKey& PredictionKey, const struct FGameplayEventData& TriggerEventData);
	void SetActiveGameplayEffectLevel(const struct FActiveGameplayEffectHandle& ActiveHandle, int32 NewLevel);
	void SetActiveGameplayEffectLevelUsingQuery(const struct FGameplayEffectQuery& Query, int32 NewLevel);
	void SetUserAbilityActivationInhibited(bool NewInhibit);
	void TargetCancel();
	void TargetConfirm();
	bool TryActivateAbilitiesByTag(const struct FGameplayTagContainer& GameplayTagContainer, bool bAllowRemoteActivation);
	bool TryActivateAbilityByClass(TSubclassOf<class UGameplayAbility> InAbilityToActivate, bool bAllowRemoteActivation);

	TArray<struct FActiveGameplayEffectHandle> GetActiveEffects(const struct FGameplayEffectQuery& Query) const;
	TArray<struct FActiveGameplayEffectHandle> GetActiveEffectsWithAllTags(const struct FGameplayTagContainer& Tags) const;
	float GetGameplayEffectMagnitude(const struct FActiveGameplayEffectHandle& Handle, const struct FGameplayAttribute& Attribute) const;
	bool GetUserAbilityActivationInhibited() const;
	bool IsGameplayCueActive(const struct FGameplayTag& GameplayCueTag) const;
	struct FGameplayEffectContextHandle MakeEffectContext() const;
	struct FGameplayEffectSpecHandle MakeOutgoingSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level, const struct FGameplayEffectContextHandle& Context) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemComponent">();
	}
	static class UAbilitySystemComponent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilitySystemComponent>();
	}
};
static_assert(alignof(UAbilitySystemComponent) == 0x000008, "Wrong alignment on UAbilitySystemComponent");
static_assert(sizeof(UAbilitySystemComponent) == 0x001308, "Wrong size on UAbilitySystemComponent");
static_assert(offsetof(UAbilitySystemComponent, DefaultStartingData) == 0x000130, "Member 'UAbilitySystemComponent::DefaultStartingData' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, SpawnedAttributes) == 0x000140, "Member 'UAbilitySystemComponent::SpawnedAttributes' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, AffectedAnimInstanceTag) == 0x000150, "Member 'UAbilitySystemComponent::AffectedAnimInstanceTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, OutgoingDuration) == 0x0002F0, "Member 'UAbilitySystemComponent::OutgoingDuration' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, IncomingDuration) == 0x0002F4, "Member 'UAbilitySystemComponent::IncomingDuration' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ClientDebugStrings) == 0x000318, "Member 'UAbilitySystemComponent::ClientDebugStrings' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ServerDebugStrings) == 0x000328, "Member 'UAbilitySystemComponent::ServerDebugStrings' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, UserAbilityActivationInhibited) == 0x000390, "Member 'UAbilitySystemComponent::UserAbilityActivationInhibited' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ReplicationProxyEnabled) == 0x000391, "Member 'UAbilitySystemComponent::ReplicationProxyEnabled' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, bSuppressGrantAbility) == 0x000392, "Member 'UAbilitySystemComponent::bSuppressGrantAbility' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, bSuppressGameplayCues) == 0x000393, "Member 'UAbilitySystemComponent::bSuppressGameplayCues' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, SpawnedTargetActors) == 0x000398, "Member 'UAbilitySystemComponent::SpawnedTargetActors' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, OwnerActor) == 0x0003D0, "Member 'UAbilitySystemComponent::OwnerActor' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, AvatarActor) == 0x0003D8, "Member 'UAbilitySystemComponent::AvatarActor' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ActivatableAbilities) == 0x0003F0, "Member 'UAbilitySystemComponent::ActivatableAbilities' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, AllReplicatedInstancedAbilities) == 0x000540, "Member 'UAbilitySystemComponent::AllReplicatedInstancedAbilities' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, RepAnimMontageInfo) == 0x000750, "Member 'UAbilitySystemComponent::RepAnimMontageInfo' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, bCachedIsNetSimulated) == 0x000780, "Member 'UAbilitySystemComponent::bCachedIsNetSimulated' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, bPendingMontageRep) == 0x000781, "Member 'UAbilitySystemComponent::bPendingMontageRep' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, LocalAnimMontageInfo) == 0x000788, "Member 'UAbilitySystemComponent::LocalAnimMontageInfo' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ActiveGameplayEffects) == 0x000850, "Member 'UAbilitySystemComponent::ActiveGameplayEffects' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ActiveGameplayCues) == 0x000CC8, "Member 'UAbilitySystemComponent::ActiveGameplayCues' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, MinimalReplicationGameplayCues) == 0x000DF0, "Member 'UAbilitySystemComponent::MinimalReplicationGameplayCues' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, BlockedAbilityBindings) == 0x001040, "Member 'UAbilitySystemComponent::BlockedAbilityBindings' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, MinimalReplicationTags) == 0x001178, "Member 'UAbilitySystemComponent::MinimalReplicationTags' has a wrong offset!");
static_assert(offsetof(UAbilitySystemComponent, ReplicatedPredictionKeyMap) == 0x0011F0, "Member 'UAbilitySystemComponent::ReplicatedPredictionKeyMap' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilitySet
// 0x0010 (0x0040 - 0x0030)
class UGameplayAbilitySet final : public UDataAsset
{
public:
	TArray<struct FGameplayAbilityBindInfo>       Abilities;                                         // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilitySet">();
	}
	static class UGameplayAbilitySet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayAbilitySet>();
	}
};
static_assert(alignof(UGameplayAbilitySet) == 0x000008, "Wrong alignment on UGameplayAbilitySet");
static_assert(sizeof(UGameplayAbilitySet) == 0x000040, "Wrong size on UGameplayAbilitySet");
static_assert(offsetof(UGameplayAbilitySet, Abilities) == 0x000030, "Member 'UGameplayAbilitySet::Abilities' has a wrong offset!");

// Class GameplayAbilities.AbilityAsync_WaitGameplayEffectApplied
// 0x00C0 (0x00F8 - 0x0038)
class UAbilityAsync_WaitGameplayEffectApplied final : public UAbilityAsync
{
public:
	TMulticastInlineDelegate<void(class AActor* Source, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0xB0];                                      // 0x0048(0x00B0)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityAsync_WaitGameplayEffectApplied* WaitGameplayEffectAppliedToActor(class AActor* TargetActor, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, bool ListenForPeriodicEffect);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync_WaitGameplayEffectApplied">();
	}
	static class UAbilityAsync_WaitGameplayEffectApplied* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync_WaitGameplayEffectApplied>();
	}
};
static_assert(alignof(UAbilityAsync_WaitGameplayEffectApplied) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayEffectApplied");
static_assert(sizeof(UAbilityAsync_WaitGameplayEffectApplied) == 0x0000F8, "Wrong size on UAbilityAsync_WaitGameplayEffectApplied");
static_assert(offsetof(UAbilityAsync_WaitGameplayEffectApplied, OnApplied) == 0x000038, "Member 'UAbilityAsync_WaitGameplayEffectApplied::OnApplied' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityTargetActor
// 0x0120 (0x0340 - 0x0220)
#pragma pack(push, 0x1)
class alignas(0x10) AGameplayAbilityTargetActor : public AActor
{
public:
	bool                                          ShouldProduceTargetDataOnServer;                   // 0x0220(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_221[0xF];                                      // 0x0221(0x000F)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayAbilityTargetingLocationInfo  StartLocation;                                     // 0x0230(0x0070)(BlueprintVisible, BlueprintReadOnly, Net, ContainsInstancedReference, ExposeOnSpawn, NativeAccessSpecifierPublic)
	uint8                                         Pad_2A0[0x30];                                     // 0x02A0(0x0030)(Fixing Size After Last Property [ Dumper-7 ])
	class APlayerController*                      MasterPC;                                          // 0x02D0(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UGameplayAbility*                       OwningAbility;                                     // 0x02D8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bDestroyOnConfirmation;                            // 0x02E0(0x0001)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2E1[0x7];                                      // 0x02E1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 SourceActor;                                       // 0x02E8(0x0008)(BlueprintVisible, BlueprintReadOnly, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FWorldReticleParameters                ReticleParams;                                     // 0x02F0(0x000C)(BlueprintVisible, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
	uint8                                         Pad_2FC[0x4];                                      // 0x02FC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class AGameplayAbilityWorldReticle> ReticleClass;                                    // 0x0300(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTargetDataFilterHandle        Filter;                                            // 0x0308(0x0010)(BlueprintVisible, Net, ExposeOnSpawn, NativeAccessSpecifierPublic)
	bool                                          bDebug;                                            // 0x0318(0x0001)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_319[0x17];                                     // 0x0319(0x0017)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                GenericDelegateBoundASC;                           // 0x0330(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	void CancelTargeting();
	void ConfirmTargeting();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor">();
	}
	static class AGameplayAbilityTargetActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor>();
	}
};
#pragma pack(pop)
static_assert(alignof(AGameplayAbilityTargetActor) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor");
static_assert(sizeof(AGameplayAbilityTargetActor) == 0x000340, "Wrong size on AGameplayAbilityTargetActor");
static_assert(offsetof(AGameplayAbilityTargetActor, ShouldProduceTargetDataOnServer) == 0x000220, "Member 'AGameplayAbilityTargetActor::ShouldProduceTargetDataOnServer' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, StartLocation) == 0x000230, "Member 'AGameplayAbilityTargetActor::StartLocation' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, MasterPC) == 0x0002D0, "Member 'AGameplayAbilityTargetActor::MasterPC' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, OwningAbility) == 0x0002D8, "Member 'AGameplayAbilityTargetActor::OwningAbility' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, bDestroyOnConfirmation) == 0x0002E0, "Member 'AGameplayAbilityTargetActor::bDestroyOnConfirmation' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, SourceActor) == 0x0002E8, "Member 'AGameplayAbilityTargetActor::SourceActor' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, ReticleParams) == 0x0002F0, "Member 'AGameplayAbilityTargetActor::ReticleParams' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, ReticleClass) == 0x000300, "Member 'AGameplayAbilityTargetActor::ReticleClass' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, Filter) == 0x000308, "Member 'AGameplayAbilityTargetActor::Filter' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, bDebug) == 0x000318, "Member 'AGameplayAbilityTargetActor::bDebug' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor, GenericDelegateBoundASC) == 0x000330, "Member 'AGameplayAbilityTargetActor::GenericDelegateBoundASC' has a wrong offset!");

// Class GameplayAbilities.AbilityAsync_WaitGameplayEvent
// 0x0028 (0x0060 - 0x0038)
class UAbilityAsync_WaitGameplayEvent final : public UAbilityAsync
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayEventData& Payload)> EventReceived;          // 0x0038(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_48[0x18];                                      // 0x0048(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityAsync_WaitGameplayEvent* WaitGameplayEventToActor(class AActor* TargetActor, const struct FGameplayTag& EventTag, bool OnlyTriggerOnce, bool OnlyMatchExact);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync_WaitGameplayEvent">();
	}
	static class UAbilityAsync_WaitGameplayEvent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync_WaitGameplayEvent>();
	}
};
static_assert(alignof(UAbilityAsync_WaitGameplayEvent) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayEvent");
static_assert(sizeof(UAbilityAsync_WaitGameplayEvent) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayEvent");
static_assert(offsetof(UAbilityAsync_WaitGameplayEvent, EventReceived) == 0x000038, "Member 'UAbilityAsync_WaitGameplayEvent::EventReceived' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityTargetActor_Trace
// 0x0010 (0x0350 - 0x0340)
class AGameplayAbilityTargetActor_Trace : public AGameplayAbilityTargetActor
{
public:
	float                                         MaxRange;                                          // 0x0338(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FCollisionProfileName                  TraceProfile;                                      // 0x033C(0x0008)(Edit, BlueprintVisible, Config, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
	bool                                          bTraceAffectsAimPitch;                             // 0x0344(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_345[0xB];                                      // 0x0345(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor_Trace">();
	}
	static class AGameplayAbilityTargetActor_Trace* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor_Trace>();
	}
};
static_assert(alignof(AGameplayAbilityTargetActor_Trace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_Trace");
static_assert(sizeof(AGameplayAbilityTargetActor_Trace) == 0x000350, "Wrong size on AGameplayAbilityTargetActor_Trace");
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, MaxRange) == 0x000338, "Member 'AGameplayAbilityTargetActor_Trace::MaxRange' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, TraceProfile) == 0x00033C, "Member 'AGameplayAbilityTargetActor_Trace::TraceProfile' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor_Trace, bTraceAffectsAimPitch) == 0x000344, "Member 'AGameplayAbilityTargetActor_Trace::bTraceAffectsAimPitch' has a wrong offset!");

// Class GameplayAbilities.AbilityAsync_WaitGameplayTag
// 0x0018 (0x0050 - 0x0038)
class UAbilityAsync_WaitGameplayTag : public UAbilityAsync
{
public:
	uint8                                         Pad_38[0x18];                                      // 0x0038(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync_WaitGameplayTag">();
	}
	static class UAbilityAsync_WaitGameplayTag* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTag>();
	}
};
static_assert(alignof(UAbilityAsync_WaitGameplayTag) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTag");
static_assert(sizeof(UAbilityAsync_WaitGameplayTag) == 0x000050, "Wrong size on UAbilityAsync_WaitGameplayTag");

// Class GameplayAbilities.GameplayAbilityTargetActor_GroundTrace
// 0x0020 (0x0370 - 0x0350)
class AGameplayAbilityTargetActor_GroundTrace : public AGameplayAbilityTargetActor_Trace
{
public:
	float                                         CollisionRadius;                                   // 0x0350(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CollisionHeight;                                   // 0x0354(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_358[0x18];                                     // 0x0358(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor_GroundTrace">();
	}
	static class AGameplayAbilityTargetActor_GroundTrace* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor_GroundTrace>();
	}
};
static_assert(alignof(AGameplayAbilityTargetActor_GroundTrace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_GroundTrace");
static_assert(sizeof(AGameplayAbilityTargetActor_GroundTrace) == 0x000370, "Wrong size on AGameplayAbilityTargetActor_GroundTrace");
static_assert(offsetof(AGameplayAbilityTargetActor_GroundTrace, CollisionRadius) == 0x000350, "Member 'AGameplayAbilityTargetActor_GroundTrace::CollisionRadius' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor_GroundTrace, CollisionHeight) == 0x000354, "Member 'AGameplayAbilityTargetActor_GroundTrace::CollisionHeight' has a wrong offset!");

// Class GameplayAbilities.AbilityAsync_WaitGameplayTagAdded
// 0x0010 (0x0060 - 0x0050)
class UAbilityAsync_WaitGameplayTagAdded final : public UAbilityAsync_WaitGameplayTag
{
public:
	TMulticastInlineDelegate<void()>              Added;                                             // 0x0050(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAbilityAsync_WaitGameplayTagAdded* WaitGameplayTagAddToActor(class AActor* TargetActor, const struct FGameplayTag& Tag, bool OnlyTriggerOnce);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync_WaitGameplayTagAdded">();
	}
	static class UAbilityAsync_WaitGameplayTagAdded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTagAdded>();
	}
};
static_assert(alignof(UAbilityAsync_WaitGameplayTagAdded) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTagAdded");
static_assert(sizeof(UAbilityAsync_WaitGameplayTagAdded) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayTagAdded");
static_assert(offsetof(UAbilityAsync_WaitGameplayTagAdded, Added) == 0x000050, "Member 'UAbilityAsync_WaitGameplayTagAdded::Added' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityTargetActor_ActorPlacement
// 0x0020 (0x0390 - 0x0370)
class AGameplayAbilityTargetActor_ActorPlacement final : public AGameplayAbilityTargetActor_GroundTrace
{
public:
	class UClass*                                 PlacedActorClass;                                  // 0x0370(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMaterialInterface*                     PlacedActorMaterial;                               // 0x0378(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_380[0x10];                                     // 0x0380(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor_ActorPlacement">();
	}
	static class AGameplayAbilityTargetActor_ActorPlacement* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor_ActorPlacement>();
	}
};
static_assert(alignof(AGameplayAbilityTargetActor_ActorPlacement) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_ActorPlacement");
static_assert(sizeof(AGameplayAbilityTargetActor_ActorPlacement) == 0x000390, "Wrong size on AGameplayAbilityTargetActor_ActorPlacement");
static_assert(offsetof(AGameplayAbilityTargetActor_ActorPlacement, PlacedActorClass) == 0x000370, "Member 'AGameplayAbilityTargetActor_ActorPlacement::PlacedActorClass' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityTargetActor_ActorPlacement, PlacedActorMaterial) == 0x000378, "Member 'AGameplayAbilityTargetActor_ActorPlacement::PlacedActorMaterial' has a wrong offset!");

// Class GameplayAbilities.AbilityAsync_WaitGameplayTagRemoved
// 0x0010 (0x0060 - 0x0050)
class UAbilityAsync_WaitGameplayTagRemoved final : public UAbilityAsync_WaitGameplayTag
{
public:
	TMulticastInlineDelegate<void()>              Removed;                                           // 0x0050(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAbilityAsync_WaitGameplayTagRemoved* WaitGameplayTagRemoveFromActor(class AActor* TargetActor, const struct FGameplayTag& Tag, bool OnlyTriggerOnce);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityAsync_WaitGameplayTagRemoved">();
	}
	static class UAbilityAsync_WaitGameplayTagRemoved* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityAsync_WaitGameplayTagRemoved>();
	}
};
static_assert(alignof(UAbilityAsync_WaitGameplayTagRemoved) == 0x000008, "Wrong alignment on UAbilityAsync_WaitGameplayTagRemoved");
static_assert(sizeof(UAbilityAsync_WaitGameplayTagRemoved) == 0x000060, "Wrong size on UAbilityAsync_WaitGameplayTagRemoved");
static_assert(offsetof(UAbilityAsync_WaitGameplayTagRemoved, Removed) == 0x000050, "Member 'UAbilityAsync_WaitGameplayTagRemoved::Removed' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityTargetActor_Radius
// 0x0000 (0x0340 - 0x0340)
class AGameplayAbilityTargetActor_Radius final : public AGameplayAbilityTargetActor
{
public:
	float                                         Radius;                                            // 0x0338(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_33C[0x4];                                      // 0x033C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor_Radius">();
	}
	static class AGameplayAbilityTargetActor_Radius* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor_Radius>();
	}
};
static_assert(alignof(AGameplayAbilityTargetActor_Radius) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_Radius");
static_assert(sizeof(AGameplayAbilityTargetActor_Radius) == 0x000340, "Wrong size on AGameplayAbilityTargetActor_Radius");
static_assert(offsetof(AGameplayAbilityTargetActor_Radius, Radius) == 0x000338, "Member 'AGameplayAbilityTargetActor_Radius::Radius' has a wrong offset!");

// Class GameplayAbilities.AbilitySystemBlueprintLibrary
// 0x0000 (0x0028 - 0x0028)
class UAbilitySystemBlueprintLibrary final : public UBlueprintFunctionLibrary
{
public:
	static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromActor(class AActor* Actor);
	static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromActorArray(const TArray<class AActor*>& ActorArray, bool OneTargetPerHandle);
	static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromHitResult(const struct FHitResult& HitResult);
	static struct FGameplayAbilityTargetDataHandle AbilityTargetDataFromLocations(const struct FGameplayAbilityTargetingLocationInfo& SourceLocation, const struct FGameplayAbilityTargetingLocationInfo& TargetLocation);
	static struct FGameplayEffectSpecHandle AddAssetTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag);
	static struct FGameplayEffectSpecHandle AddAssetTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags);
	static struct FGameplayEffectSpecHandle AddGrantedTag(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& NewGameplayTag);
	static struct FGameplayEffectSpecHandle AddGrantedTags(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTagContainer& NewGameplayTags);
	static struct FGameplayEffectSpecHandle AddLinkedGameplayEffect(const struct FGameplayEffectSpecHandle& SpecHandle, TSubclassOf<class UGameplayEffect> LinkedGameplayEffect);
	static struct FGameplayEffectSpecHandle AddLinkedGameplayEffectSpec(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayEffectSpecHandle& LinkedGameplayEffectSpec);
	static struct FGameplayAbilityTargetDataHandle AppendTargetDataHandle(const struct FGameplayAbilityTargetDataHandle& TargetHandle, const struct FGameplayAbilityTargetDataHandle& HandleToAdd);
	static struct FGameplayEffectSpecHandle AssignSetByCallerMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, class FName DataName, float Magnitude);
	static struct FGameplayEffectSpecHandle AssignTagSetByCallerMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayTag& DataTag, float Magnitude);
	static void BreakGameplayCueParameters(const struct FGameplayCueParameters& Parameters, float* NormalizedMagnitude, float* RawMagnitude, struct FGameplayEffectContextHandle* EffectContext, struct FGameplayTag* MatchedTagName, struct FGameplayTag* OriginalTag, struct FGameplayTagContainer* AggregatedSourceTags, struct FGameplayTagContainer* AggregatedTargetTags, struct FVector* Location, struct FVector* Normal, class AActor** Instigator, class AActor** EffectCauser, class UObject** SourceObject, class UPhysicalMaterial** PhysicalMaterial, int32* GameplayEffectLevel, int32* AbilityLevel, class USceneComponent** TargetAttachComponent, bool* bReplicateLocationWhenUsingMinimalRepProxy);
	static struct FGameplayEffectSpecHandle CloneSpecHandle(class AActor* InNewInstigator, class AActor* InEffectCauser, const struct FGameplayEffectSpecHandle& GameplayEffectSpecHandle_Clone);
	static bool DoesGameplayCueMeetTagRequirements(const struct FGameplayCueParameters& Parameters, const struct FGameplayTagRequirements& SourceTagReqs, const struct FGameplayTagRequirements& TargetTagReqs);
	static bool DoesTargetDataContainActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0, class AActor* Actor);
	static void EffectContextAddHitResult(const struct FGameplayEffectContextHandle& EffectContext, const struct FHitResult& HitResult, bool bReset);
	static class AActor* EffectContextGetEffectCauser(const struct FGameplayEffectContextHandle& EffectContext);
	static struct FHitResult EffectContextGetHitResult(const struct FGameplayEffectContextHandle& EffectContext);
	static class AActor* EffectContextGetInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext);
	static struct FVector EffectContextGetOrigin(const struct FGameplayEffectContextHandle& EffectContext);
	static class AActor* EffectContextGetOriginalInstigatorActor(const struct FGameplayEffectContextHandle& EffectContext);
	static class UObject* EffectContextGetSourceObject(const struct FGameplayEffectContextHandle& EffectContext);
	static bool EffectContextHasHitResult(const struct FGameplayEffectContextHandle& EffectContext);
	static bool EffectContextIsInstigatorLocallyControlled(const struct FGameplayEffectContextHandle& EffectContext);
	static bool EffectContextIsValid(const struct FGameplayEffectContextHandle& EffectContext);
	static void EffectContextSetOrigin(const struct FGameplayEffectContextHandle& EffectContext, const struct FVector& Origin);
	static bool EqualEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB);
	static float EvaluateAttributeValueWithTags(class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, const struct FGameplayTagContainer& SourceTags, const struct FGameplayTagContainer& TargetTags, bool* bSuccess);
	static float EvaluateAttributeValueWithTagsAndBase(class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, const struct FGameplayTagContainer& SourceTags, const struct FGameplayTagContainer& TargetTags, float BaseValue, bool* bSuccess);
	static struct FGameplayAbilityTargetDataHandle FilterTargetData(const struct FGameplayAbilityTargetDataHandle& TargetDataHandle, const struct FGameplayTargetDataFilterHandle& ActorFilterClass);
	static void ForwardGameplayCueToTarget(TScriptInterface<class IGameplayCueInterface> TargetCueInterface, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
	static class UAbilitySystemComponent* GetAbilitySystemComponent(class AActor* Actor);
	static class FString GetActiveGameplayEffectDebugString(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static float GetActiveGameplayEffectExpectedEndTime(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static float GetActiveGameplayEffectRemainingDuration(class UObject* WorldContextObject, const struct FActiveGameplayEffectHandle& ActiveHandle);
	static int32 GetActiveGameplayEffectStackCount(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static int32 GetActiveGameplayEffectStackLimitCount(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static float GetActiveGameplayEffectStartTime(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static float GetActiveGameplayEffectTotalDuration(const struct FActiveGameplayEffectHandle& ActiveHandle);
	static class AActor* GetActorByIndex(const struct FGameplayCueParameters& Parameters, int32 Index_0);
	static int32 GetActorCount(const struct FGameplayCueParameters& Parameters);
	static TArray<class AActor*> GetActorsFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static TArray<class AActor*> GetAllActorsFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData);
	static TArray<struct FGameplayEffectSpecHandle> GetAllLinkedGameplayEffectSpecHandles(const struct FGameplayEffectSpecHandle& SpecHandle);
	static int32 GetDataCountFromTargetData(const struct FGameplayAbilityTargetDataHandle& TargetData);
	static struct FGameplayEffectContextHandle GetEffectContext(const struct FGameplayEffectSpecHandle& SpecHandle);
	static float GetFloatAttribute(const class AActor* Actor, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
	static float GetFloatAttributeBase(const class AActor* Actor, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
	static float GetFloatAttributeBaseFromAbilitySystemComponent(const class UAbilitySystemComponent* AbilitySystemComponent, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
	static float GetFloatAttributeFromAbilitySystemComponent(const class UAbilitySystemComponent* AbilitySystem, const struct FGameplayAttribute& Attribute, bool* bSuccessfullyFoundAttribute);
	static bool GetGameplayCueDirection(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Direction);
	static bool GetGameplayCueEndLocationAndNormal(class AActor* TargetActor, const struct FGameplayCueParameters& Parameters, struct FVector* Location, struct FVector* Normal);
	static struct FHitResult GetHitResult(const struct FGameplayCueParameters& Parameters);
	static struct FHitResult GetHitResultFromTargetData(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 Index_0);
	static class AActor* GetInstigatorActor(const struct FGameplayCueParameters& Parameters);
	static struct FTransform GetInstigatorTransform(const struct FGameplayCueParameters& Parameters);
	static float GetModifiedAttributeMagnitude(const struct FGameplayEffectSpecHandle& SpecHandle, const struct FGameplayAttribute& Attribute);
	static struct FVector GetOrigin(const struct FGameplayCueParameters& Parameters);
	static struct FVector GetTargetDataEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static struct FTransform GetTargetDataEndPointTransform(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static struct FTransform GetTargetDataOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static bool HasHitResult(const struct FGameplayCueParameters& Parameters);
	static bool IsInstigatorLocallyControlled(const struct FGameplayCueParameters& Parameters);
	static bool IsInstigatorLocallyControlledPlayer(const struct FGameplayCueParameters& Parameters);
	static bool IsValid(const struct FGameplayAttribute& Attribute);
	static struct FGameplayTargetDataFilterHandle MakeFilterHandle(const struct FGameplayTargetDataFilter& Filter, class AActor* FilterActor);
	static struct FGameplayCueParameters MakeGameplayCueParameters(float NormalizedMagnitude, float RawMagnitude, const struct FGameplayEffectContextHandle& EffectContext, const struct FGameplayTag& MatchedTagName, const struct FGameplayTag& OriginalTag, const struct FGameplayTagContainer& AggregatedSourceTags, const struct FGameplayTagContainer& AggregatedTargetTags, const struct FVector& Location, const struct FVector& Normal, class AActor* Instigator, class AActor* EffectCauser, class UObject* SourceObject, class UPhysicalMaterial* PhysicalMaterial, int32 GameplayEffectLevel, int32 AbilityLevel, class USceneComponent* TargetAttachComponent, bool bReplicateLocationWhenUsingMinimalRepProxy);
	static struct FGameplayEffectSpecHandle MakeSpecHandle(class UGameplayEffect* InGameplayEffect, class AActor* InInstigator, class AActor* InEffectCauser, float InLevel);
	static bool NotEqual_GameplayAttributeGameplayAttribute(const struct FGameplayAttribute& AttributeA, const struct FGameplayAttribute& AttributeB);
	static void SendGameplayEventToActor(class AActor* Actor, const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload);
	static struct FGameplayEffectSpecHandle SetDuration(const struct FGameplayEffectSpecHandle& SpecHandle, float Duration);
	static struct FGameplayEffectSpecHandle SetStackCount(const struct FGameplayEffectSpecHandle& SpecHandle, int32 StackCount);
	static struct FGameplayEffectSpecHandle SetStackCountToMax(const struct FGameplayEffectSpecHandle& SpecHandle);
	static bool TargetDataHasActor(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static bool TargetDataHasEndPoint(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);
	static bool TargetDataHasHitResult(const struct FGameplayAbilityTargetDataHandle& HitResult, int32 Index_0);
	static bool TargetDataHasOrigin(const struct FGameplayAbilityTargetDataHandle& TargetData, int32 Index_0);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemBlueprintLibrary">();
	}
	static class UAbilitySystemBlueprintLibrary* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilitySystemBlueprintLibrary>();
	}
};
static_assert(alignof(UAbilitySystemBlueprintLibrary) == 0x000008, "Wrong alignment on UAbilitySystemBlueprintLibrary");
static_assert(sizeof(UAbilitySystemBlueprintLibrary) == 0x000028, "Wrong size on UAbilitySystemBlueprintLibrary");

// Class GameplayAbilities.AbilitySystemDebugHUD
// 0x0000 (0x0310 - 0x0310)
class AAbilitySystemDebugHUD final : public AHUD
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemDebugHUD">();
	}
	static class AAbilitySystemDebugHUD* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAbilitySystemDebugHUD>();
	}
};
static_assert(alignof(AAbilitySystemDebugHUD) == 0x000008, "Wrong alignment on AAbilitySystemDebugHUD");
static_assert(sizeof(AAbilitySystemDebugHUD) == 0x000310, "Wrong size on AAbilitySystemDebugHUD");

// Class GameplayAbilities.AbilitySystemGlobals
// 0x0238 (0x0260 - 0x0028)
class UAbilitySystemGlobals final : public UObject
{
public:
	struct FSoftClassPath                         AbilitySystemGlobalsClassName;                     // 0x0028(0x0018)(ZeroConstructor, Config, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x28];                                      // 0x0040(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTag                           ActivateFailIsDeadTag;                             // 0x0068(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailIsDeadName;                            // 0x0070(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ActivateFailCooldownTag;                           // 0x0078(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailCooldownName;                          // 0x0080(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ActivateFailCostTag;                               // 0x0088(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailCostName;                              // 0x0090(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ActivateFailTagsBlockedTag;                        // 0x0098(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailTagsBlockedName;                       // 0x00A0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ActivateFailTagsMissingTag;                        // 0x00A8(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailTagsMissingName;                       // 0x00B0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGameplayTag                           ActivateFailNetworkingTag;                         // 0x00B8(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ActivateFailNetworkingName;                        // 0x00C0(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         MinimalReplicationTagCountBits;                    // 0x00C8(0x0004)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CC[0x4];                                       // 0x00CC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FNetSerializeScriptStructCache         TargetDataStructCache;                             // 0x00D0(0x0010)(NativeAccessSpecifierPublic)
	bool                                          bAllowGameplayModEvaluationChannels;               // 0x00E0(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EGameplayModEvaluationChannel                 DefaultGameplayModEvaluationChannel;               // 0x00E1(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E2[0x2];                                       // 0x00E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   GameplayModEvaluationChannelAliases[0xA];          // 0x00E4(0x0008)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_134[0x4];                                      // 0x0134(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FSoftObjectPath                        GlobalCurveTableName;                              // 0x0138(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveTable*                            GlobalCurveTable;                                  // 0x0150(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FSoftObjectPath                        GlobalAttributeMetaDataTableName;                  // 0x0158(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UDataTable*                             GlobalAttributeMetaDataTable;                      // 0x0170(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FSoftObjectPath                        GlobalAttributeSetDefaultsTableName;               // 0x0178(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FSoftObjectPath>                GlobalAttributeSetDefaultsTableNames;              // 0x0190(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	TArray<class UCurveTable*>                    GlobalAttributeDefaultsTables;                     // 0x01A0(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	struct FSoftObjectPath                        GlobalGameplayCueManagerClass;                     // 0x01B0(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FSoftObjectPath                        GlobalGameplayCueManagerName;                      // 0x01C8(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<class FString>                         GameplayCueNotifyPaths;                            // 0x01E0(0x0010)(ZeroConstructor, Config, Protected, NativeAccessSpecifierProtected)
	struct FSoftObjectPath                        GameplayTagResponseTableName;                      // 0x01F0(0x0018)(ZeroConstructor, Config, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UGameplayTagReponseTable*               GameplayTagResponseTable;                          // 0x0208(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          PredictTargetGameplayEffects;                      // 0x0210(0x0001)(ZeroConstructor, Config, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_211[0x7];                                      // 0x0211(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	class UGameplayCueManager*                    GlobalGameplayCueManager;                          // 0x0218(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_220[0x40];                                     // 0x0220(0x0040)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void ListPlayerAbilities();
	void ServerActivatePlayerAbility(const class FString& AbilityNameMatch);
	void ServerCancelPlayerAbility(const class FString& AbilityNameMatch);
	void ServerEndPlayerAbility(const class FString& AbilityNameMatch);
	void ToggleIgnoreAbilitySystemCooldowns();
	void ToggleIgnoreAbilitySystemCosts();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemGlobals">();
	}
	static class UAbilitySystemGlobals* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilitySystemGlobals>();
	}
};
static_assert(alignof(UAbilitySystemGlobals) == 0x000008, "Wrong alignment on UAbilitySystemGlobals");
static_assert(sizeof(UAbilitySystemGlobals) == 0x000260, "Wrong size on UAbilitySystemGlobals");
static_assert(offsetof(UAbilitySystemGlobals, AbilitySystemGlobalsClassName) == 0x000028, "Member 'UAbilitySystemGlobals::AbilitySystemGlobalsClassName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailIsDeadTag) == 0x000068, "Member 'UAbilitySystemGlobals::ActivateFailIsDeadTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailIsDeadName) == 0x000070, "Member 'UAbilitySystemGlobals::ActivateFailIsDeadName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCooldownTag) == 0x000078, "Member 'UAbilitySystemGlobals::ActivateFailCooldownTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCooldownName) == 0x000080, "Member 'UAbilitySystemGlobals::ActivateFailCooldownName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCostTag) == 0x000088, "Member 'UAbilitySystemGlobals::ActivateFailCostTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailCostName) == 0x000090, "Member 'UAbilitySystemGlobals::ActivateFailCostName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsBlockedTag) == 0x000098, "Member 'UAbilitySystemGlobals::ActivateFailTagsBlockedTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsBlockedName) == 0x0000A0, "Member 'UAbilitySystemGlobals::ActivateFailTagsBlockedName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsMissingTag) == 0x0000A8, "Member 'UAbilitySystemGlobals::ActivateFailTagsMissingTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailTagsMissingName) == 0x0000B0, "Member 'UAbilitySystemGlobals::ActivateFailTagsMissingName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailNetworkingTag) == 0x0000B8, "Member 'UAbilitySystemGlobals::ActivateFailNetworkingTag' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, ActivateFailNetworkingName) == 0x0000C0, "Member 'UAbilitySystemGlobals::ActivateFailNetworkingName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, MinimalReplicationTagCountBits) == 0x0000C8, "Member 'UAbilitySystemGlobals::MinimalReplicationTagCountBits' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, TargetDataStructCache) == 0x0000D0, "Member 'UAbilitySystemGlobals::TargetDataStructCache' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, bAllowGameplayModEvaluationChannels) == 0x0000E0, "Member 'UAbilitySystemGlobals::bAllowGameplayModEvaluationChannels' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, DefaultGameplayModEvaluationChannel) == 0x0000E1, "Member 'UAbilitySystemGlobals::DefaultGameplayModEvaluationChannel' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GameplayModEvaluationChannelAliases) == 0x0000E4, "Member 'UAbilitySystemGlobals::GameplayModEvaluationChannelAliases' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalCurveTableName) == 0x000138, "Member 'UAbilitySystemGlobals::GlobalCurveTableName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalCurveTable) == 0x000150, "Member 'UAbilitySystemGlobals::GlobalCurveTable' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeMetaDataTableName) == 0x000158, "Member 'UAbilitySystemGlobals::GlobalAttributeMetaDataTableName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeMetaDataTable) == 0x000170, "Member 'UAbilitySystemGlobals::GlobalAttributeMetaDataTable' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeSetDefaultsTableName) == 0x000178, "Member 'UAbilitySystemGlobals::GlobalAttributeSetDefaultsTableName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeSetDefaultsTableNames) == 0x000190, "Member 'UAbilitySystemGlobals::GlobalAttributeSetDefaultsTableNames' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalAttributeDefaultsTables) == 0x0001A0, "Member 'UAbilitySystemGlobals::GlobalAttributeDefaultsTables' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManagerClass) == 0x0001B0, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManagerClass' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManagerName) == 0x0001C8, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManagerName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GameplayCueNotifyPaths) == 0x0001E0, "Member 'UAbilitySystemGlobals::GameplayCueNotifyPaths' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GameplayTagResponseTableName) == 0x0001F0, "Member 'UAbilitySystemGlobals::GameplayTagResponseTableName' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GameplayTagResponseTable) == 0x000208, "Member 'UAbilitySystemGlobals::GameplayTagResponseTable' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, PredictTargetGameplayEffects) == 0x000210, "Member 'UAbilitySystemGlobals::PredictTargetGameplayEffects' has a wrong offset!");
static_assert(offsetof(UAbilitySystemGlobals, GlobalGameplayCueManager) == 0x000218, "Member 'UAbilitySystemGlobals::GlobalGameplayCueManager' has a wrong offset!");

// Class GameplayAbilities.AbilitySystemInterface
// 0x0000 (0x0000 - 0x0000)
class IAbilitySystemInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemInterface">();
	}
	static class IAbilitySystemInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAbilitySystemInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAbilitySystemInterface) == 0x000001, "Wrong alignment on IAbilitySystemInterface");
static_assert(sizeof(IAbilitySystemInterface) == 0x000001, "Wrong size on IAbilitySystemInterface");

// Class GameplayAbilities.AbilitySystemReplicationProxyInterface
// 0x0000 (0x0000 - 0x0000)
class IAbilitySystemReplicationProxyInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemReplicationProxyInterface">();
	}
	static class IAbilitySystemReplicationProxyInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IAbilitySystemReplicationProxyInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IAbilitySystemReplicationProxyInterface) == 0x000001, "Wrong alignment on IAbilitySystemReplicationProxyInterface");
static_assert(sizeof(IAbilitySystemReplicationProxyInterface) == 0x000001, "Wrong size on IAbilitySystemReplicationProxyInterface");

// Class GameplayAbilities.AttributeSet
// 0x0008 (0x0030 - 0x0028)
class UAttributeSet : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AttributeSet">();
	}
	static class UAttributeSet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAttributeSet>();
	}
};
static_assert(alignof(UAttributeSet) == 0x000008, "Wrong alignment on UAttributeSet");
static_assert(sizeof(UAttributeSet) == 0x000030, "Wrong size on UAttributeSet");

// Class GameplayAbilities.AbilitySystemTestAttributeSet
// 0x0040 (0x0070 - 0x0030)
class UAbilitySystemTestAttributeSet final : public UAttributeSet
{
public:
	float                                         MaxHealth;                                         // 0x0030(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Health;                                            // 0x0034(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Mana;                                              // 0x0038(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         MaxMana;                                           // 0x003C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Damage;                                            // 0x0040(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         SpellDamage;                                       // 0x0044(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PhysicalDamage;                                    // 0x0048(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CritChance;                                        // 0x004C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         CritMultiplier;                                    // 0x0050(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ArmorDamageReduction;                              // 0x0054(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         DodgeChance;                                       // 0x0058(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LifeSteal;                                         // 0x005C(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Strength;                                          // 0x0060(0x0004)(Edit, BlueprintVisible, Net, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StackingAttribute1;                                // 0x0064(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StackingAttribute2;                                // 0x0068(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         NoStackAttribute;                                  // 0x006C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemTestAttributeSet">();
	}
	static class UAbilitySystemTestAttributeSet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilitySystemTestAttributeSet>();
	}
};
static_assert(alignof(UAbilitySystemTestAttributeSet) == 0x000008, "Wrong alignment on UAbilitySystemTestAttributeSet");
static_assert(sizeof(UAbilitySystemTestAttributeSet) == 0x000070, "Wrong size on UAbilitySystemTestAttributeSet");
static_assert(offsetof(UAbilitySystemTestAttributeSet, MaxHealth) == 0x000030, "Member 'UAbilitySystemTestAttributeSet::MaxHealth' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, Health) == 0x000034, "Member 'UAbilitySystemTestAttributeSet::Health' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, Mana) == 0x000038, "Member 'UAbilitySystemTestAttributeSet::Mana' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, MaxMana) == 0x00003C, "Member 'UAbilitySystemTestAttributeSet::MaxMana' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, Damage) == 0x000040, "Member 'UAbilitySystemTestAttributeSet::Damage' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, SpellDamage) == 0x000044, "Member 'UAbilitySystemTestAttributeSet::SpellDamage' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, PhysicalDamage) == 0x000048, "Member 'UAbilitySystemTestAttributeSet::PhysicalDamage' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, CritChance) == 0x00004C, "Member 'UAbilitySystemTestAttributeSet::CritChance' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, CritMultiplier) == 0x000050, "Member 'UAbilitySystemTestAttributeSet::CritMultiplier' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, ArmorDamageReduction) == 0x000054, "Member 'UAbilitySystemTestAttributeSet::ArmorDamageReduction' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, DodgeChance) == 0x000058, "Member 'UAbilitySystemTestAttributeSet::DodgeChance' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, LifeSteal) == 0x00005C, "Member 'UAbilitySystemTestAttributeSet::LifeSteal' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, Strength) == 0x000060, "Member 'UAbilitySystemTestAttributeSet::Strength' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, StackingAttribute1) == 0x000064, "Member 'UAbilitySystemTestAttributeSet::StackingAttribute1' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, StackingAttribute2) == 0x000068, "Member 'UAbilitySystemTestAttributeSet::StackingAttribute2' has a wrong offset!");
static_assert(offsetof(UAbilitySystemTestAttributeSet, NoStackAttribute) == 0x00006C, "Member 'UAbilitySystemTestAttributeSet::NoStackAttribute' has a wrong offset!");

// Class GameplayAbilities.AbilitySystemTestPawn
// 0x0020 (0x02C8 - 0x02A8)
class AAbilitySystemTestPawn final : public ADefaultPawn
{
public:
	uint8                                         Pad_2A8[0x18];                                     // 0x02A8(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                AbilitySystemComponent;                            // 0x02C0(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, EditConst, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilitySystemTestPawn">();
	}
	static class AAbilitySystemTestPawn* GetDefaultObj()
	{
		return GetDefaultObjImpl<AAbilitySystemTestPawn>();
	}
};
static_assert(alignof(AAbilitySystemTestPawn) == 0x000008, "Wrong alignment on AAbilitySystemTestPawn");
static_assert(sizeof(AAbilitySystemTestPawn) == 0x0002C8, "Wrong size on AAbilitySystemTestPawn");
static_assert(offsetof(AAbilitySystemTestPawn, AbilitySystemComponent) == 0x0002C0, "Member 'AAbilitySystemTestPawn::AbilitySystemComponent' has a wrong offset!");

// Class GameplayAbilities.AbilityTask
// 0x0018 (0x0080 - 0x0068)
class UAbilityTask : public UGameplayTask
{
public:
	class UGameplayAbility*                       Ability;                                           // 0x0068(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UAbilitySystemComponent*                AbilitySystemComponent;                            // 0x0070(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_78[0x8];                                       // 0x0078(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask">();
	}
	static class UAbilityTask* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask>();
	}
};
static_assert(alignof(UAbilityTask) == 0x000008, "Wrong alignment on UAbilityTask");
static_assert(sizeof(UAbilityTask) == 0x000080, "Wrong size on UAbilityTask");
static_assert(offsetof(UAbilityTask, Ability) == 0x000068, "Member 'UAbilityTask::Ability' has a wrong offset!");
static_assert(offsetof(UAbilityTask, AbilitySystemComponent) == 0x000070, "Member 'UAbilityTask::AbilitySystemComponent' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotion_Base
// 0x0038 (0x00B8 - 0x0080)
class UAbilityTask_ApplyRootMotion_Base : public UAbilityTask
{
public:
	class FName                                   ForceName;                                         // 0x0080(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ERootMotionFinishVelocityMode                 FinishVelocityMode;                                // 0x0088(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                FinishSetVelocity;                                 // 0x008C(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         FinishClampVelocity;                               // 0x0098(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_9C[0x4];                                       // 0x009C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class UCharacterMovementComponent*            MovementComponent;                                 // 0x00A0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_A8[0x10];                                      // 0x00A8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotion_Base">();
	}
	static class UAbilityTask_ApplyRootMotion_Base* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotion_Base>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotion_Base) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotion_Base");
static_assert(sizeof(UAbilityTask_ApplyRootMotion_Base) == 0x0000B8, "Wrong size on UAbilityTask_ApplyRootMotion_Base");
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, ForceName) == 0x000080, "Member 'UAbilityTask_ApplyRootMotion_Base::ForceName' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishVelocityMode) == 0x000088, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishVelocityMode' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishSetVelocity) == 0x00008C, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishSetVelocity' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, FinishClampVelocity) == 0x000098, "Member 'UAbilityTask_ApplyRootMotion_Base::FinishClampVelocity' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotion_Base, MovementComponent) == 0x0000A0, "Member 'UAbilityTask_ApplyRootMotion_Base::MovementComponent' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotionConstantForce
// 0x0038 (0x00F0 - 0x00B8)
class UAbilityTask_ApplyRootMotionConstantForce final : public UAbilityTask_ApplyRootMotion_Base
{
public:
	TMulticastInlineDelegate<void()>              OnFinish;                                          // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FVector                                WorldDirection;                                    // 0x00C8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Strength;                                          // 0x00D4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Duration;                                          // 0x00D8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsAdditive;                                       // 0x00DC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_DD[0x3];                                       // 0x00DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveFloat*                            StrengthOverTime;                                  // 0x00E0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bEnableGravity;                                    // 0x00E8(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_E9[0x7];                                       // 0x00E9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_ApplyRootMotionConstantForce* ApplyRootMotionConstantForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& WorldDirection_0, float Strength_0, float Duration_0, bool bIsAdditive_0, class UCurveFloat* StrengthOverTime_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bEnableGravity_0);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotionConstantForce">();
	}
	static class UAbilityTask_ApplyRootMotionConstantForce* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionConstantForce>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotionConstantForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionConstantForce");
static_assert(sizeof(UAbilityTask_ApplyRootMotionConstantForce) == 0x0000F0, "Wrong size on UAbilityTask_ApplyRootMotionConstantForce");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::OnFinish' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, WorldDirection) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::WorldDirection' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, Strength) == 0x0000D4, "Member 'UAbilityTask_ApplyRootMotionConstantForce::Strength' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, Duration) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::Duration' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, bIsAdditive) == 0x0000DC, "Member 'UAbilityTask_ApplyRootMotionConstantForce::bIsAdditive' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, StrengthOverTime) == 0x0000E0, "Member 'UAbilityTask_ApplyRootMotionConstantForce::StrengthOverTime' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionConstantForce, bEnableGravity) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionConstantForce::bEnableGravity' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotionJumpForce
// 0x0058 (0x0110 - 0x00B8)
class UAbilityTask_ApplyRootMotionJumpForce final : public UAbilityTask_ApplyRootMotion_Base
{
public:
	TMulticastInlineDelegate<void()>              OnFinish;                                          // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnLanded;                                          // 0x00C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FRotator                               Rotation;                                          // 0x00D8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)
	float                                         Distance;                                          // 0x00E4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Height;                                            // 0x00E8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Duration;                                          // 0x00EC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         MinimumLandedTriggerTime;                          // 0x00F0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bFinishOnLanded;                                   // 0x00F4(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_F5[0x3];                                       // 0x00F5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveVector*                           PathOffsetCurve;                                   // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveFloat*                            TimeMappingCurve;                                  // 0x0100(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_108[0x8];                                      // 0x0108(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_ApplyRootMotionJumpForce* ApplyRootMotionJumpForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FRotator& Rotation_0, float Distance_0, float Height_0, float Duration_0, float MinimumLandedTriggerTime_0, bool bFinishOnLanded_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0);

	void Finish();
	void OnLandedCallback(const struct FHitResult& Hit);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotionJumpForce">();
	}
	static class UAbilityTask_ApplyRootMotionJumpForce* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionJumpForce>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotionJumpForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionJumpForce");
static_assert(sizeof(UAbilityTask_ApplyRootMotionJumpForce) == 0x000110, "Wrong size on UAbilityTask_ApplyRootMotionJumpForce");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::OnFinish' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, OnLanded) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::OnLanded' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Rotation) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Rotation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Distance) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Distance' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Height) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Height' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, Duration) == 0x0000EC, "Member 'UAbilityTask_ApplyRootMotionJumpForce::Duration' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, MinimumLandedTriggerTime) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionJumpForce::MinimumLandedTriggerTime' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, bFinishOnLanded) == 0x0000F4, "Member 'UAbilityTask_ApplyRootMotionJumpForce::bFinishOnLanded' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, PathOffsetCurve) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionJumpForce::PathOffsetCurve' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionJumpForce, TimeMappingCurve) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionJumpForce::TimeMappingCurve' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotionMoveToActorForce
// 0x0078 (0x0130 - 0x00B8)
class UAbilityTask_ApplyRootMotionMoveToActorForce : public UAbilityTask_ApplyRootMotion_Base
{
public:
	TMulticastInlineDelegate<void(bool DestinationReached, bool TimedOut, const struct FVector& FinalTargetLocation)> OnFinished; // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_C8[0x8];                                       // 0x00C8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                StartLocation;                                     // 0x00D0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                TargetLocation;                                    // 0x00DC(0x000C)(Net, ZeroConstructor, IsPlainOldData, RepNotify, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 TargetActor;                                       // 0x00E8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                TargetLocationOffset;                              // 0x00F0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	ERootMotionMoveToActorTargetOffsetType        OffsetAlignment;                                   // 0x00FC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_FD[0x3];                                       // 0x00FD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         Duration;                                          // 0x0100(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bDisableDestinationReachedInterrupt;               // 0x0104(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bSetNewMovementMode;                               // 0x0105(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EMovementMode                                 NewMovementMode;                                   // 0x0106(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bRestrictSpeedToExpected;                          // 0x0107(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveVector*                           PathOffsetCurve;                                   // 0x0108(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveFloat*                            TimeMappingCurve;                                  // 0x0110(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveFloat*                            TargetLerpSpeedHorizontalCurve;                    // 0x0118(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveFloat*                            TargetLerpSpeedVerticalCurve;                      // 0x0120(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_128[0x8];                                      // 0x0128(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_ApplyRootMotionMoveToActorForce* ApplyRootMotionMoveToActorForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class AActor* TargetActor_0, const struct FVector& TargetLocationOffset_0, ERootMotionMoveToActorTargetOffsetType OffsetAlignment_0, float Duration_0, class UCurveFloat* TargetLerpSpeedHorizontal, class UCurveFloat* TargetLerpSpeedVertical, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bDisableDestinationReachedInterrupt_0);
	static class UAbilityTask_ApplyRootMotionMoveToActorForce* ApplyRootMotionMoveToTargetDataActorForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FGameplayAbilityTargetDataHandle& TargetDataHandle, int32 TargetDataIndex, int32 TargetActorIndex, const struct FVector& TargetLocationOffset_0, ERootMotionMoveToActorTargetOffsetType OffsetAlignment_0, float Duration_0, class UCurveFloat* TargetLerpSpeedHorizontal, class UCurveFloat* TargetLerpSpeedVertical, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, class UCurveFloat* TimeMappingCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish, bool bDisableDestinationReachedInterrupt_0);

	void OnRep_TargetLocation();
	void OnTargetActorSwapped(class AActor* OriginalTarget, class AActor* NewTarget);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotionMoveToActorForce">();
	}
	static class UAbilityTask_ApplyRootMotionMoveToActorForce* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionMoveToActorForce>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotionMoveToActorForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionMoveToActorForce");
static_assert(sizeof(UAbilityTask_ApplyRootMotionMoveToActorForce) == 0x000130, "Wrong size on UAbilityTask_ApplyRootMotionMoveToActorForce");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, OnFinished) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::OnFinished' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, StartLocation) == 0x0000D0, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::StartLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLocation) == 0x0000DC, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetActor) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetActor' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLocationOffset) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLocationOffset' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, OffsetAlignment) == 0x0000FC, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::OffsetAlignment' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, Duration) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::Duration' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bDisableDestinationReachedInterrupt) == 0x000104, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bDisableDestinationReachedInterrupt' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bSetNewMovementMode) == 0x000105, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bSetNewMovementMode' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, NewMovementMode) == 0x000106, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::NewMovementMode' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, bRestrictSpeedToExpected) == 0x000107, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::bRestrictSpeedToExpected' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, PathOffsetCurve) == 0x000108, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::PathOffsetCurve' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TimeMappingCurve) == 0x000110, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TimeMappingCurve' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLerpSpeedHorizontalCurve) == 0x000118, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLerpSpeedHorizontalCurve' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToActorForce, TargetLerpSpeedVerticalCurve) == 0x000120, "Member 'UAbilityTask_ApplyRootMotionMoveToActorForce::TargetLerpSpeedVerticalCurve' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotionMoveToForce
// 0x0050 (0x0108 - 0x00B8)
class UAbilityTask_ApplyRootMotionMoveToForce : public UAbilityTask_ApplyRootMotion_Base
{
public:
	TMulticastInlineDelegate<void()>              OnTimedOut;                                        // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnTimedOutAndDestinationReached;                   // 0x00C8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FVector                                StartLocation;                                     // 0x00D8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                TargetLocation;                                    // 0x00E4(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Duration;                                          // 0x00F0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bSetNewMovementMode;                               // 0x00F4(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EMovementMode                                 NewMovementMode;                                   // 0x00F5(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bRestrictSpeedToExpected;                          // 0x00F6(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_F7[0x1];                                       // 0x00F7(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveVector*                           PathOffsetCurve;                                   // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_100[0x8];                                      // 0x0100(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_ApplyRootMotionMoveToForce* ApplyRootMotionMoveToForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& TargetLocation_0, float Duration_0, bool bSetNewMovementMode_0, EMovementMode MovementMode, bool bRestrictSpeedToExpected_0, class UCurveVector* PathOffsetCurve_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotionMoveToForce">();
	}
	static class UAbilityTask_ApplyRootMotionMoveToForce* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionMoveToForce>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotionMoveToForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionMoveToForce");
static_assert(sizeof(UAbilityTask_ApplyRootMotionMoveToForce) == 0x000108, "Wrong size on UAbilityTask_ApplyRootMotionMoveToForce");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, OnTimedOut) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::OnTimedOut' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, OnTimedOutAndDestinationReached) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::OnTimedOutAndDestinationReached' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, StartLocation) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::StartLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, TargetLocation) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::TargetLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, Duration) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::Duration' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, bSetNewMovementMode) == 0x0000F4, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::bSetNewMovementMode' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, NewMovementMode) == 0x0000F5, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::NewMovementMode' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, bRestrictSpeedToExpected) == 0x0000F6, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::bRestrictSpeedToExpected' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionMoveToForce, PathOffsetCurve) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionMoveToForce::PathOffsetCurve' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_ApplyRootMotionRadialForce
// 0x0058 (0x0110 - 0x00B8)
class UAbilityTask_ApplyRootMotionRadialForce final : public UAbilityTask_ApplyRootMotion_Base
{
public:
	TMulticastInlineDelegate<void()>              OnFinish;                                          // 0x00B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	struct FVector                                Location;                                          // 0x00C8(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_D4[0x4];                                       // 0x00D4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class AActor*                                 LocationActor;                                     // 0x00D8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Strength;                                          // 0x00E0(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Duration;                                          // 0x00E4(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Radius;                                            // 0x00E8(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsPush;                                           // 0x00EC(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsAdditive;                                       // 0x00ED(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bNoZForce;                                         // 0x00EE(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_EF[0x1];                                       // 0x00EF(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveFloat*                            StrengthDistanceFalloff;                           // 0x00F0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveFloat*                            StrengthOverTime;                                  // 0x00F8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bUseFixedWorldDirection;                           // 0x0100(0x0001)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_101[0x3];                                      // 0x0101(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRotator                               FixedWorldDirection;                               // 0x0104(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, NativeAccessSpecifierProtected)

public:
	static class UAbilityTask_ApplyRootMotionRadialForce* ApplyRootMotionRadialForce(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& Location_0, class AActor* LocationActor_0, float Strength_0, float Duration_0, float Radius_0, bool bIsPush_0, bool bIsAdditive_0, bool bNoZForce_0, class UCurveFloat* StrengthDistanceFalloff_0, class UCurveFloat* StrengthOverTime_0, bool bUseFixedWorldDirection_0, const struct FRotator& FixedWorldDirection_0, ERootMotionFinishVelocityMode VelocityOnFinishMode, const struct FVector& SetVelocityOnFinish, float ClampVelocityOnFinish);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_ApplyRootMotionRadialForce">();
	}
	static class UAbilityTask_ApplyRootMotionRadialForce* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_ApplyRootMotionRadialForce>();
	}
};
static_assert(alignof(UAbilityTask_ApplyRootMotionRadialForce) == 0x000008, "Wrong alignment on UAbilityTask_ApplyRootMotionRadialForce");
static_assert(sizeof(UAbilityTask_ApplyRootMotionRadialForce) == 0x000110, "Wrong size on UAbilityTask_ApplyRootMotionRadialForce");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, OnFinish) == 0x0000B8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::OnFinish' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Location) == 0x0000C8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Location' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, LocationActor) == 0x0000D8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::LocationActor' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Strength) == 0x0000E0, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Strength' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Duration) == 0x0000E4, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Duration' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, Radius) == 0x0000E8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::Radius' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bIsPush) == 0x0000EC, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bIsPush' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bIsAdditive) == 0x0000ED, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bIsAdditive' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bNoZForce) == 0x0000EE, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bNoZForce' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, StrengthDistanceFalloff) == 0x0000F0, "Member 'UAbilityTask_ApplyRootMotionRadialForce::StrengthDistanceFalloff' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, StrengthOverTime) == 0x0000F8, "Member 'UAbilityTask_ApplyRootMotionRadialForce::StrengthOverTime' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, bUseFixedWorldDirection) == 0x000100, "Member 'UAbilityTask_ApplyRootMotionRadialForce::bUseFixedWorldDirection' has a wrong offset!");
static_assert(offsetof(UAbilityTask_ApplyRootMotionRadialForce, FixedWorldDirection) == 0x000104, "Member 'UAbilityTask_ApplyRootMotionRadialForce::FixedWorldDirection' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_MoveToLocation
// 0x0048 (0x00C8 - 0x0080)
class UAbilityTask_MoveToLocation final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnTargetLocationReached;                           // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x4];                                       // 0x0090(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FVector                                StartLocation;                                     // 0x0094(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FVector                                TargetLocation;                                    // 0x00A0(0x000C)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         DurationOfMovement;                                // 0x00AC(0x0004)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_B0[0x8];                                       // 0x00B0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UCurveFloat*                            LerpCurve;                                         // 0x00B8(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class UCurveVector*                           LerpCurveVector;                                   // 0x00C0(0x0008)(Net, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UAbilityTask_MoveToLocation* MoveToLocation(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, const struct FVector& Location, float Duration, class UCurveFloat* OptionalInterpolationCurve, class UCurveVector* OptionalVectorInterpolationCurve);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_MoveToLocation">();
	}
	static class UAbilityTask_MoveToLocation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_MoveToLocation>();
	}
};
static_assert(alignof(UAbilityTask_MoveToLocation) == 0x000008, "Wrong alignment on UAbilityTask_MoveToLocation");
static_assert(sizeof(UAbilityTask_MoveToLocation) == 0x0000C8, "Wrong size on UAbilityTask_MoveToLocation");
static_assert(offsetof(UAbilityTask_MoveToLocation, OnTargetLocationReached) == 0x000080, "Member 'UAbilityTask_MoveToLocation::OnTargetLocationReached' has a wrong offset!");
static_assert(offsetof(UAbilityTask_MoveToLocation, StartLocation) == 0x000094, "Member 'UAbilityTask_MoveToLocation::StartLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_MoveToLocation, TargetLocation) == 0x0000A0, "Member 'UAbilityTask_MoveToLocation::TargetLocation' has a wrong offset!");
static_assert(offsetof(UAbilityTask_MoveToLocation, DurationOfMovement) == 0x0000AC, "Member 'UAbilityTask_MoveToLocation::DurationOfMovement' has a wrong offset!");
static_assert(offsetof(UAbilityTask_MoveToLocation, LerpCurve) == 0x0000B8, "Member 'UAbilityTask_MoveToLocation::LerpCurve' has a wrong offset!");
static_assert(offsetof(UAbilityTask_MoveToLocation, LerpCurveVector) == 0x0000C0, "Member 'UAbilityTask_MoveToLocation::LerpCurveVector' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_NetworkSyncPoint
// 0x0018 (0x0098 - 0x0080)
class UAbilityTask_NetworkSyncPoint final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnSync;                                            // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_NetworkSyncPoint* WaitNetSync(class UGameplayAbility* OwningAbility, EAbilityTaskNetSyncType SyncType);

	void OnSignalCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_NetworkSyncPoint">();
	}
	static class UAbilityTask_NetworkSyncPoint* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_NetworkSyncPoint>();
	}
};
static_assert(alignof(UAbilityTask_NetworkSyncPoint) == 0x000008, "Wrong alignment on UAbilityTask_NetworkSyncPoint");
static_assert(sizeof(UAbilityTask_NetworkSyncPoint) == 0x000098, "Wrong size on UAbilityTask_NetworkSyncPoint");
static_assert(offsetof(UAbilityTask_NetworkSyncPoint, OnSync) == 0x000080, "Member 'UAbilityTask_NetworkSyncPoint::OnSync' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_PlayMontageAndWait
// 0x0088 (0x0108 - 0x0080)
class UAbilityTask_PlayMontageAndWait : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnCompleted;                                       // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnBlendOut;                                        // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnInterrupted;                                     // 0x00A0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnCancelled;                                       // 0x00B0(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_C0[0x28];                                      // 0x00C0(0x0028)(Fixing Size After Last Property [ Dumper-7 ])
	class UAnimMontage*                           MontageToPlay;                                     // 0x00E8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         Rate;                                              // 0x00F0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class FName                                   StartSection;                                      // 0x00F4(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         AnimRootMotionTranslationScale;                    // 0x00FC(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	float                                         StartTimeSeconds;                                  // 0x0100(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bStopWhenAbilityEnds;                              // 0x0104(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_105[0x3];                                      // 0x0105(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_PlayMontageAndWait* CreatePlayMontageAndWaitProxy(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, class UAnimMontage* MontageToPlay_0, float Rate_0, class FName StartSection_0, bool bStopWhenAbilityEnds_0, float AnimRootMotionTranslationScale_0, float StartTimeSeconds_0);

	void OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted);
	void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
	void OnMontageInterrupted();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_PlayMontageAndWait">();
	}
	static class UAbilityTask_PlayMontageAndWait* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_PlayMontageAndWait>();
	}
};
static_assert(alignof(UAbilityTask_PlayMontageAndWait) == 0x000008, "Wrong alignment on UAbilityTask_PlayMontageAndWait");
static_assert(sizeof(UAbilityTask_PlayMontageAndWait) == 0x000108, "Wrong size on UAbilityTask_PlayMontageAndWait");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnCompleted) == 0x000080, "Member 'UAbilityTask_PlayMontageAndWait::OnCompleted' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnBlendOut) == 0x000090, "Member 'UAbilityTask_PlayMontageAndWait::OnBlendOut' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnInterrupted) == 0x0000A0, "Member 'UAbilityTask_PlayMontageAndWait::OnInterrupted' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, OnCancelled) == 0x0000B0, "Member 'UAbilityTask_PlayMontageAndWait::OnCancelled' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, MontageToPlay) == 0x0000E8, "Member 'UAbilityTask_PlayMontageAndWait::MontageToPlay' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, Rate) == 0x0000F0, "Member 'UAbilityTask_PlayMontageAndWait::Rate' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, StartSection) == 0x0000F4, "Member 'UAbilityTask_PlayMontageAndWait::StartSection' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, AnimRootMotionTranslationScale) == 0x0000FC, "Member 'UAbilityTask_PlayMontageAndWait::AnimRootMotionTranslationScale' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, StartTimeSeconds) == 0x000100, "Member 'UAbilityTask_PlayMontageAndWait::StartTimeSeconds' has a wrong offset!");
static_assert(offsetof(UAbilityTask_PlayMontageAndWait, bStopWhenAbilityEnds) == 0x000104, "Member 'UAbilityTask_PlayMontageAndWait::bStopWhenAbilityEnds' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_Repeat
// 0x0038 (0x00B8 - 0x0080)
class UAbilityTask_Repeat final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(int32 ActionNumber)> OnPerformAction;                              // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(int32 ActionNumber)> OnFinished;                                   // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x18];                                      // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_Repeat* RepeatAction(class UGameplayAbility* OwningAbility, float TimeBetweenActions, int32 TotalActionCount);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_Repeat">();
	}
	static class UAbilityTask_Repeat* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_Repeat>();
	}
};
static_assert(alignof(UAbilityTask_Repeat) == 0x000008, "Wrong alignment on UAbilityTask_Repeat");
static_assert(sizeof(UAbilityTask_Repeat) == 0x0000B8, "Wrong size on UAbilityTask_Repeat");
static_assert(offsetof(UAbilityTask_Repeat, OnPerformAction) == 0x000080, "Member 'UAbilityTask_Repeat::OnPerformAction' has a wrong offset!");
static_assert(offsetof(UAbilityTask_Repeat, OnFinished) == 0x000090, "Member 'UAbilityTask_Repeat::OnFinished' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_SpawnActor
// 0x0048 (0x00C8 - 0x0080)
class UAbilityTask_SpawnActor final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(class AActor* SpawnedActor)> Success;                              // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(class AActor* SpawnedActor)> DidNotSpawn;                          // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x28];                                      // 0x00A0(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_SpawnActor* SpawnActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0);

	bool BeginSpawningActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class AActor> Class_0, class AActor** SpawnedActor);
	void FinishSpawningActor(class UGameplayAbility* OwningAbility, const struct FGameplayAbilityTargetDataHandle& TargetData, class AActor* SpawnedActor);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_SpawnActor">();
	}
	static class UAbilityTask_SpawnActor* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_SpawnActor>();
	}
};
static_assert(alignof(UAbilityTask_SpawnActor) == 0x000008, "Wrong alignment on UAbilityTask_SpawnActor");
static_assert(sizeof(UAbilityTask_SpawnActor) == 0x0000C8, "Wrong size on UAbilityTask_SpawnActor");
static_assert(offsetof(UAbilityTask_SpawnActor, Success) == 0x000080, "Member 'UAbilityTask_SpawnActor::Success' has a wrong offset!");
static_assert(offsetof(UAbilityTask_SpawnActor, DidNotSpawn) == 0x000090, "Member 'UAbilityTask_SpawnActor::DidNotSpawn' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_StartAbilityState
// 0x0038 (0x00B8 - 0x0080)
class UAbilityTask_StartAbilityState final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnStateEnded;                                      // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnStateInterrupted;                                // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x18];                                      // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_StartAbilityState* StartAbilityState(class UGameplayAbility* OwningAbility, class FName StateName, bool bEndCurrentState);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_StartAbilityState">();
	}
	static class UAbilityTask_StartAbilityState* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_StartAbilityState>();
	}
};
static_assert(alignof(UAbilityTask_StartAbilityState) == 0x000008, "Wrong alignment on UAbilityTask_StartAbilityState");
static_assert(sizeof(UAbilityTask_StartAbilityState) == 0x0000B8, "Wrong size on UAbilityTask_StartAbilityState");
static_assert(offsetof(UAbilityTask_StartAbilityState, OnStateEnded) == 0x000080, "Member 'UAbilityTask_StartAbilityState::OnStateEnded' has a wrong offset!");
static_assert(offsetof(UAbilityTask_StartAbilityState, OnStateInterrupted) == 0x000090, "Member 'UAbilityTask_StartAbilityState::OnStateInterrupted' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_VisualizeTargeting
// 0x0028 (0x00A8 - 0x0080)
class UAbilityTask_VisualizeTargeting final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              TimeElapsed;                                       // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x18];                                      // 0x0090(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_VisualizeTargeting* VisualizeTargeting(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class FName TaskInstanceName, float Duration);
	static class UAbilityTask_VisualizeTargeting* VisualizeTargetingUsingActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* TargetActor, class FName TaskInstanceName, float Duration);

	bool BeginSpawningActor(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor);
	void FinishSpawningActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* SpawnedActor);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_VisualizeTargeting">();
	}
	static class UAbilityTask_VisualizeTargeting* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_VisualizeTargeting>();
	}
};
static_assert(alignof(UAbilityTask_VisualizeTargeting) == 0x000008, "Wrong alignment on UAbilityTask_VisualizeTargeting");
static_assert(sizeof(UAbilityTask_VisualizeTargeting) == 0x0000A8, "Wrong size on UAbilityTask_VisualizeTargeting");
static_assert(offsetof(UAbilityTask_VisualizeTargeting, TimeElapsed) == 0x000080, "Member 'UAbilityTask_VisualizeTargeting::TimeElapsed' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitAbilityActivate
// 0x00B8 (0x0138 - 0x0080)
class UAbilityTask_WaitAbilityActivate final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(class UGameplayAbility* ActivatedAbility)> OnActivate;             // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0xA8];                                      // 0x0090(0x00A8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivate(class UGameplayAbility* OwningAbility, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTag, bool IncludeTriggeredAbilities, bool TriggerOnce);
	static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivate_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTagQuery& Query, bool IncludeTriggeredAbilities, bool TriggerOnce);
	static class UAbilityTask_WaitAbilityActivate* WaitForAbilityActivateWithTagRequirements(class UGameplayAbility* OwningAbility, const struct FGameplayTagRequirements& TagRequirements, bool IncludeTriggeredAbilities, bool TriggerOnce);

	void OnAbilityActivate(class UGameplayAbility* ActivatedAbility);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitAbilityActivate">();
	}
	static class UAbilityTask_WaitAbilityActivate* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitAbilityActivate>();
	}
};
static_assert(alignof(UAbilityTask_WaitAbilityActivate) == 0x000008, "Wrong alignment on UAbilityTask_WaitAbilityActivate");
static_assert(sizeof(UAbilityTask_WaitAbilityActivate) == 0x000138, "Wrong size on UAbilityTask_WaitAbilityActivate");
static_assert(offsetof(UAbilityTask_WaitAbilityActivate, OnActivate) == 0x000080, "Member 'UAbilityTask_WaitAbilityActivate::OnActivate' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitAbilityCommit
// 0x0078 (0x00F8 - 0x0080)
class UAbilityTask_WaitAbilityCommit final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(class UGameplayAbility* ActivatedAbility)> OnCommit;               // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x68];                                      // 0x0090(0x0068)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitAbilityCommit* WaitForAbilityCommit(class UGameplayAbility* OwningAbility, const struct FGameplayTag& WithTag, const struct FGameplayTag& WithoutTage, bool TriggerOnce);
	static class UAbilityTask_WaitAbilityCommit* WaitForAbilityCommit_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTagQuery& Query, bool TriggerOnce);

	void OnAbilityCommit(class UGameplayAbility* ActivatedAbility);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitAbilityCommit">();
	}
	static class UAbilityTask_WaitAbilityCommit* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitAbilityCommit>();
	}
};
static_assert(alignof(UAbilityTask_WaitAbilityCommit) == 0x000008, "Wrong alignment on UAbilityTask_WaitAbilityCommit");
static_assert(sizeof(UAbilityTask_WaitAbilityCommit) == 0x0000F8, "Wrong size on UAbilityTask_WaitAbilityCommit");
static_assert(offsetof(UAbilityTask_WaitAbilityCommit, OnCommit) == 0x000080, "Member 'UAbilityTask_WaitAbilityCommit::OnCommit' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitAttributeChange
// 0x0078 (0x00F8 - 0x0080)
class UAbilityTask_WaitAttributeChange final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnChange;                                          // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x60];                                      // 0x0090(0x0060)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                ExternalOwner;                                     // 0x00F0(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UAbilityTask_WaitAttributeChange* WaitForAttributeChange(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& Attribute, const struct FGameplayTag& WithSrcTag, const struct FGameplayTag& WithoutSrcTag, bool TriggerOnce, class AActor* OptionalExternalOwner);
	static class UAbilityTask_WaitAttributeChange* WaitForAttributeChangeWithComparison(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& InAttribute, const struct FGameplayTag& InWithTag, const struct FGameplayTag& InWithoutTag, EWaitAttributeChangeComparison InComparisonType, float InComparisonValue, bool TriggerOnce, class AActor* OptionalExternalOwner);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitAttributeChange">();
	}
	static class UAbilityTask_WaitAttributeChange* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitAttributeChange>();
	}
};
static_assert(alignof(UAbilityTask_WaitAttributeChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChange");
static_assert(sizeof(UAbilityTask_WaitAttributeChange) == 0x0000F8, "Wrong size on UAbilityTask_WaitAttributeChange");
static_assert(offsetof(UAbilityTask_WaitAttributeChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChange::OnChange' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitAttributeChange, ExternalOwner) == 0x0000F0, "Member 'UAbilityTask_WaitAttributeChange::ExternalOwner' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitAttributeChangeRatioThreshold
// 0x00C0 (0x0140 - 0x0080)
class UAbilityTask_WaitAttributeChangeRatioThreshold final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(bool bMatchesComparison, float CurrentRatio)> OnChange;            // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0xA8];                                      // 0x0090(0x00A8)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                ExternalOwner;                                     // 0x0138(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UAbilityTask_WaitAttributeChangeRatioThreshold* WaitForAttributeChangeRatioThreshold(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& AttributeNumerator, const struct FGameplayAttribute& AttributeDenominator, EWaitAttributeChangeComparison ComparisonType, float ComparisonValue, bool bTriggerOnce, class AActor* OptionalExternalOwner);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitAttributeChangeRatioThreshold">();
	}
	static class UAbilityTask_WaitAttributeChangeRatioThreshold* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitAttributeChangeRatioThreshold>();
	}
};
static_assert(alignof(UAbilityTask_WaitAttributeChangeRatioThreshold) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChangeRatioThreshold");
static_assert(sizeof(UAbilityTask_WaitAttributeChangeRatioThreshold) == 0x000140, "Wrong size on UAbilityTask_WaitAttributeChangeRatioThreshold");
static_assert(offsetof(UAbilityTask_WaitAttributeChangeRatioThreshold, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChangeRatioThreshold::OnChange' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitAttributeChangeRatioThreshold, ExternalOwner) == 0x000138, "Member 'UAbilityTask_WaitAttributeChangeRatioThreshold::ExternalOwner' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitAttributeChangeThreshold
// 0x0070 (0x00F0 - 0x0080)
class UAbilityTask_WaitAttributeChangeThreshold final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(bool bMatchesComparison, float CurrentValue)> OnChange;            // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x58];                                      // 0x0090(0x0058)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                ExternalOwner;                                     // 0x00E8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UAbilityTask_WaitAttributeChangeThreshold* WaitForAttributeChangeThreshold(class UGameplayAbility* OwningAbility, const struct FGameplayAttribute& Attribute, EWaitAttributeChangeComparison ComparisonType, float ComparisonValue, bool bTriggerOnce, class AActor* OptionalExternalOwner);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitAttributeChangeThreshold">();
	}
	static class UAbilityTask_WaitAttributeChangeThreshold* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitAttributeChangeThreshold>();
	}
};
static_assert(alignof(UAbilityTask_WaitAttributeChangeThreshold) == 0x000008, "Wrong alignment on UAbilityTask_WaitAttributeChangeThreshold");
static_assert(sizeof(UAbilityTask_WaitAttributeChangeThreshold) == 0x0000F0, "Wrong size on UAbilityTask_WaitAttributeChangeThreshold");
static_assert(offsetof(UAbilityTask_WaitAttributeChangeThreshold, OnChange) == 0x000080, "Member 'UAbilityTask_WaitAttributeChangeThreshold::OnChange' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitAttributeChangeThreshold, ExternalOwner) == 0x0000E8, "Member 'UAbilityTask_WaitAttributeChangeThreshold::ExternalOwner' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitCancel
// 0x0018 (0x0098 - 0x0080)
class UAbilityTask_WaitCancel final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnCancel;                                          // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitCancel* WaitCancel(class UGameplayAbility* OwningAbility);

	void OnCancelCallback();
	void OnLocalCancelCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitCancel">();
	}
	static class UAbilityTask_WaitCancel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitCancel>();
	}
};
static_assert(alignof(UAbilityTask_WaitCancel) == 0x000008, "Wrong alignment on UAbilityTask_WaitCancel");
static_assert(sizeof(UAbilityTask_WaitCancel) == 0x000098, "Wrong size on UAbilityTask_WaitCancel");
static_assert(offsetof(UAbilityTask_WaitCancel, OnCancel) == 0x000080, "Member 'UAbilityTask_WaitCancel::OnCancel' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitConfirm
// 0x0020 (0x00A0 - 0x0080)
class UAbilityTask_WaitConfirm final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnConfirm;                                         // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitConfirm* WaitConfirm(class UGameplayAbility* OwningAbility);

	void OnConfirmCallback(class UGameplayAbility* InAbility);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitConfirm">();
	}
	static class UAbilityTask_WaitConfirm* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitConfirm>();
	}
};
static_assert(alignof(UAbilityTask_WaitConfirm) == 0x000008, "Wrong alignment on UAbilityTask_WaitConfirm");
static_assert(sizeof(UAbilityTask_WaitConfirm) == 0x0000A0, "Wrong size on UAbilityTask_WaitConfirm");
static_assert(offsetof(UAbilityTask_WaitConfirm, OnConfirm) == 0x000080, "Member 'UAbilityTask_WaitConfirm::OnConfirm' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitConfirmCancel
// 0x0028 (0x00A8 - 0x0080)
class UAbilityTask_WaitConfirmCancel final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnConfirm;                                         // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void()>              OnCancel;                                          // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x8];                                       // 0x00A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitConfirmCancel* WaitConfirmCancel(class UGameplayAbility* OwningAbility);

	void OnCancelCallback();
	void OnConfirmCallback();
	void OnLocalCancelCallback();
	void OnLocalConfirmCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitConfirmCancel">();
	}
	static class UAbilityTask_WaitConfirmCancel* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitConfirmCancel>();
	}
};
static_assert(alignof(UAbilityTask_WaitConfirmCancel) == 0x000008, "Wrong alignment on UAbilityTask_WaitConfirmCancel");
static_assert(sizeof(UAbilityTask_WaitConfirmCancel) == 0x0000A8, "Wrong size on UAbilityTask_WaitConfirmCancel");
static_assert(offsetof(UAbilityTask_WaitConfirmCancel, OnConfirm) == 0x000080, "Member 'UAbilityTask_WaitConfirmCancel::OnConfirm' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitConfirmCancel, OnCancel) == 0x000090, "Member 'UAbilityTask_WaitConfirmCancel::OnCancel' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitDelay
// 0x0018 (0x0098 - 0x0080)
class UAbilityTask_WaitDelay final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnFinish;                                          // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitDelay* WaitDelay(class UGameplayAbility* OwningAbility, float Time);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitDelay">();
	}
	static class UAbilityTask_WaitDelay* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitDelay>();
	}
};
static_assert(alignof(UAbilityTask_WaitDelay) == 0x000008, "Wrong alignment on UAbilityTask_WaitDelay");
static_assert(sizeof(UAbilityTask_WaitDelay) == 0x000098, "Wrong size on UAbilityTask_WaitDelay");
static_assert(offsetof(UAbilityTask_WaitDelay, OnFinish) == 0x000080, "Member 'UAbilityTask_WaitDelay::OnFinish' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied
// 0x0138 (0x01B8 - 0x0080)
class UAbilityTask_WaitGameplayEffectApplied : public UAbilityTask
{
public:
	uint8                                         Pad_80[0x128];                                     // 0x0080(0x0128)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                ExternalOwner;                                     // 0x01A8(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1B0[0x8];                                      // 0x01B0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void OnApplyGameplayEffectCallback(class UAbilitySystemComponent* Target, const struct FGameplayEffectSpec& SpecApplied, const struct FActiveGameplayEffectHandle& ActiveHandle);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied">();
	}
	static class UAbilityTask_WaitGameplayEffectApplied* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied) == 0x0001B8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied, ExternalOwner) == 0x0001A8, "Member 'UAbilityTask_WaitGameplayEffectApplied::ExternalOwner' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Self
// 0x0020 (0x01D8 - 0x01B8)
class UAbilityTask_WaitGameplayEffectApplied_Self final : public UAbilityTask_WaitGameplayEffectApplied
{
public:
	TMulticastInlineDelegate<void(class AActor* Source, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x01B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C8[0x10];                                     // 0x01C8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEffectApplied_Self* WaitGameplayEffectAppliedToSelf(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);
	static class UAbilityTask_WaitGameplayEffectApplied_Self* WaitGameplayEffectAppliedToSelf_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagQuery& SourceTagQuery, const struct FGameplayTagQuery& TargetTagQuery, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied_Self">();
	}
	static class UAbilityTask_WaitGameplayEffectApplied_Self* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied_Self>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied_Self) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied_Self");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied_Self) == 0x0001D8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied_Self");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied_Self, OnApplied) == 0x0001B8, "Member 'UAbilityTask_WaitGameplayEffectApplied_Self::OnApplied' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectApplied_Target
// 0x0020 (0x01D8 - 0x01B8)
class UAbilityTask_WaitGameplayEffectApplied_Target final : public UAbilityTask_WaitGameplayEffectApplied
{
public:
	TMulticastInlineDelegate<void(class AActor* Target, const struct FGameplayEffectSpecHandle& SpecHandle, const struct FActiveGameplayEffectHandle& ActiveHandle)> OnApplied; // 0x01B8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C8[0x10];                                     // 0x01C8(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEffectApplied_Target* WaitGameplayEffectAppliedToTarget(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& TargetFilter, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffects);
	static class UAbilityTask_WaitGameplayEffectApplied_Target* WaitGameplayEffectAppliedToTarget_Query(class UGameplayAbility* OwningAbility, const struct FGameplayTargetDataFilterHandle& SourceFilter, const struct FGameplayTagQuery& SourceTagQuery, const struct FGameplayTagQuery& TargetTagQuery, bool TriggerOnce, class AActor* OptionalExternalOwner, bool ListenForPeriodicEffect);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectApplied_Target">();
	}
	static class UAbilityTask_WaitGameplayEffectApplied_Target* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectApplied_Target>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectApplied_Target) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectApplied_Target");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectApplied_Target) == 0x0001D8, "Wrong size on UAbilityTask_WaitGameplayEffectApplied_Target");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectApplied_Target, OnApplied) == 0x0001B8, "Member 'UAbilityTask_WaitGameplayEffectApplied_Target::OnApplied' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectBlockedImmunity
// 0x00A8 (0x0128 - 0x0080)
class UAbilityTask_WaitGameplayEffectBlockedImmunity final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayEffectSpecHandle& BlockedSpec, const struct FActiveGameplayEffectHandle& ImmunityGameplayEffectHandle)> bLocked; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x88];                                      // 0x0090(0x0088)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                ExternalOwner;                                     // 0x0118(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_120[0x8];                                      // 0x0120(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEffectBlockedImmunity* WaitGameplayEffectBlockedByImmunity(class UGameplayAbility* OwningAbility, const struct FGameplayTagRequirements& SourceTagRequirements, const struct FGameplayTagRequirements& TargetTagRequirements, class AActor* OptionalExternalTarget, bool OnlyTriggerOnce);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectBlockedImmunity">();
	}
	static class UAbilityTask_WaitGameplayEffectBlockedImmunity* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectBlockedImmunity>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectBlockedImmunity) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectBlockedImmunity");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectBlockedImmunity) == 0x000128, "Wrong size on UAbilityTask_WaitGameplayEffectBlockedImmunity");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectBlockedImmunity, bLocked) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectBlockedImmunity::bLocked' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectBlockedImmunity, ExternalOwner) == 0x000118, "Member 'UAbilityTask_WaitGameplayEffectBlockedImmunity::ExternalOwner' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectRemoved
// 0x0040 (0x00C0 - 0x0080)
class UAbilityTask_WaitGameplayEffectRemoved final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayEffectRemovalInfo& GameplayEffectRemovalInfo)> OnRemoved; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FGameplayEffectRemovalInfo& GameplayEffectRemovalInfo)> InvalidHandle; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x20];                                      // 0x00A0(0x0020)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEffectRemoved* WaitForGameplayEffectRemoved(class UGameplayAbility* OwningAbility, const struct FActiveGameplayEffectHandle& Handle);

	void OnGameplayEffectRemoved(const struct FGameplayEffectRemovalInfo& InGameplayEffectRemovalInfo);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectRemoved">();
	}
	static class UAbilityTask_WaitGameplayEffectRemoved* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectRemoved>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectRemoved) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectRemoved");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectRemoved) == 0x0000C0, "Wrong size on UAbilityTask_WaitGameplayEffectRemoved");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectRemoved, OnRemoved) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectRemoved::OnRemoved' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectRemoved, InvalidHandle) == 0x000090, "Member 'UAbilityTask_WaitGameplayEffectRemoved::InvalidHandle' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEffectStackChange
// 0x0038 (0x00B8 - 0x0080)
class UAbilityTask_WaitGameplayEffectStackChange final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount)> OnChange; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount)> InvalidHandle; // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x18];                                      // 0x00A0(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEffectStackChange* WaitForGameplayEffectStackChange(class UGameplayAbility* OwningAbility, const struct FActiveGameplayEffectHandle& Handle);

	void OnGameplayEffectStackChange(const struct FActiveGameplayEffectHandle& Handle, int32 NewCount, int32 OldCount);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEffectStackChange">();
	}
	static class UAbilityTask_WaitGameplayEffectStackChange* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEffectStackChange>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEffectStackChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEffectStackChange");
static_assert(sizeof(UAbilityTask_WaitGameplayEffectStackChange) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayEffectStackChange");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectStackChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitGameplayEffectStackChange::OnChange' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitGameplayEffectStackChange, InvalidHandle) == 0x000090, "Member 'UAbilityTask_WaitGameplayEffectStackChange::InvalidHandle' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayEvent
// 0x0030 (0x00B0 - 0x0080)
class UAbilityTask_WaitGameplayEvent final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayEventData& Payload)> EventReceived;          // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                OptionalExternalTarget;                            // 0x0098(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A0[0x10];                                      // 0x00A0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitGameplayEvent* WaitGameplayEvent(class UGameplayAbility* OwningAbility, const struct FGameplayTag& EventTag, class AActor* OptionalExternalTarget_0, bool OnlyTriggerOnce, bool OnlyMatchExact);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayEvent">();
	}
	static class UAbilityTask_WaitGameplayEvent* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayEvent>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayEvent) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayEvent");
static_assert(sizeof(UAbilityTask_WaitGameplayEvent) == 0x0000B0, "Wrong size on UAbilityTask_WaitGameplayEvent");
static_assert(offsetof(UAbilityTask_WaitGameplayEvent, EventReceived) == 0x000080, "Member 'UAbilityTask_WaitGameplayEvent::EventReceived' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitGameplayEvent, OptionalExternalTarget) == 0x000098, "Member 'UAbilityTask_WaitGameplayEvent::OptionalExternalTarget' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayTag
// 0x0028 (0x00A8 - 0x0080)
class UAbilityTask_WaitGameplayTag : public UAbilityTask
{
public:
	uint8                                         Pad_80[0x10];                                      // 0x0080(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UAbilitySystemComponent*                OptionalExternalTarget;                            // 0x0090(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_98[0x10];                                      // 0x0098(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void GameplayTagCallback(const struct FGameplayTag& Tag, int32 NewCount);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayTag">();
	}
	static class UAbilityTask_WaitGameplayTag* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayTag>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayTag) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTag");
static_assert(sizeof(UAbilityTask_WaitGameplayTag) == 0x0000A8, "Wrong size on UAbilityTask_WaitGameplayTag");
static_assert(offsetof(UAbilityTask_WaitGameplayTag, OptionalExternalTarget) == 0x000090, "Member 'UAbilityTask_WaitGameplayTag::OptionalExternalTarget' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayTagAdded
// 0x0010 (0x00B8 - 0x00A8)
class UAbilityTask_WaitGameplayTagAdded final : public UAbilityTask_WaitGameplayTag
{
public:
	TMulticastInlineDelegate<void()>              Added;                                             // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAbilityTask_WaitGameplayTagAdded* WaitGameplayTagAdd(class UGameplayAbility* OwningAbility, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayTagAdded">();
	}
	static class UAbilityTask_WaitGameplayTagAdded* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayTagAdded>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayTagAdded) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTagAdded");
static_assert(sizeof(UAbilityTask_WaitGameplayTagAdded) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayTagAdded");
static_assert(offsetof(UAbilityTask_WaitGameplayTagAdded, Added) == 0x0000A8, "Member 'UAbilityTask_WaitGameplayTagAdded::Added' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitGameplayTagRemoved
// 0x0010 (0x00B8 - 0x00A8)
class UAbilityTask_WaitGameplayTagRemoved final : public UAbilityTask_WaitGameplayTag
{
public:
	TMulticastInlineDelegate<void()>              Removed;                                           // 0x00A8(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAbilityTask_WaitGameplayTagRemoved* WaitGameplayTagRemove(class UGameplayAbility* OwningAbility, const struct FGameplayTag& Tag, class AActor* InOptionalExternalTarget, bool OnlyTriggerOnce);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitGameplayTagRemoved">();
	}
	static class UAbilityTask_WaitGameplayTagRemoved* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitGameplayTagRemoved>();
	}
};
static_assert(alignof(UAbilityTask_WaitGameplayTagRemoved) == 0x000008, "Wrong alignment on UAbilityTask_WaitGameplayTagRemoved");
static_assert(sizeof(UAbilityTask_WaitGameplayTagRemoved) == 0x0000B8, "Wrong size on UAbilityTask_WaitGameplayTagRemoved");
static_assert(offsetof(UAbilityTask_WaitGameplayTagRemoved, Removed) == 0x0000A8, "Member 'UAbilityTask_WaitGameplayTagRemoved::Removed' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitInputPress
// 0x0020 (0x00A0 - 0x0080)
class UAbilityTask_WaitInputPress final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(float TimeWaited)> OnPress;                                        // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitInputPress* WaitInputPress(class UGameplayAbility* OwningAbility, bool bTestAlreadyPressed);

	void OnPressCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitInputPress">();
	}
	static class UAbilityTask_WaitInputPress* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitInputPress>();
	}
};
static_assert(alignof(UAbilityTask_WaitInputPress) == 0x000008, "Wrong alignment on UAbilityTask_WaitInputPress");
static_assert(sizeof(UAbilityTask_WaitInputPress) == 0x0000A0, "Wrong size on UAbilityTask_WaitInputPress");
static_assert(offsetof(UAbilityTask_WaitInputPress, OnPress) == 0x000080, "Member 'UAbilityTask_WaitInputPress::OnPress' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitInputRelease
// 0x0020 (0x00A0 - 0x0080)
class UAbilityTask_WaitInputRelease final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(float TimeHeld)> OnRelease;                                        // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitInputRelease* WaitInputRelease(class UGameplayAbility* OwningAbility, bool bTestAlreadyReleased);

	void OnReleaseCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitInputRelease">();
	}
	static class UAbilityTask_WaitInputRelease* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitInputRelease>();
	}
};
static_assert(alignof(UAbilityTask_WaitInputRelease) == 0x000008, "Wrong alignment on UAbilityTask_WaitInputRelease");
static_assert(sizeof(UAbilityTask_WaitInputRelease) == 0x0000A0, "Wrong size on UAbilityTask_WaitInputRelease");
static_assert(offsetof(UAbilityTask_WaitInputRelease, OnRelease) == 0x000080, "Member 'UAbilityTask_WaitInputRelease::OnRelease' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitMovementModeChange
// 0x0020 (0x00A0 - 0x0080)
class UAbilityTask_WaitMovementModeChange final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(EMovementMode NewMovementMode)> OnChange;                          // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitMovementModeChange* CreateWaitMovementModeChange(class UGameplayAbility* OwningAbility, EMovementMode NewMode);

	void OnMovementModeChange(class ACharacter* Character, EMovementMode PrevMovementMode, uint8 PreviousCustomMode);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitMovementModeChange">();
	}
	static class UAbilityTask_WaitMovementModeChange* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitMovementModeChange>();
	}
};
static_assert(alignof(UAbilityTask_WaitMovementModeChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitMovementModeChange");
static_assert(sizeof(UAbilityTask_WaitMovementModeChange) == 0x0000A0, "Wrong size on UAbilityTask_WaitMovementModeChange");
static_assert(offsetof(UAbilityTask_WaitMovementModeChange, OnChange) == 0x000080, "Member 'UAbilityTask_WaitMovementModeChange::OnChange' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitOverlap
// 0x0010 (0x0090 - 0x0080)
class UAbilityTask_WaitOverlap final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& TargetData)> OnOverlap; // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)

public:
	static class UAbilityTask_WaitOverlap* WaitForOverlap(class UGameplayAbility* OwningAbility);

	void OnHitCallback(class UPrimitiveComponent* HitComp, class AActor* OtherActor, class UPrimitiveComponent* OtherComp, const struct FVector& NormalImpulse, const struct FHitResult& Hit);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitOverlap">();
	}
	static class UAbilityTask_WaitOverlap* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitOverlap>();
	}
};
static_assert(alignof(UAbilityTask_WaitOverlap) == 0x000008, "Wrong alignment on UAbilityTask_WaitOverlap");
static_assert(sizeof(UAbilityTask_WaitOverlap) == 0x000090, "Wrong size on UAbilityTask_WaitOverlap");
static_assert(offsetof(UAbilityTask_WaitOverlap, OnOverlap) == 0x000080, "Member 'UAbilityTask_WaitOverlap::OnOverlap' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitTargetData
// 0x0040 (0x00C0 - 0x0080)
class UAbilityTask_WaitTargetData final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& Data)> ValidData;   // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TMulticastInlineDelegate<void(const struct FGameplayAbilityTargetDataHandle& Data)> Cancelled;   // 0x0090(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	TSubclassOf<class AGameplayAbilityTargetActor> TargetClass;                                      // 0x00A0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AGameplayAbilityTargetActor*            TargetActor;                                       // 0x00A8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_B0[0x10];                                      // 0x00B0(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitTargetData* WaitTargetData(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, TSubclassOf<class AGameplayAbilityTargetActor> Class_0);
	static class UAbilityTask_WaitTargetData* WaitTargetDataUsingActor(class UGameplayAbility* OwningAbility, class FName TaskInstanceName, EGameplayTargetingConfirmation ConfirmationType, class AGameplayAbilityTargetActor* TargetActor_0);

	bool BeginSpawningActor(class UGameplayAbility* OwningAbility, TSubclassOf<class AGameplayAbilityTargetActor> Class_0, class AGameplayAbilityTargetActor** SpawnedActor);
	void FinishSpawningActor(class UGameplayAbility* OwningAbility, class AGameplayAbilityTargetActor* SpawnedActor);
	void OnTargetDataCancelledCallback(const struct FGameplayAbilityTargetDataHandle& Data);
	void OnTargetDataReadyCallback(const struct FGameplayAbilityTargetDataHandle& Data);
	void OnTargetDataReplicatedCallback(const struct FGameplayAbilityTargetDataHandle& Data, const struct FGameplayTag& ActivationTag);
	void OnTargetDataReplicatedCancelledCallback();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitTargetData">();
	}
	static class UAbilityTask_WaitTargetData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitTargetData>();
	}
};
static_assert(alignof(UAbilityTask_WaitTargetData) == 0x000008, "Wrong alignment on UAbilityTask_WaitTargetData");
static_assert(sizeof(UAbilityTask_WaitTargetData) == 0x0000C0, "Wrong size on UAbilityTask_WaitTargetData");
static_assert(offsetof(UAbilityTask_WaitTargetData, ValidData) == 0x000080, "Member 'UAbilityTask_WaitTargetData::ValidData' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitTargetData, Cancelled) == 0x000090, "Member 'UAbilityTask_WaitTargetData::Cancelled' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitTargetData, TargetClass) == 0x0000A0, "Member 'UAbilityTask_WaitTargetData::TargetClass' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitTargetData, TargetActor) == 0x0000A8, "Member 'UAbilityTask_WaitTargetData::TargetActor' has a wrong offset!");

// Class GameplayAbilities.AbilityTask_WaitVelocityChange
// 0x0028 (0x00A8 - 0x0080)
class UAbilityTask_WaitVelocityChange final : public UAbilityTask
{
public:
	TMulticastInlineDelegate<void()>              OnVelocityChage;                                   // 0x0080(0x0010)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
	class UMovementComponent*                     CachedMovementComponent;                           // 0x0090(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_98[0x10];                                      // 0x0098(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UAbilityTask_WaitVelocityChange* CreateWaitVelocityChange(class UGameplayAbility* OwningAbility, const struct FVector& Direction, float MinimumMagnitude);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"AbilityTask_WaitVelocityChange">();
	}
	static class UAbilityTask_WaitVelocityChange* GetDefaultObj()
	{
		return GetDefaultObjImpl<UAbilityTask_WaitVelocityChange>();
	}
};
static_assert(alignof(UAbilityTask_WaitVelocityChange) == 0x000008, "Wrong alignment on UAbilityTask_WaitVelocityChange");
static_assert(sizeof(UAbilityTask_WaitVelocityChange) == 0x0000A8, "Wrong size on UAbilityTask_WaitVelocityChange");
static_assert(offsetof(UAbilityTask_WaitVelocityChange, OnVelocityChage) == 0x000080, "Member 'UAbilityTask_WaitVelocityChange::OnVelocityChage' has a wrong offset!");
static_assert(offsetof(UAbilityTask_WaitVelocityChange, CachedMovementComponent) == 0x000090, "Member 'UAbilityTask_WaitVelocityChange::CachedMovementComponent' has a wrong offset!");

// Class GameplayAbilities.GameplayAbility
// 0x0388 (0x03B0 - 0x0028)
class UGameplayAbility : public UObject
{
public:
	uint8                                         Pad_28[0x80];                                      // 0x0028(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTagContainer                  AbilityTags;                                       // 0x00A8(0x0020)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
	bool                                          bReplicateInputDirectly;                           // 0x00C8(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          RemoteInstanceEnded;                               // 0x00C9(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CA[0x4];                                       // 0x00CA(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	EGameplayAbilityReplicationPolicy             ReplicationPolicy;                                 // 0x00CE(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EGameplayAbilityInstancingPolicy              InstancingPolicy;                                  // 0x00CF(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bServerRespectsRemoteAbilityCancellation;          // 0x00D0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bRetriggerInstancedAbility;                        // 0x00D1(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_D2[0x6];                                       // 0x00D2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayAbilityActivationInfo         CurrentActivationInfo;                             // 0x00D8(0x0018)(BlueprintVisible, BlueprintReadOnly, NoDestructor, Protected, NativeAccessSpecifierProtected)
	struct FGameplayEventData                     CurrentEventData;                                  // 0x00F0(0x00B0)(BlueprintVisible, BlueprintReadOnly, Protected, NativeAccessSpecifierProtected)
	EGameplayAbilityNetExecutionPolicy            NetExecutionPolicy;                                // 0x01A0(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	EGameplayAbilityNetSecurityPolicy             NetSecurityPolicy;                                 // 0x01A1(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1A2[0x6];                                      // 0x01A2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TSubclassOf<class UGameplayEffect>            CostGameplayEffectClass;                           // 0x01A8(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	TArray<struct FAbilityTriggerData>            AbilityTriggers;                                   // 0x01B0(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	TSubclassOf<class UGameplayEffect>            CooldownGameplayEffectClass;                       // 0x01C0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  CancelAbilitiesWithTag;                            // 0x01C8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  BlockAbilitiesWithTag;                             // 0x01E8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  ActivationOwnedTags;                               // 0x0208(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  ActivationRequiredTags;                            // 0x0228(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  ActivationBlockedTags;                             // 0x0248(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  SourceRequiredTags;                                // 0x0268(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  SourceBlockedTags;                                 // 0x0288(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  TargetRequiredTags;                                // 0x02A8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	struct FGameplayTagContainer                  TargetBlockedTags;                                 // 0x02C8(0x0020)(Edit, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_2E8[0x20];                                     // 0x02E8(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UGameplayTask*>                  ActiveTasks;                                       // 0x0308(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_318[0x10];                                     // 0x0318(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	class UAnimMontage*                           CurrentMontage;                                    // 0x0328(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_330[0x60];                                     // 0x0330(0x0060)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bIsActive;                                         // 0x0390(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsAbilityEnding;                                  // 0x0391(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsCancelable;                                     // 0x0392(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsBlockingOtherAbilities;                         // 0x0393(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_394[0x14];                                     // 0x0394(0x0014)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bMarkPendingKillOnAbilityEnd;                      // 0x03A8(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_3A9[0x7];                                      // 0x03A9(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	struct FActiveGameplayEffectHandle BP_ApplyGameplayEffectToOwner(TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks);
	TArray<struct FActiveGameplayEffectHandle> BP_ApplyGameplayEffectToTarget(const struct FGameplayAbilityTargetDataHandle& TargetData, TSubclassOf<class UGameplayEffect> GameplayEffectClass, int32 GameplayEffectLevel, int32 Stacks);
	void BP_RemoveGameplayEffectFromOwnerWithAssetTags(const struct FGameplayTagContainer& WithAssetTags, int32 StacksToRemove);
	void BP_RemoveGameplayEffectFromOwnerWithGrantedTags(const struct FGameplayTagContainer& WithGrantedTags, int32 StacksToRemove);
	void BP_RemoveGameplayEffectFromOwnerWithHandle(const struct FActiveGameplayEffectHandle& Handle, int32 StacksToRemove);
	void CancelTaskByInstanceName(class FName InstanceName);
	void ConfirmTaskByInstanceName(class FName InstanceName, bool bEndTask);
	void EndAbilityState(class FName OptionalStateNameToEnd);
	void EndTaskByInstanceName(class FName InstanceName);
	void K2_ActivateAbility();
	void K2_ActivateAbilityFromEvent(const struct FGameplayEventData& EventData);
	void K2_AddGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context, bool bRemoveOnAbilityEnd);
	void K2_AddGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameter, bool bRemoveOnAbilityEnd);
	struct FActiveGameplayEffectHandle K2_ApplyGameplayEffectSpecToOwner(const struct FGameplayEffectSpecHandle& EffectSpecHandle);
	TArray<struct FActiveGameplayEffectHandle> K2_ApplyGameplayEffectSpecToTarget(const struct FGameplayEffectSpecHandle& EffectSpecHandle, const struct FGameplayAbilityTargetDataHandle& TargetData);
	void K2_CancelAbility();
	bool K2_CheckAbilityCooldown();
	bool K2_CheckAbilityCost();
	bool K2_CommitAbility();
	bool K2_CommitAbilityCooldown(bool BroadcastCommitEvent, bool ForceCooldown);
	bool K2_CommitAbilityCost(bool BroadcastCommitEvent);
	void K2_CommitExecute();
	void K2_EndAbility();
	void K2_ExecuteGameplayCue(const struct FGameplayTag& GameplayCueTag, const struct FGameplayEffectContextHandle& Context);
	void K2_ExecuteGameplayCueWithParams(const struct FGameplayTag& GameplayCueTag, const struct FGameplayCueParameters& GameplayCueParameters);
	void K2_OnEndAbility(bool bWasCancelled);
	void K2_RemoveGameplayCue(const struct FGameplayTag& GameplayCueTag);
	struct FGameplayAbilityTargetingLocationInfo MakeTargetLocationInfoFromOwnerActor();
	struct FGameplayAbilityTargetingLocationInfo MakeTargetLocationInfoFromOwnerSkeletalMeshComponent(class FName SocketName);
	void MontageJumpToSection(class FName SectionName);
	void MontageSetNextSectionName(class FName FromSectionName, class FName ToSectionName);
	void MontageStop(float OverrideBlendOutTime);
	void RemoveGrantedByEffect();
	void SendGameplayEvent(const struct FGameplayTag& EventTag, const struct FGameplayEventData& Payload);
	void SetCanBeCanceled(bool bCanBeCanceled);
	void SetShouldBlockOtherAbilities(bool bShouldBlockAbilities);

	int32 GetAbilityLevel() const;
	int32 GetAbilityLevel_BP(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo) const;
	class UAbilitySystemComponent* GetAbilitySystemComponentFromActorInfo() const;
	struct FGameplayAbilityActorInfo GetActorInfo() const;
	class AActor* GetAvatarActorFromActorInfo() const;
	struct FGameplayEffectContextHandle GetContextFromOwner(const struct FGameplayAbilityTargetDataHandle& OptionalTargetData) const;
	float GetCooldownTimeRemaining() const;
	class UAnimMontage* GetCurrentMontage() const;
	class UObject* GetCurrentSourceObject() const;
	struct FGameplayEffectContextHandle GetGrantedByEffectContext() const;
	class AActor* GetOwningActorFromActorInfo() const;
	class USkeletalMeshComponent* GetOwningComponentFromActorInfo() const;
	class UObject* GetSourceObject_BP(const struct FGameplayAbilitySpecHandle& Handle, const struct FGameplayAbilityActorInfo& ActorInfo) const;
	void InvalidateClientPredictionKey() const;
	bool IsLocallyControlled() const;
	bool K2_CanActivateAbility(const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayAbilitySpecHandle& Handle, struct FGameplayTagContainer* RelevantTags) const;
	bool K2_HasAuthority() const;
	bool K2_ShouldAbilityRespondToEvent(const struct FGameplayAbilityActorInfo& ActorInfo, const struct FGameplayEventData& Payload) const;
	struct FGameplayEffectSpecHandle MakeOutgoingGameplayEffectSpec(TSubclassOf<class UGameplayEffect> GameplayEffectClass, float Level) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbility">();
	}
	static class UGameplayAbility* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayAbility>();
	}
};
static_assert(alignof(UGameplayAbility) == 0x000008, "Wrong alignment on UGameplayAbility");
static_assert(sizeof(UGameplayAbility) == 0x0003B0, "Wrong size on UGameplayAbility");
static_assert(offsetof(UGameplayAbility, AbilityTags) == 0x0000A8, "Member 'UGameplayAbility::AbilityTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bReplicateInputDirectly) == 0x0000C8, "Member 'UGameplayAbility::bReplicateInputDirectly' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, RemoteInstanceEnded) == 0x0000C9, "Member 'UGameplayAbility::RemoteInstanceEnded' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, ReplicationPolicy) == 0x0000CE, "Member 'UGameplayAbility::ReplicationPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, InstancingPolicy) == 0x0000CF, "Member 'UGameplayAbility::InstancingPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bServerRespectsRemoteAbilityCancellation) == 0x0000D0, "Member 'UGameplayAbility::bServerRespectsRemoteAbilityCancellation' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bRetriggerInstancedAbility) == 0x0000D1, "Member 'UGameplayAbility::bRetriggerInstancedAbility' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CurrentActivationInfo) == 0x0000D8, "Member 'UGameplayAbility::CurrentActivationInfo' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CurrentEventData) == 0x0000F0, "Member 'UGameplayAbility::CurrentEventData' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, NetExecutionPolicy) == 0x0001A0, "Member 'UGameplayAbility::NetExecutionPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, NetSecurityPolicy) == 0x0001A1, "Member 'UGameplayAbility::NetSecurityPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CostGameplayEffectClass) == 0x0001A8, "Member 'UGameplayAbility::CostGameplayEffectClass' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, AbilityTriggers) == 0x0001B0, "Member 'UGameplayAbility::AbilityTriggers' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CooldownGameplayEffectClass) == 0x0001C0, "Member 'UGameplayAbility::CooldownGameplayEffectClass' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CancelAbilitiesWithTag) == 0x0001C8, "Member 'UGameplayAbility::CancelAbilitiesWithTag' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, BlockAbilitiesWithTag) == 0x0001E8, "Member 'UGameplayAbility::BlockAbilitiesWithTag' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, ActivationOwnedTags) == 0x000208, "Member 'UGameplayAbility::ActivationOwnedTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, ActivationRequiredTags) == 0x000228, "Member 'UGameplayAbility::ActivationRequiredTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, ActivationBlockedTags) == 0x000248, "Member 'UGameplayAbility::ActivationBlockedTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, SourceRequiredTags) == 0x000268, "Member 'UGameplayAbility::SourceRequiredTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, SourceBlockedTags) == 0x000288, "Member 'UGameplayAbility::SourceBlockedTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, TargetRequiredTags) == 0x0002A8, "Member 'UGameplayAbility::TargetRequiredTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, TargetBlockedTags) == 0x0002C8, "Member 'UGameplayAbility::TargetBlockedTags' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, ActiveTasks) == 0x000308, "Member 'UGameplayAbility::ActiveTasks' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, CurrentMontage) == 0x000328, "Member 'UGameplayAbility::CurrentMontage' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bIsActive) == 0x000390, "Member 'UGameplayAbility::bIsActive' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bIsAbilityEnding) == 0x000391, "Member 'UGameplayAbility::bIsAbilityEnding' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bIsCancelable) == 0x000392, "Member 'UGameplayAbility::bIsCancelable' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bIsBlockingOtherAbilities) == 0x000393, "Member 'UGameplayAbility::bIsBlockingOtherAbilities' has a wrong offset!");
static_assert(offsetof(UGameplayAbility, bMarkPendingKillOnAbilityEnd) == 0x0003A8, "Member 'UGameplayAbility::bMarkPendingKillOnAbilityEnd' has a wrong offset!");

// Class GameplayAbilities.GameplayAbility_CharacterJump
// 0x0000 (0x03B0 - 0x03B0)
class UGameplayAbility_CharacterJump final : public UGameplayAbility
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbility_CharacterJump">();
	}
	static class UGameplayAbility_CharacterJump* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayAbility_CharacterJump>();
	}
};
static_assert(alignof(UGameplayAbility_CharacterJump) == 0x000008, "Wrong alignment on UGameplayAbility_CharacterJump");
static_assert(sizeof(UGameplayAbility_CharacterJump) == 0x0003B0, "Wrong size on UGameplayAbility_CharacterJump");

// Class GameplayAbilities.GameplayAbility_Montage
// 0x0038 (0x03E8 - 0x03B0)
class UGameplayAbility_Montage final : public UGameplayAbility
{
public:
	class UAnimMontage*                           MontageToPlay;                                     // 0x03B0(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlayRate;                                          // 0x03B8(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   SectionName;                                       // 0x03BC(0x0008)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3C4[0x4];                                      // 0x03C4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TSubclassOf<class UGameplayEffect>>    GameplayEffectClassesWhileAnimating;               // 0x03C8(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<class UGameplayEffect*>                GameplayEffectsWhileAnimating;                     // 0x03D8(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, EditConst, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbility_Montage">();
	}
	static class UGameplayAbility_Montage* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayAbility_Montage>();
	}
};
static_assert(alignof(UGameplayAbility_Montage) == 0x000008, "Wrong alignment on UGameplayAbility_Montage");
static_assert(sizeof(UGameplayAbility_Montage) == 0x0003E8, "Wrong size on UGameplayAbility_Montage");
static_assert(offsetof(UGameplayAbility_Montage, MontageToPlay) == 0x0003B0, "Member 'UGameplayAbility_Montage::MontageToPlay' has a wrong offset!");
static_assert(offsetof(UGameplayAbility_Montage, PlayRate) == 0x0003B8, "Member 'UGameplayAbility_Montage::PlayRate' has a wrong offset!");
static_assert(offsetof(UGameplayAbility_Montage, SectionName) == 0x0003BC, "Member 'UGameplayAbility_Montage::SectionName' has a wrong offset!");
static_assert(offsetof(UGameplayAbility_Montage, GameplayEffectClassesWhileAnimating) == 0x0003C8, "Member 'UGameplayAbility_Montage::GameplayEffectClassesWhileAnimating' has a wrong offset!");
static_assert(offsetof(UGameplayAbility_Montage, GameplayEffectsWhileAnimating) == 0x0003D8, "Member 'UGameplayAbility_Montage::GameplayEffectsWhileAnimating' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityTargetActor_SingleLineTrace
// 0x0000 (0x0350 - 0x0350)
class AGameplayAbilityTargetActor_SingleLineTrace final : public AGameplayAbilityTargetActor_Trace
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityTargetActor_SingleLineTrace">();
	}
	static class AGameplayAbilityTargetActor_SingleLineTrace* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityTargetActor_SingleLineTrace>();
	}
};
static_assert(alignof(AGameplayAbilityTargetActor_SingleLineTrace) == 0x000010, "Wrong alignment on AGameplayAbilityTargetActor_SingleLineTrace");
static_assert(sizeof(AGameplayAbilityTargetActor_SingleLineTrace) == 0x000350, "Wrong size on AGameplayAbilityTargetActor_SingleLineTrace");

// Class GameplayAbilities.GameplayAbilityWorldReticle
// 0x0020 (0x0240 - 0x0220)
class AGameplayAbilityWorldReticle : public AActor
{
public:
	struct FWorldReticleParameters                Parameters;                                        // 0x0220(0x000C)(Edit, BlueprintVisible, DisableEditOnTemplate, NoDestructor, ExposeOnSpawn, NativeAccessSpecifierPublic)
	bool                                          bFaceOwnerFlat;                                    // 0x022C(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSnapToTargetedActor;                              // 0x022D(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, ExposeOnSpawn, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsTargetValid;                                    // 0x022E(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	bool                                          bIsTargetAnActor;                                  // 0x022F(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class APlayerController*                      MasterPC;                                          // 0x0230(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	class AActor*                                 TargetingActor;                                    // 0x0238(0x0008)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void FaceTowardSource(bool bFaceIn2D);
	void OnParametersInitialized();
	void OnTargetingAnActor(bool bNewValue);
	void OnValidTargetChanged(bool bNewValue);
	void SetReticleMaterialParamFloat(class FName ParamName, float Value);
	void SetReticleMaterialParamVector(class FName ParamName, const struct FVector& Value);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityWorldReticle">();
	}
	static class AGameplayAbilityWorldReticle* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityWorldReticle>();
	}
};
static_assert(alignof(AGameplayAbilityWorldReticle) == 0x000008, "Wrong alignment on AGameplayAbilityWorldReticle");
static_assert(sizeof(AGameplayAbilityWorldReticle) == 0x000240, "Wrong size on AGameplayAbilityWorldReticle");
static_assert(offsetof(AGameplayAbilityWorldReticle, Parameters) == 0x000220, "Member 'AGameplayAbilityWorldReticle::Parameters' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, bFaceOwnerFlat) == 0x00022C, "Member 'AGameplayAbilityWorldReticle::bFaceOwnerFlat' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, bSnapToTargetedActor) == 0x00022D, "Member 'AGameplayAbilityWorldReticle::bSnapToTargetedActor' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, bIsTargetValid) == 0x00022E, "Member 'AGameplayAbilityWorldReticle::bIsTargetValid' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, bIsTargetAnActor) == 0x00022F, "Member 'AGameplayAbilityWorldReticle::bIsTargetAnActor' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, MasterPC) == 0x000230, "Member 'AGameplayAbilityWorldReticle::MasterPC' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle, TargetingActor) == 0x000238, "Member 'AGameplayAbilityWorldReticle::TargetingActor' has a wrong offset!");

// Class GameplayAbilities.GameplayAbilityWorldReticle_ActorVisualization
// 0x0018 (0x0258 - 0x0240)
class AGameplayAbilityWorldReticle_ActorVisualization final : public AGameplayAbilityWorldReticle
{
public:
	class UCapsuleComponent*                      CollisionComponent;                                // 0x0240(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UActorComponent*>                VisualizationComponents;                           // 0x0248(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayAbilityWorldReticle_ActorVisualization">();
	}
	static class AGameplayAbilityWorldReticle_ActorVisualization* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayAbilityWorldReticle_ActorVisualization>();
	}
};
static_assert(alignof(AGameplayAbilityWorldReticle_ActorVisualization) == 0x000008, "Wrong alignment on AGameplayAbilityWorldReticle_ActorVisualization");
static_assert(sizeof(AGameplayAbilityWorldReticle_ActorVisualization) == 0x000258, "Wrong size on AGameplayAbilityWorldReticle_ActorVisualization");
static_assert(offsetof(AGameplayAbilityWorldReticle_ActorVisualization, CollisionComponent) == 0x000240, "Member 'AGameplayAbilityWorldReticle_ActorVisualization::CollisionComponent' has a wrong offset!");
static_assert(offsetof(AGameplayAbilityWorldReticle_ActorVisualization, VisualizationComponents) == 0x000248, "Member 'AGameplayAbilityWorldReticle_ActorVisualization::VisualizationComponents' has a wrong offset!");

// Class GameplayAbilities.GameplayCueInterface
// 0x0000 (0x0000 - 0x0000)
class IGameplayCueInterface final
{
public:
	void BlueprintCustomHandler(EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
	void ForwardGameplayCueToParent();

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueInterface">();
	}
	static class IGameplayCueInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<IGameplayCueInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(IGameplayCueInterface) == 0x000001, "Wrong alignment on IGameplayCueInterface");
static_assert(sizeof(IGameplayCueInterface) == 0x000001, "Wrong size on IGameplayCueInterface");

// Class GameplayAbilities.GameplayCueManager
// 0x02E0 (0x0310 - 0x0030)
class UGameplayCueManager final : public UDataAsset
{
public:
	uint8                                         Pad_30[0x18];                                      // 0x0030(0x0018)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayCueObjectLibrary              RuntimeGameplayCueObjectLibrary;                   // 0x0048(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
	struct FGameplayCueObjectLibrary              EditorGameplayCueObjectLibrary;                    // 0x0098(0x0050)(Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_E8[0x1C8];                                     // 0x00E8(0x01C8)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UClass*>                         LoadedGameplayCueNotifyClasses;                    // 0x02B0(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	TArray<TSubclassOf<class AGameplayCueNotify_Actor>> GameplayCueClassesForPreallocation;          // 0x02C0(0x0010)(ZeroConstructor, Transient, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
	TArray<struct FGameplayCuePendingExecute>     PendingExecuteCues;                                // 0x02D0(0x0010)(ZeroConstructor, Transient, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)
	int32                                         GameplayCueSendContextCount;                       // 0x02E0(0x0004)(ZeroConstructor, Transient, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_2E4[0x4];                                      // 0x02E4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FPreallocationInfo>             PreallocationInfoList_Internal;                    // 0x02E8(0x0010)(ZeroConstructor, Transient, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_2F8[0x18];                                     // 0x02F8(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueManager">();
	}
	static class UGameplayCueManager* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueManager>();
	}
};
static_assert(alignof(UGameplayCueManager) == 0x000008, "Wrong alignment on UGameplayCueManager");
static_assert(sizeof(UGameplayCueManager) == 0x000310, "Wrong size on UGameplayCueManager");
static_assert(offsetof(UGameplayCueManager, RuntimeGameplayCueObjectLibrary) == 0x000048, "Member 'UGameplayCueManager::RuntimeGameplayCueObjectLibrary' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, EditorGameplayCueObjectLibrary) == 0x000098, "Member 'UGameplayCueManager::EditorGameplayCueObjectLibrary' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, LoadedGameplayCueNotifyClasses) == 0x0002B0, "Member 'UGameplayCueManager::LoadedGameplayCueNotifyClasses' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, GameplayCueClassesForPreallocation) == 0x0002C0, "Member 'UGameplayCueManager::GameplayCueClassesForPreallocation' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, PendingExecuteCues) == 0x0002D0, "Member 'UGameplayCueManager::PendingExecuteCues' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, GameplayCueSendContextCount) == 0x0002E0, "Member 'UGameplayCueManager::GameplayCueSendContextCount' has a wrong offset!");
static_assert(offsetof(UGameplayCueManager, PreallocationInfoList_Internal) == 0x0002E8, "Member 'UGameplayCueManager::PreallocationInfoList_Internal' has a wrong offset!");

// Class GameplayAbilities.GameplayCueNotify_Actor
// 0x0060 (0x0280 - 0x0220)
class AGameplayCueNotify_Actor final : public AActor
{
public:
	bool                                          bAutoDestroyOnRemove;                              // 0x0220(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_221[0x3];                                      // 0x0221(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         AutoDestroyDelay;                                  // 0x0224(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          WarnIfTimelineIsStillRunning;                      // 0x0228(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          WarnIfLatentActionIsStillRunning;                  // 0x0229(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_22A[0x2];                                      // 0x022A(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayTag                           GameplayCueTag;                                    // 0x022C(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   GameplayCueName;                                   // 0x0234(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoAttachToOwner;                                // 0x023C(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsOverride;                                        // 0x023D(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUniqueInstancePerInstigator;                      // 0x023E(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bUniqueInstancePerSourceObject;                    // 0x023F(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowMultipleOnActiveEvents;                      // 0x0240(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAllowMultipleWhileActiveEvents;                   // 0x0241(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_242[0x2];                                      // 0x0242(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         NumPreallocatedInstances;                          // 0x0244(0x0004)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_248[0x38];                                     // 0x0248(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void K2_EndGameplayCue();
	void K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters);
	bool OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
	bool OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
	void OnOwnerDestroyed(class AActor* DestroyedActor);
	bool OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);
	bool WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueNotify_Actor">();
	}
	static class AGameplayCueNotify_Actor* GetDefaultObj()
	{
		return GetDefaultObjImpl<AGameplayCueNotify_Actor>();
	}
};
static_assert(alignof(AGameplayCueNotify_Actor) == 0x000008, "Wrong alignment on AGameplayCueNotify_Actor");
static_assert(sizeof(AGameplayCueNotify_Actor) == 0x000280, "Wrong size on AGameplayCueNotify_Actor");
static_assert(offsetof(AGameplayCueNotify_Actor, bAutoDestroyOnRemove) == 0x000220, "Member 'AGameplayCueNotify_Actor::bAutoDestroyOnRemove' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, AutoDestroyDelay) == 0x000224, "Member 'AGameplayCueNotify_Actor::AutoDestroyDelay' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, WarnIfTimelineIsStillRunning) == 0x000228, "Member 'AGameplayCueNotify_Actor::WarnIfTimelineIsStillRunning' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, WarnIfLatentActionIsStillRunning) == 0x000229, "Member 'AGameplayCueNotify_Actor::WarnIfLatentActionIsStillRunning' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, GameplayCueTag) == 0x00022C, "Member 'AGameplayCueNotify_Actor::GameplayCueTag' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, GameplayCueName) == 0x000234, "Member 'AGameplayCueNotify_Actor::GameplayCueName' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, bAutoAttachToOwner) == 0x00023C, "Member 'AGameplayCueNotify_Actor::bAutoAttachToOwner' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, IsOverride) == 0x00023D, "Member 'AGameplayCueNotify_Actor::IsOverride' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, bUniqueInstancePerInstigator) == 0x00023E, "Member 'AGameplayCueNotify_Actor::bUniqueInstancePerInstigator' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, bUniqueInstancePerSourceObject) == 0x00023F, "Member 'AGameplayCueNotify_Actor::bUniqueInstancePerSourceObject' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, bAllowMultipleOnActiveEvents) == 0x000240, "Member 'AGameplayCueNotify_Actor::bAllowMultipleOnActiveEvents' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, bAllowMultipleWhileActiveEvents) == 0x000241, "Member 'AGameplayCueNotify_Actor::bAllowMultipleWhileActiveEvents' has a wrong offset!");
static_assert(offsetof(AGameplayCueNotify_Actor, NumPreallocatedInstances) == 0x000244, "Member 'AGameplayCueNotify_Actor::NumPreallocatedInstances' has a wrong offset!");

// Class GameplayAbilities.GameplayCueNotify_Static
// 0x0018 (0x0040 - 0x0028)
class UGameplayCueNotify_Static : public UObject
{
public:
	struct FGameplayTag                           GameplayCueTag;                                    // 0x0028(0x0008)(Edit, DisableEditOnInstance, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   GameplayCueName;                                   // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, AssetRegistrySearchable, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          IsOverride;                                        // 0x0038(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void K2_HandleGameplayCue(class AActor* MyTarget, EGameplayCueEvent EventType, const struct FGameplayCueParameters& Parameters) const;
	bool OnActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
	bool OnExecute(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
	bool OnRemove(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;
	bool WhileActive(class AActor* MyTarget, const struct FGameplayCueParameters& Parameters) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueNotify_Static">();
	}
	static class UGameplayCueNotify_Static* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueNotify_Static>();
	}
};
static_assert(alignof(UGameplayCueNotify_Static) == 0x000008, "Wrong alignment on UGameplayCueNotify_Static");
static_assert(sizeof(UGameplayCueNotify_Static) == 0x000040, "Wrong size on UGameplayCueNotify_Static");
static_assert(offsetof(UGameplayCueNotify_Static, GameplayCueTag) == 0x000028, "Member 'UGameplayCueNotify_Static::GameplayCueTag' has a wrong offset!");
static_assert(offsetof(UGameplayCueNotify_Static, GameplayCueName) == 0x000030, "Member 'UGameplayCueNotify_Static::GameplayCueName' has a wrong offset!");
static_assert(offsetof(UGameplayCueNotify_Static, IsOverride) == 0x000038, "Member 'UGameplayCueNotify_Static::IsOverride' has a wrong offset!");

// Class GameplayAbilities.GameplayCueNotify_HitImpact
// 0x0010 (0x0050 - 0x0040)
class UGameplayCueNotify_HitImpact final : public UGameplayCueNotify_Static
{
public:
	class USoundBase*                             Sound;                                             // 0x0040(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UParticleSystem*                        ParticleSystem;                                    // 0x0048(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueNotify_HitImpact">();
	}
	static class UGameplayCueNotify_HitImpact* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueNotify_HitImpact>();
	}
};
static_assert(alignof(UGameplayCueNotify_HitImpact) == 0x000008, "Wrong alignment on UGameplayCueNotify_HitImpact");
static_assert(sizeof(UGameplayCueNotify_HitImpact) == 0x000050, "Wrong size on UGameplayCueNotify_HitImpact");
static_assert(offsetof(UGameplayCueNotify_HitImpact, Sound) == 0x000040, "Member 'UGameplayCueNotify_HitImpact::Sound' has a wrong offset!");
static_assert(offsetof(UGameplayCueNotify_HitImpact, ParticleSystem) == 0x000048, "Member 'UGameplayCueNotify_HitImpact::ParticleSystem' has a wrong offset!");

// Class GameplayAbilities.GameplayCueSet
// 0x0060 (0x0090 - 0x0030)
class UGameplayCueSet final : public UDataAsset
{
public:
	TArray<struct FGameplayCueNotifyData>         GameplayCueData;                                   // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x50];                                      // 0x0040(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueSet">();
	}
	static class UGameplayCueSet* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueSet>();
	}
};
static_assert(alignof(UGameplayCueSet) == 0x000008, "Wrong alignment on UGameplayCueSet");
static_assert(sizeof(UGameplayCueSet) == 0x000090, "Wrong size on UGameplayCueSet");
static_assert(offsetof(UGameplayCueSet, GameplayCueData) == 0x000030, "Member 'UGameplayCueSet::GameplayCueData' has a wrong offset!");

// Class GameplayAbilities.GameplayCueTranslator
// 0x0000 (0x0028 - 0x0028)
class UGameplayCueTranslator : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueTranslator">();
	}
	static class UGameplayCueTranslator* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueTranslator>();
	}
};
static_assert(alignof(UGameplayCueTranslator) == 0x000008, "Wrong alignment on UGameplayCueTranslator");
static_assert(sizeof(UGameplayCueTranslator) == 0x000028, "Wrong size on UGameplayCueTranslator");

// Class GameplayAbilities.GameplayCueTranslator_Test
// 0x0000 (0x0028 - 0x0028)
class UGameplayCueTranslator_Test final : public UGameplayCueTranslator
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayCueTranslator_Test">();
	}
	static class UGameplayCueTranslator_Test* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayCueTranslator_Test>();
	}
};
static_assert(alignof(UGameplayCueTranslator_Test) == 0x000008, "Wrong alignment on UGameplayCueTranslator_Test");
static_assert(sizeof(UGameplayCueTranslator_Test) == 0x000028, "Wrong size on UGameplayCueTranslator_Test");

// Class GameplayAbilities.GameplayEffect
// 0x07D8 (0x0800 - 0x0028)
class UGameplayEffect final : public UObject
{
public:
	uint8                                         Pad_28[0x8];                                       // 0x0028(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	EGameplayEffectDurationType                   DurationPolicy;                                    // 0x0030(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x7];                                       // 0x0031(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayEffectModifierMagnitude       DurationMagnitude;                                 // 0x0038(0x01E0)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FScalableFloat                         Period;                                            // 0x0218(0x0028)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	bool                                          bExecutePeriodicEffectOnApplication;               // 0x0240(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EGameplayEffectPeriodInhibitionRemovedPolicy  PeriodicInhibitionPolicy;                          // 0x0241(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_242[0x6];                                      // 0x0242(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FGameplayModifierInfo>          Modifiers;                                         // 0x0248(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
	TArray<struct FGameplayEffectExecutionDefinition> Executions;                                    // 0x0258(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FScalableFloat                         ChanceToApplyToTarget;                             // 0x0268(0x0028)(Edit, DisableEditOnInstance, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UGameplayEffectCustomApplicationRequirement>> ApplicationRequirements;  // 0x0290(0x0010)(Edit, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UGameplayEffect>>    TargetEffectClasses;                               // 0x02A0(0x0010)(ZeroConstructor, Deprecated, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<struct FConditionalGameplayEffect>     ConditionalGameplayEffects;                        // 0x02B0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UGameplayEffect>>    OverflowEffects;                                   // 0x02C0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bDenyOverflowApplication;                          // 0x02D0(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bClearStackOnOverflow;                             // 0x02D1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2D2[0x6];                                      // 0x02D2(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<TSubclassOf<class UGameplayEffect>>    PrematureExpirationEffectClasses;                  // 0x02D8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	TArray<TSubclassOf<class UGameplayEffect>>    RoutineExpirationEffectClasses;                    // 0x02E8(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bRequireModifierSuccessToTriggerCues;              // 0x02F8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bSuppressStackingCues;                             // 0x02F9(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2FA[0x6];                                      // 0x02FA(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FGameplayEffectCue>             GameplayCues;                                      // 0x0300(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)
	class UGameplayEffectUIData*                  UIData;                                            // 0x0310(0x0008)(Edit, BlueprintVisible, ExportObject, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, InstancedReference, IsPlainOldData, NoDestructor, PersistentInstance, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FInheritedTagContainer                 InheritableGameplayEffectTags;                     // 0x0318(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FInheritedTagContainer                 InheritableOwnedTagsContainer;                     // 0x0378(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FGameplayTagRequirements               OngoingTagRequirements;                            // 0x03D8(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FGameplayTagRequirements               ApplicationTagRequirements;                        // 0x0418(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FGameplayTagRequirements               RemovalTagRequirements;                            // 0x0458(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FInheritedTagContainer                 RemoveGameplayEffectsWithTags;                     // 0x0498(0x0060)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FGameplayTagRequirements               GrantedApplicationImmunityTags;                    // 0x04F8(0x0040)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)
	struct FGameplayEffectQuery                   GrantedApplicationImmunityQuery;                   // 0x0538(0x0150)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_688[0x8];                                      // 0x0688(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGameplayEffectQuery                   RemoveGameplayEffectQuery;                         // 0x0690(0x0150)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, ContainsInstancedReference, NativeAccessSpecifierPublic)
	uint8                                         Pad_7E0[0x1];                                      // 0x07E0(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	EGameplayEffectStackingType                   StackingType;                                      // 0x07E1(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7E2[0x2];                                      // 0x07E2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         StackLimitCount;                                   // 0x07E4(0x0004)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EGameplayEffectStackingDurationPolicy         StackDurationRefreshPolicy;                        // 0x07E8(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EGameplayEffectStackingPeriodPolicy           StackPeriodResetPolicy;                            // 0x07E9(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EGameplayEffectStackingExpirationPolicy       StackExpirationPolicy;                             // 0x07EA(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_7EB[0x5];                                      // 0x07EB(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FGameplayAbilitySpecDef>        GrantedAbilities;                                  // 0x07F0(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffect">();
	}
	static class UGameplayEffect* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffect>();
	}
};
static_assert(alignof(UGameplayEffect) == 0x000008, "Wrong alignment on UGameplayEffect");
static_assert(sizeof(UGameplayEffect) == 0x000800, "Wrong size on UGameplayEffect");
static_assert(offsetof(UGameplayEffect, DurationPolicy) == 0x000030, "Member 'UGameplayEffect::DurationPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, DurationMagnitude) == 0x000038, "Member 'UGameplayEffect::DurationMagnitude' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, Period) == 0x000218, "Member 'UGameplayEffect::Period' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, bExecutePeriodicEffectOnApplication) == 0x000240, "Member 'UGameplayEffect::bExecutePeriodicEffectOnApplication' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, PeriodicInhibitionPolicy) == 0x000241, "Member 'UGameplayEffect::PeriodicInhibitionPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, Modifiers) == 0x000248, "Member 'UGameplayEffect::Modifiers' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, Executions) == 0x000258, "Member 'UGameplayEffect::Executions' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, ChanceToApplyToTarget) == 0x000268, "Member 'UGameplayEffect::ChanceToApplyToTarget' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, ApplicationRequirements) == 0x000290, "Member 'UGameplayEffect::ApplicationRequirements' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, TargetEffectClasses) == 0x0002A0, "Member 'UGameplayEffect::TargetEffectClasses' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, ConditionalGameplayEffects) == 0x0002B0, "Member 'UGameplayEffect::ConditionalGameplayEffects' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, OverflowEffects) == 0x0002C0, "Member 'UGameplayEffect::OverflowEffects' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, bDenyOverflowApplication) == 0x0002D0, "Member 'UGameplayEffect::bDenyOverflowApplication' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, bClearStackOnOverflow) == 0x0002D1, "Member 'UGameplayEffect::bClearStackOnOverflow' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, PrematureExpirationEffectClasses) == 0x0002D8, "Member 'UGameplayEffect::PrematureExpirationEffectClasses' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, RoutineExpirationEffectClasses) == 0x0002E8, "Member 'UGameplayEffect::RoutineExpirationEffectClasses' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, bRequireModifierSuccessToTriggerCues) == 0x0002F8, "Member 'UGameplayEffect::bRequireModifierSuccessToTriggerCues' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, bSuppressStackingCues) == 0x0002F9, "Member 'UGameplayEffect::bSuppressStackingCues' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, GameplayCues) == 0x000300, "Member 'UGameplayEffect::GameplayCues' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, UIData) == 0x000310, "Member 'UGameplayEffect::UIData' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, InheritableGameplayEffectTags) == 0x000318, "Member 'UGameplayEffect::InheritableGameplayEffectTags' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, InheritableOwnedTagsContainer) == 0x000378, "Member 'UGameplayEffect::InheritableOwnedTagsContainer' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, OngoingTagRequirements) == 0x0003D8, "Member 'UGameplayEffect::OngoingTagRequirements' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, ApplicationTagRequirements) == 0x000418, "Member 'UGameplayEffect::ApplicationTagRequirements' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, RemovalTagRequirements) == 0x000458, "Member 'UGameplayEffect::RemovalTagRequirements' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, RemoveGameplayEffectsWithTags) == 0x000498, "Member 'UGameplayEffect::RemoveGameplayEffectsWithTags' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, GrantedApplicationImmunityTags) == 0x0004F8, "Member 'UGameplayEffect::GrantedApplicationImmunityTags' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, GrantedApplicationImmunityQuery) == 0x000538, "Member 'UGameplayEffect::GrantedApplicationImmunityQuery' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, RemoveGameplayEffectQuery) == 0x000690, "Member 'UGameplayEffect::RemoveGameplayEffectQuery' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, StackingType) == 0x0007E1, "Member 'UGameplayEffect::StackingType' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, StackLimitCount) == 0x0007E4, "Member 'UGameplayEffect::StackLimitCount' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, StackDurationRefreshPolicy) == 0x0007E8, "Member 'UGameplayEffect::StackDurationRefreshPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, StackPeriodResetPolicy) == 0x0007E9, "Member 'UGameplayEffect::StackPeriodResetPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, StackExpirationPolicy) == 0x0007EA, "Member 'UGameplayEffect::StackExpirationPolicy' has a wrong offset!");
static_assert(offsetof(UGameplayEffect, GrantedAbilities) == 0x0007F0, "Member 'UGameplayEffect::GrantedAbilities' has a wrong offset!");

// Class GameplayAbilities.GameplayEffectCalculation
// 0x0010 (0x0038 - 0x0028)
class UGameplayEffectCalculation : public UObject
{
public:
	TArray<struct FGameplayEffectAttributeCaptureDefinition> RelevantAttributesToCapture;            // 0x0028(0x0010)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffectCalculation">();
	}
	static class UGameplayEffectCalculation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffectCalculation>();
	}
};
static_assert(alignof(UGameplayEffectCalculation) == 0x000008, "Wrong alignment on UGameplayEffectCalculation");
static_assert(sizeof(UGameplayEffectCalculation) == 0x000038, "Wrong size on UGameplayEffectCalculation");
static_assert(offsetof(UGameplayEffectCalculation, RelevantAttributesToCapture) == 0x000028, "Member 'UGameplayEffectCalculation::RelevantAttributesToCapture' has a wrong offset!");

// Class GameplayAbilities.GameplayEffectCustomApplicationRequirement
// 0x0000 (0x0028 - 0x0028)
class UGameplayEffectCustomApplicationRequirement final : public UObject
{
public:
	bool CanApplyGameplayEffect(const class UGameplayEffect* GameplayEffect, const struct FGameplayEffectSpec& Spec, class UAbilitySystemComponent* ASC) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffectCustomApplicationRequirement">();
	}
	static class UGameplayEffectCustomApplicationRequirement* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffectCustomApplicationRequirement>();
	}
};
static_assert(alignof(UGameplayEffectCustomApplicationRequirement) == 0x000008, "Wrong alignment on UGameplayEffectCustomApplicationRequirement");
static_assert(sizeof(UGameplayEffectCustomApplicationRequirement) == 0x000028, "Wrong size on UGameplayEffectCustomApplicationRequirement");

// Class GameplayAbilities.GameplayEffectExecutionCalculation
// 0x0008 (0x0040 - 0x0038)
class UGameplayEffectExecutionCalculation final : public UGameplayEffectCalculation
{
public:
	bool                                          bRequiresPassedInTags;                             // 0x0038(0x0001)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void Execute(const struct FGameplayEffectCustomExecutionParameters& ExecutionParams, struct FGameplayEffectCustomExecutionOutput* OutExecutionOutput) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffectExecutionCalculation">();
	}
	static class UGameplayEffectExecutionCalculation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffectExecutionCalculation>();
	}
};
static_assert(alignof(UGameplayEffectExecutionCalculation) == 0x000008, "Wrong alignment on UGameplayEffectExecutionCalculation");
static_assert(sizeof(UGameplayEffectExecutionCalculation) == 0x000040, "Wrong size on UGameplayEffectExecutionCalculation");
static_assert(offsetof(UGameplayEffectExecutionCalculation, bRequiresPassedInTags) == 0x000038, "Member 'UGameplayEffectExecutionCalculation::bRequiresPassedInTags' has a wrong offset!");

// Class GameplayAbilities.GameplayEffectUIData
// 0x0000 (0x0028 - 0x0028)
class UGameplayEffectUIData : public UObject
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffectUIData">();
	}
	static class UGameplayEffectUIData* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffectUIData>();
	}
};
static_assert(alignof(UGameplayEffectUIData) == 0x000008, "Wrong alignment on UGameplayEffectUIData");
static_assert(sizeof(UGameplayEffectUIData) == 0x000028, "Wrong size on UGameplayEffectUIData");

// Class GameplayAbilities.GameplayEffectUIData_TextOnly
// 0x0018 (0x0040 - 0x0028)
class UGameplayEffectUIData_TextOnly final : public UGameplayEffectUIData
{
public:
	class FText                                   Description;                                       // 0x0028(0x0018)(Edit, BlueprintVisible, BlueprintReadOnly, DisableEditOnInstance, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayEffectUIData_TextOnly">();
	}
	static class UGameplayEffectUIData_TextOnly* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayEffectUIData_TextOnly>();
	}
};
static_assert(alignof(UGameplayEffectUIData_TextOnly) == 0x000008, "Wrong alignment on UGameplayEffectUIData_TextOnly");
static_assert(sizeof(UGameplayEffectUIData_TextOnly) == 0x000040, "Wrong size on UGameplayEffectUIData_TextOnly");
static_assert(offsetof(UGameplayEffectUIData_TextOnly, Description) == 0x000028, "Member 'UGameplayEffectUIData_TextOnly::Description' has a wrong offset!");

// Class GameplayAbilities.GameplayModMagnitudeCalculation
// 0x0008 (0x0040 - 0x0038)
class UGameplayModMagnitudeCalculation final : public UGameplayEffectCalculation
{
public:
	bool                                          bAllowNonNetAuthorityDependencyRegistration;       // 0x0038(0x0001)(Edit, ZeroConstructor, DisableEditOnInstance, IsPlainOldData, NoDestructor, AdvancedDisplay, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_39[0x7];                                       // 0x0039(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	float CalculateBaseMagnitude(const struct FGameplayEffectSpec& Spec) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayModMagnitudeCalculation">();
	}
	static class UGameplayModMagnitudeCalculation* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayModMagnitudeCalculation>();
	}
};
static_assert(alignof(UGameplayModMagnitudeCalculation) == 0x000008, "Wrong alignment on UGameplayModMagnitudeCalculation");
static_assert(sizeof(UGameplayModMagnitudeCalculation) == 0x000040, "Wrong size on UGameplayModMagnitudeCalculation");
static_assert(offsetof(UGameplayModMagnitudeCalculation, bAllowNonNetAuthorityDependencyRegistration) == 0x000038, "Member 'UGameplayModMagnitudeCalculation::bAllowNonNetAuthorityDependencyRegistration' has a wrong offset!");

// Class GameplayAbilities.GameplayTagReponseTable
// 0x01B8 (0x01E8 - 0x0030)
class UGameplayTagReponseTable final : public UDataAsset
{
public:
	TArray<struct FGameplayTagResponseTableEntry> Entries;                                           // 0x0030(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_40[0x1A8];                                     // 0x0040(0x01A8)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void TagResponseEvent(const struct FGameplayTag& Tag, int32 NewCount, class UAbilitySystemComponent* ASC, int32 idx);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"GameplayTagReponseTable">();
	}
	static class UGameplayTagReponseTable* GetDefaultObj()
	{
		return GetDefaultObjImpl<UGameplayTagReponseTable>();
	}
};
static_assert(alignof(UGameplayTagReponseTable) == 0x000008, "Wrong alignment on UGameplayTagReponseTable");
static_assert(sizeof(UGameplayTagReponseTable) == 0x0001E8, "Wrong size on UGameplayTagReponseTable");
static_assert(offsetof(UGameplayTagReponseTable, Entries) == 0x000030, "Member 'UGameplayTagReponseTable::Entries' has a wrong offset!");

// Class GameplayAbilities.MovieSceneGameplayCueTriggerSection
// 0x0088 (0x0188 - 0x0100)
class UMovieSceneGameplayCueTriggerSection final : public UMovieSceneHookSection
{
public:
	struct FMovieSceneGameplayCueChannel          Channel;                                           // 0x0100(0x0088)(AssetRegistrySearchable, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneGameplayCueTriggerSection">();
	}
	static class UMovieSceneGameplayCueTriggerSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneGameplayCueTriggerSection>();
	}
};
static_assert(alignof(UMovieSceneGameplayCueTriggerSection) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueTriggerSection");
static_assert(sizeof(UMovieSceneGameplayCueTriggerSection) == 0x000188, "Wrong size on UMovieSceneGameplayCueTriggerSection");
static_assert(offsetof(UMovieSceneGameplayCueTriggerSection, Channel) == 0x000100, "Member 'UMovieSceneGameplayCueTriggerSection::Channel' has a wrong offset!");

// Class GameplayAbilities.MovieSceneGameplayCueSection
// 0x0078 (0x0178 - 0x0100)
class UMovieSceneGameplayCueSection final : public UMovieSceneHookSection
{
public:
	struct FMovieSceneGameplayCueKey              Cue;                                               // 0x0100(0x0078)(Edit, NoDestructor, AssetRegistrySearchable, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneGameplayCueSection">();
	}
	static class UMovieSceneGameplayCueSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneGameplayCueSection>();
	}
};
static_assert(alignof(UMovieSceneGameplayCueSection) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueSection");
static_assert(sizeof(UMovieSceneGameplayCueSection) == 0x000178, "Wrong size on UMovieSceneGameplayCueSection");
static_assert(offsetof(UMovieSceneGameplayCueSection, Cue) == 0x000100, "Member 'UMovieSceneGameplayCueSection::Cue' has a wrong offset!");

// Class GameplayAbilities.MovieSceneGameplayCueTrack
// 0x0010 (0x00A0 - 0x0090)
class UMovieSceneGameplayCueTrack final : public UMovieSceneNameableTrack
{
public:
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x0090(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

public:
	static void SetSequencerTrackHandler(TDelegate<void(class AActor* Target, const struct FGameplayTag& GameplayTag, const struct FGameplayCueParameters& Parameters, EGameplayCueEvent Event)> InGameplayCueTrackHandler);

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneGameplayCueTrack">();
	}
	static class UMovieSceneGameplayCueTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneGameplayCueTrack>();
	}
};
static_assert(alignof(UMovieSceneGameplayCueTrack) == 0x000008, "Wrong alignment on UMovieSceneGameplayCueTrack");
static_assert(sizeof(UMovieSceneGameplayCueTrack) == 0x0000A0, "Wrong size on UMovieSceneGameplayCueTrack");
static_assert(offsetof(UMovieSceneGameplayCueTrack, Sections) == 0x000090, "Member 'UMovieSceneGameplayCueTrack::Sections' has a wrong offset!");

// Class GameplayAbilities.TickableAttributeSetInterface
// 0x0000 (0x0000 - 0x0000)
class ITickableAttributeSetInterface final
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"TickableAttributeSetInterface">();
	}
	static class ITickableAttributeSetInterface* GetDefaultObj()
	{
		return GetDefaultObjImpl<ITickableAttributeSetInterface>();
	}

	class UObject* AsUObject()
	{
		return reinterpret_cast<UObject*>(this);
	}
	const class UObject* AsUObject() const
	{
		return reinterpret_cast<const UObject*>(this);
	}
};
static_assert(alignof(ITickableAttributeSetInterface) == 0x000001, "Wrong alignment on ITickableAttributeSetInterface");
static_assert(sizeof(ITickableAttributeSetInterface) == 0x000001, "Wrong size on ITickableAttributeSetInterface");

}