enum class ACLCompressionLevel {
    ACLCL_Lowest = 0,
    ACLCL_Low = 1,
    ACLCL_Medium = 2,
    ACLCL_High = 3,
    ACLCL_Highest = 4,
    ACLCL_Automatic = 5,
    ACLCL_MAX = 6,
};

enum class ACLRotationFormat {
    ACLRF_Quat_128 = 0,
    ACLRF_QuatDropW_96 = 1,
    ACLRF_QuatDropW_Variable = 2,
    ACLRF_MAX = 3,
};

enum class ACLVectorFormat {
    ACLVF_Vector3_96 = 0,
    ACLVF_Vector3_Variable = 1,
    ACLVF_Vector3_MAX = 2,
};

enum class ACLVisualFidelity {
    Highest = 0,
    Medium = 1,
    Lowest = 2,
    ACLVisualFidelity_MAX = 3,
};

enum class ACLVisualFidelityChangeResult {
    Dispatched = 0,
    Completed = 1,
    Failed = 2,
    ACLVisualFidelityChangeResult_MAX = 3,
};

// Size: 0x38
class UAnimBoneCompressionCodec_ACL : public UAnimBoneCompressionCodec_ACLBase {
};

// Size: 0x38
class UAnimBoneCompressionCodec_ACLBase : public UAnimBoneCompressionCodec {
};

// Size: 0x38
class UAnimBoneCompressionCodec_ACLCustom : public UAnimBoneCompressionCodec_ACLBase {
};

// Size: 0x40
class UAnimBoneCompressionCodec_ACLDatabase : public UAnimBoneCompressionCodec_ACLBase {
    /* 0x0038 */ UAnimationCompressionLibraryDatabase* DatabaseAsset;
};

// Size: 0x38
class UAnimBoneCompressionCodec_ACLSafe : public UAnimBoneCompressionCodec_ACLBase {
};

// Size: 0x28
class UAnimCurveCompressionCodec_ACL : public UAnimCurveCompressionCodec {
};

// Size: 0x128
class UAnimationCompressionLibraryDatabase : public UObject {
    /* 0x0028 */ TArray<uint8_t> CookedCompressedBytes;
    /* 0x0038 */ TArray<uint64_t> CookedAnimSequenceMappings;
    /* 0x0120 */ uint32_t MaxStreamRequestSizeKB;
    /* 0x0124 */ ACLVisualFidelity DefaultVisualFidelity;

    static ACLVisualFidelity GetVisualFidelity(UAnimationCompressionLibraryDatabase* DatabaseAsset);
    static void SetVisualFidelity(UObject* WorldContextObject, FLatentActionInfo LatentInfo, UAnimationCompressionLibraryDatabase* DatabaseAsset, ACLVisualFidelityChangeResult& Result, ACLVisualFidelity VisualFidelity);
};

// Size: 0x68
class UAIAsyncTaskBlueprintProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFail;

    void OnMoveCompleted(FAIRequestID RequestId, uint8_t MovementResult);
};

// Size: 0x28
class UAIBlueprintHelperLibrary : public UBlueprintFunctionLibrary {

    static UAIAsyncTaskBlueprintProxy* CreateMoveToProxyObject(UObject* WorldContextObject, APawn* Pawn, FVector destination, AActor* TargetActor, float AcceptanceRadius, bool bStopOnOverlap);
    static AAIController* GetAIController(AActor* ControlledActor);
    static UBlackboardComponent* GetBlackboard(AActor* Target);
    static UNavigationPath* GetCurrentPath(AController* Controller);
    static int32_t GetCurrentPathIndex(const AController* Controller);
    static TArray<FVector> GetCurrentPathPoints(AController* Controller);
    static int32_t GetNextNavLinkIndex(const AController* Controller);
    static bool IsValidAIDirection(FVector DirectionVector);
    static bool IsValidAILocation(FVector Location);
    static bool IsValidAIRotation(FRotator Rotation);
    static void LockAIResourcesWithAnimation(UAnimInstance* AnimInstance, bool bLockMovement, bool LockAILogic);
    static void SendAIMessage(APawn* Target, FName Message, UObject* MessageSource, bool bSuccess);
    static void SimpleMoveToActor(AController* Controller, const AActor* Goal);
    static void SimpleMoveToLocation(AController* Controller, const FVector& Goal);
    static APawn* SpawnAIFromClass(UObject* WorldContextObject, UClass* PawnClass, UBehaviorTree* BehaviorTree, FVector Location, FRotator Rotation, bool bNoCollisionFail, AActor* Owner);
    static void UnlockAIResourcesWithAnimation(UAnimInstance* AnimInstance, bool bUnlockMovement, bool UnlockAILogic);
};

// Size: 0x3c8
class AAIController : public AController {
    /* 0x0378 */ bool bStartAILogicOnPossess;
    /* 0x0378 */ bool bStopAILogicOnUnposses;
    /* 0x0378 */ bool bLOSflag;
    /* 0x0378 */ bool bSkipExtraLOSChecks;
    /* 0x0378 */ bool bAllowStrafe;
    /* 0x0378 */ bool bWantsPlayerState;
    /* 0x0378 */ bool bSetControlRotationFromPawnOrientation;
    /* 0x0380 */ UPathFollowingComponent* PathFollowingComponent;
    /* 0x0388 */ UBrainComponent* BrainComponent;
    /* 0x0390 */ UAIPerceptionComponent* PerceptionComponent;
    /* 0x0398 */ UBlackboardComponent* Blackboard;
    /* 0x03a0 */ UGameplayTasksComponent* CachedGameplayTasksComponent;
    /* 0x03a8 */ UClass* DefaultNavigationFilterClass;
    /* 0x03b0 */ FMulticastInlineDelegate ReceiveMoveCompleted;

    void ClaimTaskResource(UClass* ResourceClass);
    UAIPerceptionComponent* GetAIPerceptionComponent();
    FVector GetFocalPoint() const;
    FVector GetFocalPointOnActor(const AActor* Actor) const;
    AActor* GetFocusActor() const;
    FVector GetImmediateMoveDestination() const;
    uint8_t GetMoveStatus() const;
    UPathFollowingComponent* GetPathFollowingComponent() const;
    bool HasPartialPath() const;
    void K2_ClearFocus();
    void K2_SetFocalPoint(FVector FP);
    void K2_SetFocus(AActor* NewFocus);
    uint8_t MoveToActor(AActor* Goal, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bCanStrafe, UClass* FilterClass, bool bAllowPartialPath);
    uint8_t MoveToLocation(const FVector& Dest, float AcceptanceRadius, bool bStopOnOverlap, bool bUsePathfinding, bool bProjectDestinationToNavigation, bool bCanStrafe, UClass* FilterClass, bool bAllowPartialPath);
    void OnGameplayTaskResourcesClaimed(FGameplayResourceSet NewlyClaimed, FGameplayResourceSet FreshlyReleased);
    void OnUsingBlackBoard(UBlackboardComponent* BlackboardComp, UBlackboardData* BlackboardAsset);
    bool RunBehaviorTree(UBehaviorTree* BTAsset);
    void SetMoveBlockDetection(bool bEnable);
    void SetPathFollowingComponent(UPathFollowingComponent* NewPFComponent);
    void UnclaimTaskResource(UClass* ResourceClass);
    bool UseBlackboard(UBlackboardData* BlackboardAsset, UBlackboardComponent*& BlackboardComponent);
};

// Size: 0x50
struct FAIDamageEvent {
    /* 0x0000 */ float amount;
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FVector HitLocation;
    /* 0x0038 */ AActor* DamagedActor;
    /* 0x0040 */ AActor* Instigator;
    /* 0x0048 */ FName Tag;
};

// Size: 0x28
class UAIDataProvider : public UObject {
};

// Size: 0x38
struct FAIDataProviderBoolValue : public FAIDataProviderTypedValue {
    /* 0x0030 */ bool DefaultValue;
};

// Size: 0x38
struct FAIDataProviderFloatValue : public FAIDataProviderTypedValue {
    /* 0x0030 */ float DefaultValue;
};

// Size: 0x38
struct FAIDataProviderIntValue : public FAIDataProviderTypedValue {
    /* 0x0030 */ int32_t DefaultValue;
};

// Size: 0x30
struct FAIDataProviderStructValue : public FAIDataProviderValue {
};

// Size: 0x30
struct FAIDataProviderTypedValue : public FAIDataProviderValue {
    /* 0x0020 */ UClass* PropertyType;
};

// Size: 0x20
struct FAIDataProviderValue {
    /* 0x0010 */ UAIDataProvider* DataBinding;
    /* 0x0018 */ FName DataField;
};

// Size: 0x40
class UAIDataProvider_QueryParams : public UAIDataProvider {
    /* 0x0028 */ FName paramName;
    /* 0x0030 */ float FloatValue;
    /* 0x0034 */ int32_t IntValue;
    /* 0x0038 */ bool boolValue;
};

// Size: 0x50
class UAIDataProvider_Random : public UAIDataProvider_QueryParams {
    /* 0x0040 */ float min;
    /* 0x0044 */ float max;
    /* 0x0048 */ bool bInteger;
};

// Size: 0x38
struct FAIDynamicParam {
    /* 0x0000 */ FName paramName;
    /* 0x0008 */ EAIParamType ParamType;
    /* 0x0009 */ bool bAllowBBKey;
    /* 0x000c */ float Value;
    /* 0x0010 */ FBlackboardKeySelector BBKey;
};

// Size: 0x28
class UAIHotSpotManager : public UObject {
};

// Size: 0x50
struct FAIMoveRequest {
    /* 0x0000 */ TWeakObjectPtr<AActor> GoalActor;
};

// Size: 0x40
struct FAINoiseEvent {
    /* 0x0008 */ FVector NoiseLocation;
    /* 0x0020 */ float Loudness;
    /* 0x0024 */ float MaxRange;
    /* 0x0028 */ AActor* Instigator;
    /* 0x0030 */ FName Tag;
};

// Size: 0x1a8
class UAIPerceptionComponent : public UActorComponent {
    /* 0x00b8 */ TArray<UAISenseConfig*> SensesConfig;
    /* 0x00c8 */ UClass* DominantSense;
    /* 0x00e0 */ AAIController* AIOwner;
    /* 0x0168 */ FMulticastInlineDelegate OnPerceptionUpdated;
    /* 0x0178 */ FMulticastInlineDelegate OnTargetPerceptionForgotten;
    /* 0x0188 */ FMulticastInlineDelegate OnTargetPerceptionUpdated;
    /* 0x0198 */ FMulticastInlineDelegate OnTargetPerceptionInfoUpdated;

    void ForgetAll();
    bool GetActorsPerception(AActor* Actor, FActorPerceptionBlueprintInfo& Info);
    void GetCurrentlyPerceivedActors(UClass* SenseToUse, TArray<AActor*>& OutActors) const;
    void GetKnownPerceivedActors(UClass* SenseToUse, TArray<AActor*>& OutActors) const;
    void GetPerceivedHostileActors(TArray<AActor*>& OutActors) const;
    void GetPerceivedHostileActorsBySense(const UClass* SenseToUse, TArray<AActor*>& OutActors) const;
    bool IsSenseEnabled(UClass* SenseClass) const;
    void OnOwnerEndPlay(AActor* Actor, uint8_t EndPlayReason);
    void RequestStimuliListenerUpdate();
    void SetSenseEnabled(UClass* SenseClass, const bool bEnable);
};

// Size: 0x28
class IAIPerceptionListenerInterface : public UInterface {
};

// Size: 0xd0
class UAIPerceptionStimuliSourceComponent : public UActorComponent {
    /* 0x00b8 */ bool bAutoRegisterAsSource;
    /* 0x00c0 */ TArray<UClass*> RegisterAsSourceForSenses;

    void RegisterForSense(UClass* SenseClass);
    void RegisterWithPerceptionSystem();
    void UnregisterFromPerceptionSystem();
    void UnregisterFromSense(UClass* SenseClass);
};

// Size: 0x138
class UAIPerceptionSystem : public UAISubsystem {
    /* 0x0088 */ TArray<UAISense*> Senses;
    /* 0x0098 */ float PerceptionAgingRate;

    static UClass* GetSenseClassForStimulus(UObject* WorldContextObject, const FAIStimulus& Stimulus);
    void OnPerceptionStimuliSourceEndPlay(AActor* Actor, uint8_t EndPlayReason);
    static bool RegisterPerceptionStimuliSource(UObject* WorldContextObject, UClass* Sense, AActor* Target);
    void ReportEvent(UAISenseEvent* PerceptionEvent);
    static void ReportPerceptionEvent(UObject* WorldContextObject, UAISenseEvent* PerceptionEvent);
};

// Size: 0x18
struct FAIPredictionEvent {
    /* 0x0000 */ AActor* Requestor;
    /* 0x0008 */ AActor* PredictedActor;
};

// Size: 0x4
struct FAIRequestID {
    /* 0x0000 */ uint32_t RequestId;
};

// Size: 0x28
class IAIResourceInterface : public UInterface {
};

// Size: 0x38
class UAIResource_Logic : public UGameplayTaskResource {
};

// Size: 0x38
class UAIResource_Movement : public UGameplayTaskResource {
};

// Size: 0x78
class UAISense : public UObject {
    /* 0x0028 */ EAISenseNotifyType NotifyType;
    /* 0x002c */ bool bWantsNewPawnNotification;
    /* 0x002c */ bool bAutoRegisterAllPawnsAsSources;
    /* 0x0030 */ UAIPerceptionSystem* PerceptionSystemInstance;
};

// Size: 0x4
struct FAISenseAffiliationFilter {
    /* 0x0000 */ bool bDetectEnemies;
    /* 0x0000 */ bool bDetectNeutrals;
    /* 0x0000 */ bool bDetectFriendlies;
};

// Size: 0x108
class UAISenseBlueprintListener : public UUserDefinedStruct {
};

// Size: 0x48
class UAISenseConfig : public UObject {
    /* 0x0028 */ FColor DebugColor;
    /* 0x002c */ float MaxAge;
    /* 0x0030 */ bool bStartsEnabled;
};

// Size: 0x50
class UAISenseConfig_Blueprint : public UAISenseConfig {
    /* 0x0048 */ UClass* Implementation;
};

// Size: 0x50
class UAISenseConfig_Damage : public UAISenseConfig {
    /* 0x0048 */ UClass* Implementation;
};

// Size: 0x60
class UAISenseConfig_Hearing : public UAISenseConfig {
    /* 0x0048 */ UClass* Implementation;
    /* 0x0050 */ float HearingRange;
    /* 0x0054 */ float LoSHearingRange;
    /* 0x0058 */ bool bUseLoSHearing;
    /* 0x005c */ FAISenseAffiliationFilter DetectionByAffiliation;
};

// Size: 0x48
class UAISenseConfig_Prediction : public UAISenseConfig {
};

// Size: 0x70
class UAISenseConfig_Sight : public UAISenseConfig {
    /* 0x0048 */ UClass* Implementation;
    /* 0x0050 */ float SightRadius;
    /* 0x0054 */ float LoseSightRadius;
    /* 0x0058 */ float PeripheralVisionAngleDegrees;
    /* 0x005c */ FAISenseAffiliationFilter DetectionByAffiliation;
    /* 0x0060 */ float AutoSuccessRangeFromLastSeenLocation;
    /* 0x0064 */ float PointOfViewBackwardOffset;
    /* 0x0068 */ float NearClippingRadius;
};

// Size: 0x48
class UAISenseConfig_Team : public UAISenseConfig {
};

// Size: 0x50
class UAISenseConfig_Touch : public UAISenseConfig {
    /* 0x0048 */ FAISenseAffiliationFilter DetectionByAffiliation;
};

// Size: 0x28
class UAISenseEvent : public UObject {
};

// Size: 0x78
class UAISenseEvent_Damage : public UAISenseEvent {
    /* 0x0028 */ FAIDamageEvent Event;
};

// Size: 0x68
class UAISenseEvent_Hearing : public UAISenseEvent {
    /* 0x0028 */ FAINoiseEvent Event;
};

// Size: 0xa0
class UAISense_Blueprint : public UAISense {
    /* 0x0078 */ UClass* ListenerDataType;
    /* 0x0080 */ TArray<UAIPerceptionComponent*> ListenerContainer;
    /* 0x0090 */ TArray<UAISenseEvent*> UnprocessedEvents;

    void GetAllListenerActors(TArray<AActor*>& ListenerActors) const;
    void GetAllListenerComponents(TArray<UAIPerceptionComponent*>& ListenerComponents) const;
    void K2_OnNewPawn(APawn* NewPawn);
    void OnListenerRegistered(AActor* ActorListener, UAIPerceptionComponent* PerceptionComponent);
    void OnListenerUnregistered(AActor* ActorListener, UAIPerceptionComponent* PerceptionComponent);
    void OnListenerUpdated(AActor* ActorListener, UAIPerceptionComponent* PerceptionComponent);
    float OnUpdate(const TArray<UAISenseEvent*>& EventsToProcess);
};

// Size: 0x88
class UAISense_Damage : public UAISense {
    /* 0x0078 */ TArray<FAIDamageEvent> RegisteredEvents;

    static void ReportDamageEvent(UObject* WorldContextObject, AActor* DamagedActor, AActor* Instigator, float DamageAmount, FVector EventLocation, FVector HitLocation, FName Tag);
};

// Size: 0xe0
class UAISense_Hearing : public UAISense {
    /* 0x0078 */ TArray<FAINoiseEvent> NoiseEvents;
    /* 0x0088 */ float SpeedOfSoundSq;

    static void ReportNoiseEvent(UObject* WorldContextObject, FVector NoiseLocation, float Loudness, AActor* Instigator, float MaxRange, FName Tag);
};

// Size: 0x88
class UAISense_Prediction : public UAISense {
    /* 0x0078 */ TArray<FAIPredictionEvent> RegisteredEvents;

    static void RequestControllerPredictionEvent(AAIController* Requestor, AActor* PredictedActor, float PredictionTime);
    static void RequestPawnPredictionEvent(APawn* Requestor, AActor* PredictedActor, float PredictionTime);
};

// Size: 0x1a8
class UAISense_Sight : public UAISense {
    /* 0x0150 */ int32_t MaxTracesPerTick;
    /* 0x0154 */ int32_t MaxAsyncTracesPerTick;
    /* 0x0158 */ int32_t MinQueriesPerTimeSliceCheck;
    /* 0x0160 */ double MaxTimeSlicePerTick;
    /* 0x0168 */ float HighImportanceQueryDistanceThreshold;
    /* 0x0170 */ float MaxQueryImportance;
    /* 0x0174 */ float SightLimitQueryImportance;
    /* 0x0178 */ float PendingQueriesBudgetReductionRatio;
    /* 0x017c */ bool bUseAsynchronousTraceForDefaultSightQueries;
};

// Size: 0x88
class UAISense_Team : public UAISense {
    /* 0x0078 */ TArray<FAITeamStimulusEvent> RegisteredEvents;
};

// Size: 0xd8
class UAISense_Touch : public UAISense {
    /* 0x0078 */ TArray<FAITouchEvent> RegisteredEvents;

    static void ReportTouchEvent(UObject* WorldContextObject, AActor* TouchReceiver, AActor* OtherActor, FVector Location);
};

// Size: 0x18
struct FAISightEvent {
    /* 0x0008 */ AActor* SeenActor;
    /* 0x0010 */ AActor* Observer;
};

// Size: 0x28
class IAISightTargetInterface : public UInterface {
};

// Size: 0x58
struct FAIStimulus {
    /* 0x0000 */ float Age;
    /* 0x0004 */ float ExpirationAge;
    /* 0x0008 */ float Strength;
    /* 0x0010 */ FVector StimulusLocation;
    /* 0x0028 */ FVector ReceiverLocation;
    /* 0x0040 */ FName Tag;
    /* 0x0054 */ bool bSuccessfullySensed;
};

// Size: 0x38
class UAISubsystem : public UObject {
    /* 0x0030 */ UAISystem* AISystem;
};

// Size: 0x1a0
class UAISystem : public UAISystemBase {
    /* 0x0060 */ FSoftClassPath PerceptionSystemClassName;
    /* 0x0080 */ FSoftClassPath HotSpotManagerClassName;
    /* 0x00a0 */ FSoftClassPath EnvQueryManagerClassName;
    /* 0x00c0 */ float AcceptanceRadius;
    /* 0x00c4 */ float PathfollowingRegularPathPointAcceptanceRadius;
    /* 0x00c8 */ float PathfollowingNavLinkAcceptanceRadius;
    /* 0x00cc */ bool bFinishMoveOnGoalOverlap;
    /* 0x00cd */ bool bAcceptPartialPaths;
    /* 0x00ce */ bool bAllowStrafing;
    /* 0x00cf */ bool bAllowControllersAsEQSQuerier;
    /* 0x00d0 */ bool bEnableDebuggerPlugin;
    /* 0x00d1 */ bool bForgetStaleActors;
    /* 0x00d2 */ bool bAddBlackboardSelfKey;
    /* 0x00d3 */ bool bClearBBEntryOnBTEQSFail;
    /* 0x00d4 */ bool bBlackboardKeyDecoratorAllowsNoneAsValue;
    /* 0x00d8 */ TSoftObjectPtr<UBlackboardData> DefaultBlackboard;
    /* 0x0100 */ uint8_t DefaultSightCollisionChannel;
    /* 0x0108 */ UBehaviorTreeManager* BehaviorTreeManager;
    /* 0x0110 */ UEnvQueryManager* EnvironmentQueryManager;
    /* 0x0118 */ UAIPerceptionSystem* PerceptionSystem;
    /* 0x0120 */ TArray<UAIAsyncTaskBlueprintProxy*> AllProxyObjects;
    /* 0x0130 */ UAIHotSpotManager* HotSpotManager;
    /* 0x0138 */ UNavLocalGridManager* NavLocalGrids;

    void AIIgnorePlayers();
    void AILoggingVerbose();
};

// Size: 0x70
class UAITask : public UGameplayTask {
    /* 0x0068 */ AAIController* OwnerController;
};

// Size: 0x70
class UAITask_LockLogic : public UAITask {
};

// Size: 0x138
class UAITask_MoveTo : public UAITask {
    /* 0x0088 */ FMulticastInlineDelegate OnRequestFailed;
    /* 0x0098 */ FMulticastInlineDelegate OnMoveFinished;
    /* 0x00a8 */ FAIMoveRequest MoveRequest;

    static UAITask_MoveTo* AIMoveTo(AAIController* Controller, FVector GoalLocation, AActor* GoalActor, float AcceptanceRadius, uint8_t StopOnOverlap, uint8_t AcceptPartialPath, bool bUsePathfinding, bool bLockAILogic, bool bUseContinuousGoalTracking, uint8_t ProjectGoalOnNavigation, uint8_t RequireNavigableEndLocation);
};

// Size: 0xe8
class UAITask_RunEQS : public UAITask {

    static UAITask_RunEQS* RunEQS(AAIController* Controller, UEnvQuery* QueryTemplate);
};

// Size: 0x50
struct FAITeamStimulusEvent {
    /* 0x0040 */ AActor* Broadcaster;
    /* 0x0048 */ AActor* Enemy;
};

// Size: 0x30
struct FAITouchEvent {
    /* 0x0018 */ AActor* TouchReceiver;
    /* 0x0020 */ AActor* OtherActor;
};

// Size: 0x20
struct FActorPerceptionBlueprintInfo {
    /* 0x0000 */ AActor* Target;
    /* 0x0008 */ TArray<FAIStimulus> LastSensedStimuli;
    /* 0x0018 */ bool bIsHostile;
    /* 0x0018 */ bool bIsFriendly;
};

// Size: 0x68
struct FActorPerceptionUpdateInfo {
    /* 0x0000 */ int32_t TargetId;
    /* 0x0004 */ TWeakObjectPtr<AActor> Target;
    /* 0x0010 */ FAIStimulus Stimulus;
};

// Size: 0x60
class UBTAuxiliaryNode : public UBTNode {
};

// Size: 0x30
struct FBTCompositeChild {
    /* 0x0000 */ UBTCompositeNode* ChildComposite;
    /* 0x0008 */ UBTTaskNode* ChildTask;
    /* 0x0010 */ TArray<UBTDecorator*> Decorators;
    /* 0x0020 */ TArray<FBTDecoratorLogic> DecoratorOps;
};

// Size: 0x80
class UBTCompositeNode : public UBTNode {
    /* 0x0058 */ TArray<FBTCompositeChild> Children;
    /* 0x0068 */ TArray<UBTService*> Services;
    /* 0x0078 */ bool bApplyDecoratorScope;
};

// Size: 0x80
class UBTComposite_Selector : public UBTCompositeNode {
};

// Size: 0x80
class UBTComposite_Sequence : public UBTCompositeNode {
};

// Size: 0x88
class UBTComposite_SimpleParallel : public UBTCompositeNode {
    /* 0x0080 */ uint8_t FinishMode;
};

// Size: 0x68
class UBTDecorator : public UBTAuxiliaryNode {
    /* 0x0060 */ bool bInverseCondition;
    /* 0x0064 */ uint8_t FlowAbortMode;
};

// Size: 0x4
struct FBTDecoratorLogic {
    /* 0x0000 */ uint8_t Operation;
    /* 0x0002 */ uint16_t Number;
};

// Size: 0xc0
class UBTDecorator_Blackboard : public UBTDecorator_BlackboardBase {
    /* 0x0090 */ int32_t IntValue;
    /* 0x0094 */ float FloatValue;
    /* 0x0098 */ FString StringValue;
    /* 0x00a8 */ FString CachedDescription;
    /* 0x00b8 */ uint8_t OperationType;
    /* 0x00b9 */ uint8_t NotifyObserver;
};

// Size: 0x90
class UBTDecorator_BlackboardBase : public UBTDecorator {
    /* 0x0068 */ FBlackboardKeySelector BlackboardKey;
};

// Size: 0xa0
class UBTDecorator_BlueprintBase : public UBTDecorator {
    /* 0x0068 */ AAIController* AIOwner;
    /* 0x0070 */ AActor* ActorOwner;
    /* 0x0078 */ TArray<FName> ObservedKeyNames;
    /* 0x0098 */ bool bShowPropertyDetails;
    /* 0x0098 */ bool bCheckConditionOnlyBlackBoardChanges;

    bool IsDecoratorExecutionActive() const;
    bool IsDecoratorObserverActive() const;
    bool PerformConditionCheck(AActor* OwnerActor);
    bool PerformConditionCheckAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveExecutionFinish(AActor* OwnerActor, uint8_t NodeResult);
    void ReceiveExecutionFinishAI(AAIController* OwnerController, APawn* ControlledPawn, uint8_t NodeResult);
    void ReceiveExecutionStart(AActor* OwnerActor);
    void ReceiveExecutionStartAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveObserverActivated(AActor* OwnerActor);
    void ReceiveObserverActivatedAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveObserverDeactivated(AActor* OwnerActor);
    void ReceiveObserverDeactivatedAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveTick(AActor* OwnerActor, float DeltaSeconds);
    void ReceiveTickAI(AAIController* OwnerController, APawn* ControlledPawn, float DeltaSeconds);
};

// Size: 0xc8
class UBTDecorator_CheckGameplayTagsOnActor : public UBTDecorator {
    /* 0x0068 */ FBlackboardKeySelector ActorToCheck;
    /* 0x0090 */ EGameplayContainerMatchType TagsToMatch;
    /* 0x0098 */ FGameplayTagContainer GameplayTags;
    /* 0x00b8 */ FString CachedDescription;
};

// Size: 0xc0
class UBTDecorator_CompareBBEntries : public UBTDecorator {
    /* 0x0068 */ uint8_t Operator;
    /* 0x0070 */ FBlackboardKeySelector BlackboardKeyA;
    /* 0x0098 */ FBlackboardKeySelector BlackboardKeyB;
};

// Size: 0xc0
class UBTDecorator_ConditionalLoop : public UBTDecorator_Blackboard {
};

// Size: 0xf0
class UBTDecorator_ConeCheck : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Float ConeHalfAngle;
    /* 0x0078 */ FBlackboardKeySelector ConeOrigin;
    /* 0x00a0 */ FBlackboardKeySelector ConeDirection;
    /* 0x00c8 */ FBlackboardKeySelector Observed;
};

// Size: 0x78
class UBTDecorator_Cooldown : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Float CoolDownTime;
};

// Size: 0x108
class UBTDecorator_DoesPathExist : public UBTDecorator {
    /* 0x0068 */ FBlackboardKeySelector BlackboardKeyA;
    /* 0x0090 */ FBlackboardKeySelector BlackboardKeyB;
    /* 0x00b8 */ bool bUseSelf;
    /* 0x00c0 */ FValueOrBBKey_Enum PathQueryType;
    /* 0x00e8 */ FValueOrBBKey_Class FilterClass;
};

// Size: 0x68
class UBTDecorator_ForceSuccess : public UBTDecorator {
};

// Size: 0xf8
class UBTDecorator_IsAtLocation : public UBTDecorator_BlackboardBase {
    /* 0x0090 */ float AcceptableRadius;
    /* 0x0098 */ FAIDataProviderFloatValue ParametrizedAcceptableRadius;
    /* 0x00d0 */ FAIDistanceType GeometricDistanceType;
    /* 0x00d4 */ bool bUseParametrizedRadius;
    /* 0x00d8 */ FValueOrBBKey_Bool bUseNavAgentGoalLocation;
    /* 0x00e8 */ FValueOrBBKey_Bool bPathFindingBasedTest;
};

// Size: 0xb0
class UBTDecorator_IsBBEntryOfClass : public UBTDecorator_BlackboardBase {
    /* 0x0090 */ FValueOrBBKey_Class TestClass;
};

// Size: 0xd0
class UBTDecorator_KeepInCone : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Float ConeHalfAngle;
    /* 0x0078 */ FBlackboardKeySelector ConeOrigin;
    /* 0x00a0 */ FBlackboardKeySelector Observed;
    /* 0x00c8 */ bool bUseSelfAsOrigin;
    /* 0x00c8 */ bool bUseSelfAsObserved;
};

// Size: 0x90
class UBTDecorator_Loop : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Int32 NumLoops;
    /* 0x0078 */ bool bInfiniteLoop;
    /* 0x007c */ FValueOrBBKey_Float InfiniteLoopTimeoutTime;
};

// Size: 0x90
class UBTDecorator_LoopUntil : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Enum RequiredResult;
};

// Size: 0x68
class UBTDecorator_ReachedMoveGoal : public UBTDecorator {
};

// Size: 0x90
class UBTDecorator_SetTagCooldown : public UBTDecorator {
    /* 0x0068 */ FGameplayTag CooldownTag;
    /* 0x0070 */ FValueOrBBKey_Float CooldownDuration;
    /* 0x0080 */ FValueOrBBKey_Bool bAddToExistingDuration;
};

// Size: 0xa0
class UBTDecorator_TagCooldown : public UBTDecorator {
    /* 0x0068 */ FGameplayTag CooldownTag;
    /* 0x0070 */ FValueOrBBKey_Float CooldownDuration;
    /* 0x0080 */ FValueOrBBKey_Bool bAddToExistingDuration;
    /* 0x0090 */ FValueOrBBKey_Bool bActivatesCooldown;
};

// Size: 0x78
class UBTDecorator_TimeLimit : public UBTDecorator {
    /* 0x0068 */ FValueOrBBKey_Float TimeLimit;
};

// Size: 0x28
class UBTFunctionLibrary : public UBlueprintFunctionLibrary {

    static void ClearBlackboardValue(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static void ClearBlackboardValueAsVector(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static AActor* GetBlackboardValueAsActor(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static bool GetBlackboardValueAsBool(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static UClass* GetBlackboardValueAsClass(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static uint8_t GetBlackboardValueAsEnum(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static float GetBlackboardValueAsFloat(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static int32_t GetBlackboardValueAsInt(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static FName GetBlackboardValueAsName(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static UObject* GetBlackboardValueAsObject(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static FRotator GetBlackboardValueAsRotator(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static FString GetBlackboardValueAsString(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static FVector GetBlackboardValueAsVector(UBTNode* NodeOwner, const FBlackboardKeySelector& Key);
    static UBehaviorTreeComponent* GetOwnerComponent(UBTNode* NodeOwner);
    static UBlackboardComponent* GetOwnersBlackboard(UBTNode* NodeOwner);
    static void SetBlackboardValueAsBool(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, bool Value);
    static void SetBlackboardValueAsClass(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, UClass* Value);
    static void SetBlackboardValueAsEnum(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, uint8_t Value);
    static void SetBlackboardValueAsFloat(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, float Value);
    static void SetBlackboardValueAsInt(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, int32_t Value);
    static void SetBlackboardValueAsName(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, FName Value);
    static void SetBlackboardValueAsObject(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, UObject* Value);
    static void SetBlackboardValueAsRotator(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, FRotator Value);
    static void SetBlackboardValueAsString(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, FString Value);
    static void SetBlackboardValueAsVector(UBTNode* NodeOwner, const FBlackboardKeySelector& Key, FVector Value);
    static void StartUsingExternalEvent(UBTNode* NodeOwner, AActor* OwningActor);
    static void StopUsingExternalEvent(UBTNode* NodeOwner);
};

// Size: 0x58
class UBTNode : public UObject {
    /* 0x0030 */ FString NodeName;
    /* 0x0040 */ UBehaviorTree* TreeAsset;
    /* 0x0048 */ UBTCompositeNode* ParentNode;
};

// Size: 0x70
class UBTService : public UBTAuxiliaryNode {
    /* 0x0060 */ float interval;
    /* 0x0064 */ float RandomDeviation;
    /* 0x0068 */ bool bCallTickOnSearchStart;
    /* 0x0068 */ bool bRestartTimerOnEachActivation;
};

// Size: 0x98
class UBTService_BlackboardBase : public UBTService {
    /* 0x0070 */ FBlackboardKeySelector BlackboardKey;
};

// Size: 0x98
class UBTService_BlueprintBase : public UBTService {
    /* 0x0070 */ AAIController* AIOwner;
    /* 0x0078 */ AActor* ActorOwner;
    /* 0x0090 */ bool bShowPropertyDetails;
    /* 0x0090 */ bool bShowEventDetails;

    bool IsServiceActive() const;
    void ReceiveActivation(AActor* OwnerActor);
    void ReceiveActivationAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveDeactivation(AActor* OwnerActor);
    void ReceiveDeactivationAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveSearchStart(AActor* OwnerActor);
    void ReceiveSearchStartAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveTick(AActor* OwnerActor, float DeltaSeconds);
    void ReceiveTickAI(AAIController* OwnerController, APawn* ControlledPawn, float DeltaSeconds);
};

// Size: 0xa0
class UBTService_DefaultFocus : public UBTService_BlackboardBase {
    /* 0x0098 */ uint8_t FocusPriority;
};

// Size: 0xf8
class UBTService_RunEQS : public UBTService_BlackboardBase {
    /* 0x0098 */ FEQSParametrizedQueryExecutionRequest EQSRequest;
    /* 0x00e0 */ bool bUpdateBBOnFail;
};

// Size: 0x70
class UBTTaskNode : public UBTNode {
    /* 0x0058 */ TArray<UBTService*> Services;
    /* 0x0068 */ bool bIgnoreRestartSelf;
};

// Size: 0x98
class UBTTask_BlackboardBase : public UBTTaskNode {
    /* 0x0070 */ FBlackboardKeySelector BlackboardKey;
};

// Size: 0xa8
class UBTTask_BlueprintBase : public UBTTaskNode {
    /* 0x0070 */ AAIController* AIOwner;
    /* 0x0078 */ AActor* ActorOwner;
    /* 0x0080 */ FIntervalCountdown TickInterval;
    /* 0x00a0 */ bool bShowPropertyDetails;

    void FinishAbort();
    void FinishExecute(bool bSuccess);
    bool IsTaskAborting() const;
    bool IsTaskExecuting() const;
    void ReceiveAbort(AActor* OwnerActor);
    void ReceiveAbortAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveExecute(AActor* OwnerActor);
    void ReceiveExecuteAI(AAIController* OwnerController, APawn* ControlledPawn);
    void ReceiveTick(AActor* OwnerActor, float DeltaSeconds);
    void ReceiveTickAI(AAIController* OwnerController, APawn* ControlledPawn, float DeltaSeconds);
    void SetFinishOnMessage(FName MessageName);
    void SetFinishOnMessageWithId(FName MessageName, int32_t RequestId);
};

// Size: 0x98
class UBTTask_FinishWithResult : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Enum Result;
};

// Size: 0x80
class UBTTask_GameplayTaskBase : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Bool bWaitForGameplayTask;
};

// Size: 0x80
class UBTTask_MakeNoise : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Float Loudnes;
};

// Size: 0x160
class UBTTask_MoveDirectlyToward : public UBTTask_MoveTo {
};

// Size: 0x160
class UBTTask_MoveTo : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Float AcceptableRadius;
    /* 0x00a8 */ FValueOrBBKey_Class FilterClass;
    /* 0x00c8 */ FValueOrBBKey_Float ObservedBlackboardValueTolerance;
    /* 0x00d8 */ FValueOrBBKey_Bool bAllowStrafe;
    /* 0x00e8 */ FValueOrBBKey_Bool bAllowPartialPath;
    /* 0x00f8 */ FValueOrBBKey_Bool bTrackMovingGoal;
    /* 0x0108 */ FValueOrBBKey_Bool bRequireNavigableEndLocation;
    /* 0x0118 */ FValueOrBBKey_Bool bProjectGoalLocation;
    /* 0x0128 */ FValueOrBBKey_Bool bReachTestIncludesAgentRadius;
    /* 0x0138 */ FValueOrBBKey_Bool bReachTestIncludesGoalRadius;
    /* 0x0148 */ FValueOrBBKey_Bool bStartFromPreviousPath;
    /* 0x0158 */ bool bObserveBlackboardValue;
};

// Size: 0xe0
class UBTTask_PlayAnimation : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Object animationToPlay;
    /* 0x0090 */ FValueOrBBKey_Bool bLooping;
    /* 0x00a0 */ FValueOrBBKey_Bool bNonBlocking;
    /* 0x00b0 */ UBehaviorTreeComponent* MyOwnerComp;
    /* 0x00b8 */ USkeletalMeshComponent* CachedSkelMesh;
};

// Size: 0x90
class UBTTask_PlaySound : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Object SoundToPlay;
};

// Size: 0xa8
class UBTTask_RotateToFaceBBEntry : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Float Precision;
};

// Size: 0x78
class UBTTask_RunBehavior : public UBTTaskNode {
    /* 0x0070 */ UBehaviorTree* BehaviorAsset;
};

// Size: 0x88
class UBTTask_RunBehaviorDynamic : public UBTTaskNode {
    /* 0x0070 */ FGameplayTag InjectionTag;
    /* 0x0078 */ UBehaviorTree* DefaultBehaviorAsset;
    /* 0x0080 */ UBehaviorTree* BehaviorAsset;
};

// Size: 0x100
class UBTTask_RunEQSQuery : public UBTTask_BlackboardBase {
    /* 0x0098 */ bool bUseBBKey;
    /* 0x00a0 */ FEQSParametrizedQueryExecutionRequest EQSRequest;
    /* 0x00e8 */ bool bUpdateBBOnFail;
};

// Size: 0xa8
class UBTTask_SetKeyValueBool : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Bool Value;
};

// Size: 0xc0
class UBTTask_SetKeyValueClass : public UBTTask_BlackboardBase {
    /* 0x0098 */ UClass* BaseClass;
    /* 0x00a0 */ FValueOrBBKey_Class Value;
};

// Size: 0xc8
class UBTTask_SetKeyValueEnum : public UBTTask_BlackboardBase {
    /* 0x0098 */ UEnum* EnumType;
    /* 0x00a0 */ FValueOrBBKey_Enum Value;
};

// Size: 0xa8
class UBTTask_SetKeyValueFloat : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Float Value;
};

// Size: 0xa8
class UBTTask_SetKeyValueInt32 : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Int32 Value;
};

// Size: 0xb0
class UBTTask_SetKeyValueName : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Name Value;
};

// Size: 0xc0
class UBTTask_SetKeyValueObject : public UBTTask_BlackboardBase {
    /* 0x0098 */ UClass* BaseClass;
    /* 0x00a0 */ FValueOrBBKey_Object Value;
};

// Size: 0xc0
class UBTTask_SetKeyValueRotator : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Rotator Value;
};

// Size: 0xb8
class UBTTask_SetKeyValueString : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_String Value;
};

// Size: 0xc0
class UBTTask_SetKeyValueStruct : public UBTTask_BlackboardBase {
    /* 0x0098 */ UScriptStruct* StructType;
    /* 0x00a0 */ FValueOrBBKey_Struct Value;
};

// Size: 0xc0
class UBTTask_SetKeyValueVector : public UBTTask_BlackboardBase {
    /* 0x0098 */ FValueOrBBKey_Vector Value;
};

// Size: 0x98
class UBTTask_SetTagCooldown : public UBTTaskNode {
    /* 0x0070 */ FGameplayTag CooldownTag;
    /* 0x0078 */ FValueOrBBKey_Bool bAddToExistingDuration;
    /* 0x0088 */ FValueOrBBKey_Float CooldownDuration;
};

// Size: 0x90
class UBTTask_Wait : public UBTTaskNode {
    /* 0x0070 */ FValueOrBBKey_Float WaitTime;
    /* 0x0080 */ FValueOrBBKey_Float RandomDeviation;
};

// Size: 0xb8
class UBTTask_WaitBlackboardTime : public UBTTask_Wait {
    /* 0x0090 */ FBlackboardKeySelector BlackboardKey;
};

// Size: 0x68
class UBehaviorTree : public UObject {
    /* 0x0030 */ UBTCompositeNode* RootNode;
    /* 0x0038 */ UBlackboardData* BlackboardAsset;
    /* 0x0040 */ TArray<UBTDecorator*> RootDecorators;
    /* 0x0050 */ TArray<FBTDecoratorLogic> RootDecoratorOps;
};

// Size: 0x2a8
class UBehaviorTreeComponent : public UBrainComponent {
    /* 0x0130 */ TArray<UBTNode*> NodeInstances;
    /* 0x0288 */ UBehaviorTree* DefaultBehaviorTreeAsset;

    void AddCooldownTagDuration(FGameplayTag CooldownTag, float CooldownDuration, bool bAddToExistingDuration);
    double GetTagCooldownEndTime(FGameplayTag CooldownTag) const;
    void SetDynamicSubtree(FGameplayTag InjectTag, UBehaviorTree* BehaviorAsset);
};

// Size: 0x50
class UBehaviorTreeManager : public UObject {
    /* 0x0028 */ int32_t MaxDebuggerSteps;
    /* 0x0030 */ TArray<FBehaviorTreeTemplateInfo> LoadedTemplates;
    /* 0x0040 */ TArray<UBehaviorTreeComponent*> ActiveComponents;
};

// Size: 0x18
struct FBehaviorTreeTemplateInfo {
    /* 0x0000 */ UBehaviorTree* Asset;
    /* 0x0008 */ UBTCompositeNode* Template;
};

// Size: 0x28
class UBehaviorTreeTypes : public UObject {
};

// Size: 0x28
class IBlackboardAssetProvider : public UInterface {

    UBlackboardData* GetBlackboardAsset() const;
};

// Size: 0x1c0
class UBlackboardComponent : public UActorComponent {
    /* 0x00b8 */ UBrainComponent* BrainComp;
    /* 0x00c0 */ UBlackboardData* DefaultBlackboardAsset;
    /* 0x00c8 */ UBlackboardData* BlackboardAsset;
    /* 0x00f0 */ TArray<UBlackboardKeyType*> KeyInstances;

    void ClearValue(const FName& KeyName);
    bool GetLocationFromEntry(const FName& KeyName, FVector& ResultLocation) const;
    bool GetRotationFromEntry(const FName& KeyName, FRotator& ResultRotation) const;
    bool GetValueAsBool(const FName& KeyName) const;
    UClass* GetValueAsClass(const FName& KeyName) const;
    uint8_t GetValueAsEnum(const FName& KeyName) const;
    float GetValueAsFloat(const FName& KeyName) const;
    int32_t GetValueAsInt(const FName& KeyName) const;
    FName GetValueAsName(const FName& KeyName) const;
    UObject* GetValueAsObject(const FName& KeyName) const;
    FRotator GetValueAsRotator(const FName& KeyName) const;
    FString GetValueAsString(const FName& KeyName) const;
    FVector GetValueAsVector(const FName& KeyName) const;
    bool IsVectorValueSet(const FName& KeyName) const;
    void SetValueAsBool(const FName& KeyName, bool boolValue);
    void SetValueAsClass(const FName& KeyName, UClass* ClassValue);
    void SetValueAsEnum(const FName& KeyName, uint8_t EnumValue);
    void SetValueAsFloat(const FName& KeyName, float FloatValue);
    void SetValueAsInt(const FName& KeyName, int32_t IntValue);
    void SetValueAsName(const FName& KeyName, FName NameValue);
    void SetValueAsObject(const FName& KeyName, UObject* ObjectValue);
    void SetValueAsRotator(const FName& KeyName, FRotator VectorValue);
    void SetValueAsString(const FName& KeyName, FString StringValue);
    void SetValueAsVector(const FName& KeyName, FVector VectorValue);
};

// Size: 0x50
class UBlackboardData : public UDataAsset {
    /* 0x0030 */ UBlackboardData* Parent;
    /* 0x0038 */ TArray<FBlackboardEntry> Keys;
    /* 0x0048 */ bool bHasSynchronizedKeys;
};

// Size: 0x18
struct FBlackboardEntry {
    /* 0x0000 */ FName EntryName;
    /* 0x0008 */ UBlackboardKeyType* KeyType;
    /* 0x0010 */ bool bInstanceSynced;
};

// Size: 0x28
struct FBlackboardKeySelector {
    /* 0x0000 */ TArray<UBlackboardKeyType*> AllowedTypes;
    /* 0x0010 */ FName SelectedKeyName;
    /* 0x0018 */ UClass* SelectedKeyType;
    /* 0x0020 */ int32_t SelectedKeyID;
    /* 0x0024 */ bool bNoneIsAllowedValue;
};

// Size: 0x30
class UBlackboardKeyType : public UObject {
};

// Size: 0x38
class UBlackboardKeyType_Bool : public UBlackboardKeyType {
    /* 0x0030 */ bool bDefaultValue;
};

// Size: 0x40
class UBlackboardKeyType_Class : public UBlackboardKeyType {
    /* 0x0030 */ UClass* BaseClass;
    /* 0x0038 */ UClass* DefaultValue;
};

// Size: 0x50
class UBlackboardKeyType_Enum : public UBlackboardKeyType {
    /* 0x0030 */ UEnum* EnumType;
    /* 0x0038 */ FString EnumName;
    /* 0x0048 */ uint8_t DefaultValue;
    /* 0x004c */ bool bIsEnumNameValid;
};

// Size: 0x38
class UBlackboardKeyType_Float : public UBlackboardKeyType {
    /* 0x0030 */ float DefaultValue;
};

// Size: 0x38
class UBlackboardKeyType_Int : public UBlackboardKeyType {
    /* 0x0030 */ int32_t DefaultValue;
};

// Size: 0x38
class UBlackboardKeyType_Name : public UBlackboardKeyType {
    /* 0x0030 */ FName DefaultValue;
};

// Size: 0x48
class UBlackboardKeyType_NativeEnum : public UBlackboardKeyType {
    /* 0x0030 */ FString EnumName;
    /* 0x0040 */ UEnum* EnumType;
};

// Size: 0x40
class UBlackboardKeyType_Object : public UBlackboardKeyType {
    /* 0x0030 */ UClass* BaseClass;
    /* 0x0038 */ UObject* DefaultValue;
};

// Size: 0x50
class UBlackboardKeyType_Rotator : public UBlackboardKeyType {
    /* 0x0030 */ FRotator DefaultValue;
    /* 0x0048 */ bool bUseDefaultValue;
};

// Size: 0x50
class UBlackboardKeyType_String : public UBlackboardKeyType {
    /* 0x0030 */ FString StringValue;
    /* 0x0040 */ FString DefaultValue;
};

// Size: 0x50
class UBlackboardKeyType_Struct : public UBlackboardKeyType {
    /* 0x0030 */ FInstancedStruct DefaultValue;
    /* 0x0040 */ FInstancedStruct Value;
};

// Size: 0x50
class UBlackboardKeyType_Vector : public UBlackboardKeyType {
    /* 0x0030 */ FVector DefaultValue;
    /* 0x0048 */ bool bUseDefaultValue;
};

// Size: 0x110
class UBrainComponent : public UActorComponent {
    /* 0x00c0 */ UBlackboardComponent* BlackboardComp;
    /* 0x00c8 */ AAIController* AIOwner;

    bool IsPaused() const;
    bool IsRunning() const;
    void RestartLogic();
    void StartLogic();
    void StopLogic(FString Reason);
};

// Size: 0x4
struct FCompactIndexedHandleBase {
};

// Size: 0x28
class ICrowdAgentInterface : public UInterface {
};

// Size: 0x1c
struct FCrowdAvoidanceConfig {
    /* 0x0000 */ float VelocityBias;
    /* 0x0004 */ float DesiredVelocityWeight;
    /* 0x0008 */ float CurrentVelocityWeight;
    /* 0x000c */ float SideBiasWeight;
    /* 0x0010 */ float ImpactTimeWeight;
    /* 0x0014 */ float ImpactTimeRange;
    /* 0x0018 */ uint8_t CustomPatternIdx;
    /* 0x0019 */ uint8_t AdaptiveDivisions;
    /* 0x001a */ uint8_t AdaptiveRings;
    /* 0x001b */ uint8_t AdaptiveDepth;
};

// Size: 0x20
struct FCrowdAvoidanceSamplingPattern {
    /* 0x0000 */ TArray<float> Angles;
    /* 0x0010 */ TArray<float> Radii;
};

// Size: 0x358
class UCrowdFollowingComponent : public UPathFollowingComponent {
    /* 0x0320 */ FVector CrowdAgentMoveDirection;

    void SuspendCrowdSteering(bool bSuspend);
};

// Size: 0xf0
class UCrowdManager : public UCrowdManagerBase {
    /* 0x0028 */ ANavigationData* MyNavData;
    /* 0x0030 */ TArray<FCrowdAvoidanceConfig> AvoidanceConfig;
    /* 0x0040 */ TArray<FCrowdAvoidanceSamplingPattern> SamplingPatterns;
    /* 0x0050 */ int32_t MaxAgents;
    /* 0x0054 */ float MaxAgentRadius;
    /* 0x0058 */ int32_t MaxAvoidedAgents;
    /* 0x005c */ int32_t MaxAvoidedWalls;
    /* 0x0060 */ float NavmeshCheckInterval;
    /* 0x0064 */ float PathOptimizationInterval;
    /* 0x0068 */ float SeparationDirClamp;
    /* 0x006c */ float PathOffsetRadiusMultiplier;
    /* 0x0070 */ bool bResolveCollisions;
};

// Size: 0x3c8
class ADetourCrowdAIController : public AAIController {
};

enum class EAILockSource {
    Animation = 0,
    Logic = 1,
    Script = 2,
    Gameplay = 3,
    MAX = 4,
};

enum class EAIOptionFlag {
    Default = 0,
    Enable = 1,
    Disable = 2,
    MAX = 3,
};

enum class EAIParamType {
    Float = 0,
    Int = 1,
    Bool = 2,
    MAX = 3,
};

enum class EAIRequestPriority {
    SoftScript = 0,
    Logic = 1,
    HardScript = 2,
    Reaction = 3,
    Ultimate = 4,
    MAX = 5,
};

enum class EAISenseNotifyType {
    OnEveryPerception = 0,
    OnPerceptionChange = 1,
    EAISenseNotifyType_MAX = 2,
};

enum class EAITaskPriority {
    Lowest = 0,
    Low = 64,
    AutonomousAI = 127,
    High = 192,
    Ultimate = 254,
    EAITaskPriority_MAX = 255,
};

enum class EArithmeticKeyOperation {
    Equal = 0,
    NotEqual = 1,
    Less = 2,
    LessOrEqual = 3,
    Greater = 4,
    GreaterOrEqual = 5,
    EArithmeticKeyOperation_MAX = 6,
};

enum class EBTBlackboardRestart {
    ValueChange = 0,
    ResultChange = 1,
    EBTBlackboardRestart_MAX = 2,
};

enum class EBTChildIndex {
    FirstNode = 0,
    TaskNode = 1,
    EBTChildIndex_MAX = 2,
};

enum class EBTDecoratorLogic {
    Invalid = 0,
    Test = 1,
    And = 2,
    Or = 3,
    Not = 4,
    EBTDecoratorLogic_MAX = 5,
};

enum class EBTFlowAbortMode {
    None = 0,
    LowerPriority = 1,
    Self = 2,
    Both = 3,
    EBTFlowAbortMode_MAX = 4,
};

enum class EBTNodeResult {
    Succeeded = 0,
    Failed = 1,
    Aborted = 2,
    InProgress = 3,
    EBTNodeResult_MAX = 4,
};

enum class EBTParallelMode {
    AbortBackground = 0,
    WaitForBackground = 1,
    EBTParallelMode_MAX = 2,
};

enum class EBasicKeyOperation {
    Set = 0,
    NotSet = 1,
    EBasicKeyOperation_MAX = 2,
};

enum class EBlackBoardEntryComparison {
    Equal = 0,
    NotEqual = 1,
    EBlackBoardEntryComparison_MAX = 2,
};

enum class EEQSNormalizationType {
    Absolute = 0,
    RelativeToScores = 1,
    EEQSNormalizationType_MAX = 2,
};

enum class EEnvDirection {
    TwoPoints = 0,
    Rotation = 1,
    EEnvDirection_MAX = 2,
};

enum class EEnvOverlapShape {
    Box = 0,
    Sphere = 1,
    Capsule = 2,
    EEnvOverlapShape_MAX = 3,
};

enum class EEnvQueryHightlightMode {
    All = 0,
    Best5Pct = 1,
    Best25Pct = 2,
    EEnvQueryHightlightMode_MAX = 3,
};

enum class EEnvQueryParam {
    Float = 0,
    Int = 1,
    Bool = 2,
    EEnvQueryParam_MAX = 3,
};

enum class EEnvQueryRunMode {
    SingleResult = 0,
    RandomBest5Pct = 1,
    RandomBest25Pct = 2,
    AllMatching = 3,
    EEnvQueryRunMode_MAX = 4,
};

enum class EEnvQueryStatus {
    Processing = 0,
    Success = 1,
    Failed = 2,
    Aborted = 3,
    OwnerLost = 4,
    MissingParam = 5,
    EEnvQueryStatus_MAX = 6,
};

enum class EEnvQueryTestClamping {
    None = 0,
    SpecifiedValue = 1,
    FilterThreshold = 2,
    EEnvQueryTestClamping_MAX = 3,
};

enum class EEnvQueryTrace {
    None = 0,
    Navigation = 1,
    GeometryByChannel = 2,
    GeometryByProfile = 3,
    NavigationOverLedges = 4,
    EEnvQueryTrace_MAX = 5,
};

enum class EEnvTestCost {
    Low = 0,
    Medium = 1,
    High = 2,
    EEnvTestCost_MAX = 3,
};

enum class EEnvTestDistance {
    Distance3D = 0,
    Distance2D = 1,
    DistanceZ = 2,
    DistanceAbsoluteZ = 3,
    EEnvTestDistance_MAX = 4,
};

enum class EEnvTestDot {
    Dot3D = 0,
    Dot2D = 1,
    EEnvTestDot_MAX = 2,
};

enum class EEnvTestFilterOperator {
    AllPass = 0,
    AnyPass = 1,
    EEnvTestFilterOperator_MAX = 2,
};

enum class EEnvTestFilterType {
    Minimum = 0,
    Maximum = 1,
    Range = 2,
    Match = 3,
    EEnvTestFilterType_MAX = 4,
};

enum class EEnvTestPathfinding {
    PathExist = 0,
    PathCost = 1,
    PathLength = 2,
    EEnvTestPathfinding_MAX = 3,
};

enum class EEnvTestPurpose {
    Filter = 0,
    Score = 1,
    FilterAndScore = 2,
    EEnvTestPurpose_MAX = 3,
};

enum class EEnvTestScoreEquation {
    Linear = 0,
    Square = 1,
    InverseLinear = 2,
    SquareRoot = 3,
    Constant = 4,
    EEnvTestScoreEquation_MAX = 5,
};

enum class EEnvTestScoreOperator {
    AverageScore = 0,
    MinScore = 1,
    MaxScore = 2,
    Multiply = 3,
    EEnvTestScoreOperator_MAX = 4,
};

enum class EEnvTestWeight {
    None = 0,
    Square = 1,
    Inverse = 2,
    Unused = 3,
    Constant = 4,
    Skip = 5,
    EEnvTestWeight_MAX = 6,
};

enum class EEnvTraceShape {
    Line = 0,
    Box = 1,
    Sphere = 2,
    Capsule = 3,
    EEnvTraceShape_MAX = 4,
};

enum class EGenericAICheck {
    Less = 0,
    LessOrEqual = 1,
    Equal = 2,
    NotEqual = 3,
    GreaterOrEqual = 4,
    Greater = 5,
    IsTrue = 6,
    MAX = 7,
};

enum class EPathExistanceQueryType {
    NavmeshRaycast2D = 0,
    HierarchicalQuery = 1,
    RegularPathFinding = 2,
    EPathExistanceQueryType_MAX = 3,
};

enum class EPathFollowingAction {
    Error = 0,
    NoMove = 1,
    DirectMove = 2,
    PartialPath = 3,
    PathToGoal = 4,
    EPathFollowingAction_MAX = 5,
};

enum class EPathFollowingRequestResult {
    Failed = 0,
    AlreadyAtGoal = 1,
    RequestSuccessful = 2,
    EPathFollowingRequestResult_MAX = 3,
};

enum class EPathFollowingResult {
    Success = 0,
    Blocked = 1,
    OffPath = 2,
    Aborted = 3,
    Skipped_DEPRECATED = 4,
    Invalid = 5,
    EPathFollowingResult_MAX = 6,
};

enum class EPathFollowingStatus {
    Idle = 0,
    Waiting = 1,
    Paused = 2,
    Moving = 3,
    EPathFollowingStatus_MAX = 4,
};

enum class EPawnActionMoveMode {
    UsePathfinding = 0,
    StraightLine = 1,
    EPawnActionMoveMode_MAX = 2,
};

enum class EPointOnCircleSpacingMethod {
    BySpaceBetween = 0,
    ByNumberOfPoints = 1,
    EPointOnCircleSpacingMethod_MAX = 2,
};

// Size: 0x48
struct FEQSParametrizedQueryExecutionRequest {
    /* 0x0000 */ UEnvQuery* QueryTemplate;
    /* 0x0008 */ TArray<FAIDynamicParam> QueryConfig;
    /* 0x0018 */ FBlackboardKeySelector EQSQueryBlackboardKey;
    /* 0x0040 */ uint8_t RunMode;
    /* 0x0044 */ bool bUseBBKeyForQueryTemplate;
};

// Size: 0x28
class IEQSQueryResultSourceInterface : public UInterface {
};

// Size: 0x5c0
class UEQSRenderingComponent : public UDebugDrawComponent {
};

// Size: 0x6f0
class AEQSTestingPawn : public ACharacter {
    /* 0x0650 */ UEnvQuery* QueryTemplate;
    /* 0x0658 */ TArray<FEnvNamedValue> QueryParams;
    /* 0x0668 */ TArray<FAIDynamicParam> QueryConfig;
    /* 0x0678 */ float TimeLimitPerStep;
    /* 0x067c */ int32_t StepToDebugDraw;
    /* 0x0680 */ EEnvQueryHightlightMode highlightMode;
    /* 0x0684 */ bool bDrawLabels;
    /* 0x0684 */ bool bDrawFailedItems;
    /* 0x0684 */ bool bReRunQueryOnlyOnFinishedMove;
    /* 0x0684 */ bool bShouldBeVisibleInGame;
    /* 0x0684 */ bool bTickDuringGame;
    /* 0x0684 */ bool bRunQueryOnSelectionChanged;
    /* 0x0688 */ uint8_t QueryingMode;
    /* 0x0690 */ FNavAgentProperties NavAgentProperties;
};

enum class ETeamAttitude {
    Friendly = 0,
    Neutral = 1,
    Hostile = 2,
    ETeamAttitude_MAX = 3,
};

enum class ETextKeyOperation {
    Equal = 0,
    NotEqual = 1,
    Contain = 2,
    NotContain = 3,
    ETextKeyOperation_MAX = 4,
};

// Size: 0x20
struct FEnvDirection {
    /* 0x0000 */ UClass* LineFrom;
    /* 0x0008 */ UClass* LineTo;
    /* 0x0010 */ UClass* Rotation;
    /* 0x0018 */ uint8_t DirMode;
};

// Size: 0x10
struct FEnvNamedValue {
    /* 0x0000 */ FName paramName;
    /* 0x0008 */ EAIParamType ParamType;
    /* 0x000c */ float Value;
};

// Size: 0x30
struct FEnvOverlapData {
    /* 0x0000 */ float ExtentX;
    /* 0x0004 */ float ExtentY;
    /* 0x0008 */ float ExtentZ;
    /* 0x0010 */ FVector ShapeOffset;
    /* 0x0028 */ uint8_t OverlapChannel;
    /* 0x0029 */ uint8_t OverlapShape;
    /* 0x002c */ bool bOnlyBlockingHits;
    /* 0x002c */ bool bOverlapComplex;
    /* 0x002c */ bool bSkipOverlapQuerier;
};

// Size: 0x48
class UEnvQuery : public UDataAsset {
    /* 0x0030 */ FName QueryName;
    /* 0x0038 */ TArray<UEnvQueryOption*> Options;
};

// Size: 0x28
class UEnvQueryContext : public UObject {
};

// Size: 0x30
class UEnvQueryContext_BlueprintBase : public UEnvQueryContext {

    void ProvideActorsSet(UObject* QuerierObject, AActor* QuerierActor, TArray<AActor*>& ResultingActorsSet) const;
    void ProvideLocationsSet(UObject* QuerierObject, AActor* QuerierActor, TArray<FVector>& ResultingLocationSet) const;
    void ProvideSingleActor(UObject* QuerierObject, AActor* QuerierActor, AActor*& ResultingActor) const;
    void ProvideSingleLocation(UObject* QuerierObject, AActor* QuerierActor, FVector& ResultingLocation) const;
};

// Size: 0x28
class UEnvQueryContext_Item : public UEnvQueryContext {
};

// Size: 0x60
class UEnvQueryContext_NavigationData : public UEnvQueryContext {
    /* 0x0028 */ FNavAgentProperties NavAgentProperties;
};

// Size: 0x28
class UEnvQueryContext_Querier : public UEnvQueryContext {
};

// Size: 0x28
class UEnvQueryDebugHelpers : public UObject {
};

// Size: 0x50
class UEnvQueryGenerator : public UEnvQueryNode {
    /* 0x0030 */ FString OptionName;
    /* 0x0040 */ UClass* ItemType;
    /* 0x0048 */ bool bAutoSortTests;
    /* 0x0048 */ bool bCanRunAsync;
};

// Size: 0xd0
class UEnvQueryGenerator_ActorsOfClass : public UEnvQueryGenerator {
    /* 0x0050 */ UClass* SearchedActorClass;
    /* 0x0058 */ FAIDataProviderBoolValue GenerateOnlyActorsInRadius;
    /* 0x0090 */ FAIDataProviderFloatValue SearchRadius;
    /* 0x00c8 */ UClass* SearchCenter;
};

// Size: 0x80
class UEnvQueryGenerator_BlueprintBase : public UEnvQueryGenerator {
    /* 0x0050 */ FText GeneratorsActionDescription;
    /* 0x0060 */ UClass* Context;
    /* 0x0068 */ UClass* GeneratedItemType;

    void AddGeneratedActor(AActor* GeneratedActor) const;
    void AddGeneratedVector(FVector GeneratedVector) const;
    void DoItemGeneration(const TArray<FVector>& ContextLocations) const;
    void DoItemGenerationFromActors(const TArray<AActor*>& ContextActors) const;
    UObject* GetQuerier() const;
};

// Size: 0x70
class UEnvQueryGenerator_Composite : public UEnvQueryGenerator {
    /* 0x0050 */ TArray<UEnvQueryGenerator*> Generators;
    /* 0x0060 */ bool bAllowDifferentItemTypes;
    /* 0x0060 */ bool bHasMatchingItemType;
    /* 0x0068 */ UClass* ForcedItemType;
};

// Size: 0x188
class UEnvQueryGenerator_Cone : public UEnvQueryGenerator_ProjectedPoints {
    /* 0x0098 */ FAIDataProviderFloatValue AlignedPointsDistance;
    /* 0x00d0 */ FAIDataProviderFloatValue ConeDegrees;
    /* 0x0108 */ FAIDataProviderFloatValue AngleStep;
    /* 0x0140 */ FAIDataProviderFloatValue Range;
    /* 0x0178 */ UClass* CenterActor;
    /* 0x0180 */ bool bIncludeContextLocation;
};

// Size: 0xa0
class UEnvQueryGenerator_CurrentLocation : public UEnvQueryGenerator_ProjectedPoints {
    /* 0x0098 */ UClass* QueryContext;
};

// Size: 0x1e8
class UEnvQueryGenerator_Donut : public UEnvQueryGenerator_ProjectedPoints {
    /* 0x0098 */ FAIDataProviderFloatValue InnerRadius;
    /* 0x00d0 */ FAIDataProviderFloatValue OuterRadius;
    /* 0x0108 */ FAIDataProviderIntValue NumberOfRings;
    /* 0x0140 */ FAIDataProviderIntValue PointsPerRing;
    /* 0x0178 */ FEnvDirection ArcDirection;
    /* 0x0198 */ FAIDataProviderFloatValue ArcAngle;
    /* 0x01d0 */ bool bUseSpiralPattern;
    /* 0x01d8 */ UClass* Center;
    /* 0x01e0 */ bool bDefineArc;
};

// Size: 0x268
class UEnvQueryGenerator_OnCircle : public UEnvQueryGenerator_ProjectedPoints {
    /* 0x0098 */ FAIDataProviderFloatValue CircleRadius;
    /* 0x00d0 */ EPointOnCircleSpacingMethod PointOnCircleSpacingMethod;
    /* 0x00d8 */ FAIDataProviderFloatValue SpaceBetween;
    /* 0x0110 */ FAIDataProviderIntValue NumberOfPoints;
    /* 0x0148 */ FEnvDirection ArcDirection;
    /* 0x0168 */ FAIDataProviderFloatValue ArcDirectionOffsetDegrees;
    /* 0x01a0 */ FAIDataProviderFloatValue ArcAngle;
    /* 0x01d8 */ UClass* CircleCenter;
    /* 0x01e0 */ bool bIgnoreAnyContextActorsWhenGeneratingCircle;
    /* 0x01e8 */ FAIDataProviderFloatValue CircleCenterZOffset;
    /* 0x0220 */ FEnvTraceData TraceData;
    /* 0x0260 */ bool bDefineArc;
};

// Size: 0x188
class UEnvQueryGenerator_PathingGrid : public UEnvQueryGenerator_SimpleGrid {
    /* 0x0110 */ FAIDataProviderBoolValue PathToItem;
    /* 0x0148 */ UClass* NavigationFilter;
    /* 0x0150 */ FAIDataProviderFloatValue ScanRangeMultiplier;
};

// Size: 0xa8
class UEnvQueryGenerator_PerceivedActors : public UEnvQueryGenerator {
    /* 0x0050 */ UClass* AllowedActorClass;
    /* 0x0058 */ FAIDataProviderFloatValue SearchRadius;
    /* 0x0090 */ UClass* ListenerContext;
    /* 0x0098 */ UClass* SenseToUse;
    /* 0x00a0 */ bool bIncludeKnownActors;
};

// Size: 0x98
class UEnvQueryGenerator_ProjectedPoints : public UEnvQueryGenerator {
    /* 0x0050 */ FEnvTraceData ProjectionData;
    /* 0x0090 */ UClass* NavDataOverrideContext;
};

// Size: 0x110
class UEnvQueryGenerator_SimpleGrid : public UEnvQueryGenerator_ProjectedPoints {
    /* 0x0098 */ FAIDataProviderFloatValue GridSize;
    /* 0x00d0 */ FAIDataProviderFloatValue SpaceBetween;
    /* 0x0108 */ UClass* GenerateAround;
};

// Size: 0x78
class UEnvQueryInstanceBlueprintWrapper : public UObject {
    /* 0x0030 */ int32_t QueryID;
    /* 0x0058 */ UClass* ItemType;
    /* 0x0060 */ int32_t OptionIndex;
    /* 0x0068 */ FMulticastInlineDelegate OnQueryFinishedEvent;

    void EQSQueryDoneSignature__DelegateSignature(UEnvQueryInstanceBlueprintWrapper* QueryInstance, uint8_t QueryStatus);
    float GetItemScore(int32_t ItemIndex) const;
    bool GetQueryResultsAsActors(TArray<AActor*>& ResultActors) const;
    bool GetQueryResultsAsLocations(TArray<FVector>& ResultLocations) const;
    TArray<AActor*> GetResultsAsActors() const;
    TArray<FVector> GetResultsAsLocations() const;
    void SetNamedParam(FName paramName, float Value);
};

// Size: 0x180
struct FEnvQueryInstanceCache {
    /* 0x0000 */ UEnvQuery* Template;
};

// Size: 0x30
class UEnvQueryItemType : public UObject {
};

// Size: 0x30
class UEnvQueryItemType_Actor : public UEnvQueryItemType_ActorBase {
};

// Size: 0x30
class UEnvQueryItemType_ActorBase : public UEnvQueryItemType_VectorBase {
};

// Size: 0x30
class UEnvQueryItemType_Direction : public UEnvQueryItemType_VectorBase {
};

// Size: 0x30
class UEnvQueryItemType_Point : public UEnvQueryItemType_VectorBase {
};

// Size: 0x30
class UEnvQueryItemType_VectorBase : public UEnvQueryItemType {
};

// Size: 0x158
class UEnvQueryManager : public UAISubsystem {
    /* 0x00a8 */ TArray<FEnvQueryInstanceCache> InstanceCache;
    /* 0x00b8 */ TArray<UEnvQueryContext*> LocalContexts;
    /* 0x00c8 */ TArray<UEnvQueryInstanceBlueprintWrapper*> GCShieldedWrappers;
    /* 0x012c */ float MaxAllowedTestingTime;
    /* 0x0130 */ bool bTestQueriesUsingBreadth;
    /* 0x0134 */ int32_t QueryCountWarningThreshold;
    /* 0x0138 */ double QueryCountWarningInterval;
    /* 0x0140 */ double ExecutionTimeWarningSeconds;
    /* 0x0148 */ double HandlingResultTimeWarningSeconds;
    /* 0x0150 */ double GenerationTimeWarningSeconds;

    static UEnvQueryInstanceBlueprintWrapper* RunEQSQuery(UObject* WorldContextObject, UEnvQuery* QueryTemplate, UObject* Querier, uint8_t RunMode, UClass* WrapperClass);
};

// Size: 0x30
struct FEnvQueryManagerConfig {
    /* 0x0000 */ float MaxAllowedTestingTime;
    /* 0x0004 */ bool bTestQueriesUsingBreadth;
    /* 0x0008 */ int32_t QueryCountWarningThreshold;
    /* 0x0010 */ double QueryCountWarningInterval;
    /* 0x0018 */ double ExecutionTimeWarningSeconds;
    /* 0x0020 */ double HandlingResultTimeWarningSeconds;
    /* 0x0028 */ double GenerationTimeWarningSeconds;
};

// Size: 0x30
class UEnvQueryNode : public UObject {
    /* 0x0028 */ int32_t VerNum;
};

// Size: 0x40
class UEnvQueryOption : public UObject {
    /* 0x0028 */ UEnvQueryGenerator* Generator;
    /* 0x0030 */ TArray<UEnvQueryTest*> Tests;
};

// Size: 0x68
struct FEnvQueryRequest {
    /* 0x0000 */ UEnvQuery* QueryTemplate;
    /* 0x0008 */ UObject* Owner;
    /* 0x0010 */ UWorld* World;
};

// Size: 0x40
struct FEnvQueryResult {
    /* 0x0010 */ UClass* ItemType;
    /* 0x002c */ int32_t OptionIndex;
    /* 0x0030 */ int32_t QueryID;
};

// Size: 0x1f8
class UEnvQueryTest : public UEnvQueryNode {
    /* 0x0030 */ int32_t TestOrder;
    /* 0x0034 */ uint8_t TestPurpose;
    /* 0x0038 */ FString TestComment;
    /* 0x0048 */ uint8_t MultipleContextFilterOp;
    /* 0x0049 */ uint8_t MultipleContextScoreOp;
    /* 0x004a */ uint8_t FilterType;
    /* 0x0050 */ FAIDataProviderBoolValue boolValue;
    /* 0x0088 */ FAIDataProviderFloatValue FloatValueMin;
    /* 0x00c0 */ FAIDataProviderFloatValue FloatValueMax;
    /* 0x00f9 */ uint8_t ScoringEquation;
    /* 0x00fa */ uint8_t ClampMinType;
    /* 0x00fb */ uint8_t ClampMaxType;
    /* 0x00fc */ EEQSNormalizationType NormalizationType;
    /* 0x0100 */ FAIDataProviderFloatValue ScoreClampMin;
    /* 0x0138 */ FAIDataProviderFloatValue ScoreClampMax;
    /* 0x0170 */ FAIDataProviderFloatValue ScoringFactor;
    /* 0x01a8 */ FAIDataProviderFloatValue ReferenceValue;
    /* 0x01e0 */ bool bDefineReferenceValue;
    /* 0x01f0 */ bool bWorkOnFloatValues;
};

// Size: 0x208
class UEnvQueryTest_Distance : public UEnvQueryTest {
    /* 0x01f8 */ uint8_t TestMode;
    /* 0x0200 */ UClass* DistanceTo;
};

// Size: 0x240
class UEnvQueryTest_Dot : public UEnvQueryTest {
    /* 0x01f8 */ FEnvDirection LineA;
    /* 0x0218 */ FEnvDirection LineB;
    /* 0x0238 */ EEnvTestDot TestMode;
    /* 0x0239 */ bool bAbsoluteValue;
};

// Size: 0x268
class UEnvQueryTest_GameplayTags : public UEnvQueryTest {
    /* 0x01f8 */ FGameplayTagQuery TagQueryToMatch;
    /* 0x0240 */ bool bRejectIncompatibleItems;
    /* 0x0241 */ bool bUpdatedToUseQuery;
    /* 0x0242 */ EGameplayContainerMatchType TagsToMatch;
    /* 0x0248 */ FGameplayTagContainer GameplayTags;
};

// Size: 0x228
class UEnvQueryTest_Overlap : public UEnvQueryTest {
    /* 0x01f8 */ FEnvOverlapData OverlapData;
};

// Size: 0x280
class UEnvQueryTest_Pathfinding : public UEnvQueryTest {
    /* 0x01f8 */ uint8_t TestMode;
    /* 0x0200 */ UClass* Context;
    /* 0x0208 */ FAIDataProviderBoolValue PathFromContext;
    /* 0x0240 */ FAIDataProviderBoolValue SkipUnreachable;
    /* 0x0278 */ UClass* FilterClass;
};

// Size: 0x2b8
class UEnvQueryTest_PathfindingBatch : public UEnvQueryTest_Pathfinding {
    /* 0x0280 */ FAIDataProviderFloatValue ScanRangeMultiplier;
};

// Size: 0x238
class UEnvQueryTest_Project : public UEnvQueryTest {
    /* 0x01f8 */ FEnvTraceData ProjectionData;
};

// Size: 0x1f8
class UEnvQueryTest_Random : public UEnvQueryTest {
};

// Size: 0x2e8
class UEnvQueryTest_Trace : public UEnvQueryTest {
    /* 0x01f8 */ FEnvTraceData TraceData;
    /* 0x0238 */ FAIDataProviderBoolValue TraceFromContext;
    /* 0x0270 */ FAIDataProviderFloatValue ItemHeightOffset;
    /* 0x02a8 */ FAIDataProviderFloatValue ContextHeightOffset;
    /* 0x02e0 */ UClass* Context;
};

// Size: 0x210
class UEnvQueryTest_Volume : public UEnvQueryTest {
    /* 0x01f8 */ UClass* VolumeContext;
    /* 0x0200 */ UClass* VolumeClass;
    /* 0x0208 */ bool bDoComplexVolumeTest;
    /* 0x0208 */ bool bSkipTestIfNoVolumes;
};

// Size: 0x28
class UEnvQueryTypes : public UObject {
};

// Size: 0x40
struct FEnvTraceData {
    /* 0x0000 */ int32_t VersionNum;
    /* 0x0008 */ UClass* NavigationFilter;
    /* 0x0010 */ float ProjectDown;
    /* 0x0014 */ float ProjectUp;
    /* 0x0018 */ float ExtentX;
    /* 0x001c */ float ExtentY;
    /* 0x0020 */ float ExtentZ;
    /* 0x0024 */ float PostProjectionVerticalOffset;
    /* 0x0028 */ uint8_t TraceChannel;
    /* 0x0029 */ uint8_t SerializedChannel;
    /* 0x002c */ FName TraceProfileName;
    /* 0x0034 */ uint8_t TraceShape;
    /* 0x0035 */ uint8_t TraceMode;
    /* 0x0038 */ bool bTraceComplex;
    /* 0x0038 */ bool bOnlyBlockingHits;
    /* 0x0038 */ bool bCanTraceOnNavMesh;
    /* 0x0038 */ bool bCanTraceOnGeometry;
    /* 0x0038 */ bool bCanDisableTrace;
    /* 0x0038 */ bool bCanProjectDown;
};

enum class FAIDistanceType {
    Distance3D = 0,
    Distance2D = 1,
    DistanceZ = 2,
    MAX = 3,
};

// Size: 0x50
class UGeneratedNavLinksProxy : public UBaseGeneratedNavLinksProxy {
    /* 0x0040 */ FMulticastInlineDelegate OnSmartLinkReached;

    void ReceiveSmartLinkReached(AActor* Agent, const FVector destination);
};

// Size: 0x28
class IGenericTeamAgentInterface : public UInterface {
};

// Size: 0x1
struct FGenericTeamId {
    /* 0x0000 */ uint8_t TeamID;
};

// Size: 0x3c8
class AGridPathAIController : public AAIController {
};

// Size: 0x338
class UGridPathFollowingComponent : public UPathFollowingComponent {
    /* 0x0308 */ UNavLocalGridManager* GridManager;
};

// Size: 0x8
struct FIndexedHandleBase : public FSimpleIndexedHandleBase {
};

// Size: 0x8
struct FIntervalCountdown {
    /* 0x0000 */ float interval;
};

// Size: 0x48
class UNavFilter_AIControllerDefault : public UNavigationQueryFilter {
};

// Size: 0x2f8
class ANavLinkProxy : public AActor {
    /* 0x02b8 */ TArray<FNavigationLink> PointLinks;
    /* 0x02c8 */ TArray<FNavigationSegmentLink> SegmentLinks;
    /* 0x02d8 */ UNavLinkCustomComponent* SmartLinkComp;
    /* 0x02e0 */ bool bSmartLinkIsRelevant;
    /* 0x02e8 */ FMulticastInlineDelegate OnSmartLinkReached;

    bool HasMovingAgents() const;
    bool IsSmartLinkEnabled() const;
    void ReceiveSmartLinkReached(AActor* Agent, const FVector& destination);
    void ResumePathFollowing(AActor* Agent);
    void SetSmartLinkEnabled(bool bEnabled);
};

// Size: 0x58
class UNavLocalGridManager : public UObject {

    static int32_t AddLocalNavigationGridForBox(UObject* WorldContextObject, const FVector& Location, FVector Extent, FRotator Rotation, const int32_t Radius2D, const float Height, bool bRebuildGrids);
    static int32_t AddLocalNavigationGridForCapsule(UObject* WorldContextObject, const FVector& Location, float CapsuleRadius, float CapsuleHalfHeight, const int32_t Radius2D, const float Height, bool bRebuildGrids);
    static int32_t AddLocalNavigationGridForPoint(UObject* WorldContextObject, const FVector& Location, const int32_t Radius2D, const float Height, bool bRebuildGrids);
    static int32_t AddLocalNavigationGridForPoints(UObject* WorldContextObject, const TArray<FVector>& Locations, const int32_t Radius2D, const float Height, bool bRebuildGrids);
    static bool FindLocalNavigationGridPath(UObject* WorldContextObject, const FVector& Start, const FVector& End, TArray<FVector>& PathPoints);
    static void RemoveLocalNavigationGrid(UObject* WorldContextObject, int32_t GridId, bool bRebuildGrids);
    static bool SetLocalNavigationGridDensity(UObject* WorldContextObject, float CellSize);
};

// Size: 0x308
class UPathFollowingComponent : public UActorComponent {
    /* 0x00f0 */ UNavMovementComponent* MovementComp;
    /* 0x0118 */ ANavigationData* MyNavData;

    uint8_t GetPathActionType() const;
    FVector GetPathDestination() const;
    void OnActorBump(AActor* SelfActor, AActor* OtherActor, FVector NormalImpulse, const FHitResult& Hit);
    void OnNavDataRegistered(ANavigationData* NavData);
};

// Size: 0x28
class UPathFollowingManager : public UObject {
};

// Size: 0x100
class UPawnSensingComponent : public UActorComponent {
    /* 0x00b8 */ float HearingThreshold;
    /* 0x00bc */ float LOSHearingThreshold;
    /* 0x00c0 */ float SightRadius;
    /* 0x00c4 */ float SensingInterval;
    /* 0x00c8 */ float HearingMaxSoundAge;
    /* 0x00cc */ bool bEnableSensingUpdates;
    /* 0x00cc */ bool bOnlySensePlayers;
    /* 0x00cc */ bool bSeePawns;
    /* 0x00cc */ bool bHearNoises;
    /* 0x00d8 */ FMulticastInlineDelegate OnSeePawn;
    /* 0x00e8 */ FMulticastInlineDelegate OnHearNoise;
    /* 0x00f8 */ float PeripheralVisionAngle;
    /* 0x00fc */ float PeripheralVisionCosine;

    float GetPeripheralVisionAngle() const;
    float GetPeripheralVisionCosine() const;
    void HearNoiseDelegate__DelegateSignature(APawn* Instigator, const FVector& Location, float Volume);
    void SeePawnDelegate__DelegateSignature(APawn* Pawn);
    void SetPeripheralVisionAngle(const float NewPeripheralVisionAngle);
    void SetSensingInterval(const float NewSensingInterval);
    void SetSensingUpdatesEnabled(const bool bEnabled);
};

// Size: 0xb8
struct FRecastGraphWrapper {
    /* 0x0000 */ ARecastNavMesh* RecastNavMeshActor;
};

// Size: 0x4
struct FSequentialIDBase {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x4
struct FSimpleIndexedHandleBase {
};

// Size: 0x28
class UValueOrBBKeyBlueprintUtility : public UBlueprintFunctionLibrary {

    static bool GetBool(const FValueOrBBKey_Bool& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static UClass* GetClass(const FValueOrBBKey_Class& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static uint8_t GetEnum(const FValueOrBBKey_Enum& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static float GetFloat(const FValueOrBBKey_Float& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static int32_t GetInt32(const FValueOrBBKey_Int32& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static FName GetName(const FValueOrBBKey_Name& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static UObject* GetObject(const FValueOrBBKey_Object& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static FRotator GetRotator(const FValueOrBBKey_Rotator& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static FString GetString(const FValueOrBBKey_String& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static FInstancedStruct GetStruct(const FValueOrBBKey_Struct& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
    static FVector GetVector(const FValueOrBBKey_Vector& Value, const UBehaviorTreeComponent* BehaviorTreeComp);
};

// Size: 0x10
struct FValueOrBBKey_Bool : public FValueOrBlackboardKeyBase {
    /* 0x000c */ bool DefaultValue;
};

// Size: 0x20
struct FValueOrBBKey_Class : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ UClass* DefaultValue;
    /* 0x0018 */ UClass* BaseClass;
};

// Size: 0x28
struct FValueOrBBKey_Enum : public FValueOrBlackboardKeyBase {
    /* 0x000c */ uint8_t DefaultValue;
    /* 0x0010 */ UEnum* EnumType;
    /* 0x0018 */ FString NativeEnumTypeName;
};

// Size: 0x10
struct FValueOrBBKey_Float : public FValueOrBlackboardKeyBase {
    /* 0x000c */ float DefaultValue;
};

// Size: 0x10
struct FValueOrBBKey_Int32 : public FValueOrBlackboardKeyBase {
    /* 0x000c */ int32_t DefaultValue;
};

// Size: 0x14
struct FValueOrBBKey_Name : public FValueOrBlackboardKeyBase {
    /* 0x000c */ FName DefaultValue;
};

// Size: 0x20
struct FValueOrBBKey_Object : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ UObject* DefaultValue;
    /* 0x0018 */ UClass* BaseClass;
};

// Size: 0x28
struct FValueOrBBKey_Rotator : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ FRotator DefaultValue;
};

// Size: 0x20
struct FValueOrBBKey_String : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ FString DefaultValue;
};

// Size: 0x20
struct FValueOrBBKey_Struct : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ FInstancedStruct DefaultValue;
};

// Size: 0x28
struct FValueOrBBKey_Vector : public FValueOrBlackboardKeyBase {
    /* 0x0010 */ FVector DefaultValue;
};

// Size: 0xc
struct FValueOrBlackboardKeyBase {
    /* 0x0000 */ FName Key;
};

// Size: 0x28
class UVisualLoggerExtension : public UObject {
};

// Size: 0x8
struct FActorLayer {
    /* 0x0000 */ FName Name;
};

// Size: 0x28
class ULayersBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void AddActorToLayer(AActor* InActor, const FActorLayer& Layer);
    static TArray<AActor*> GetActors(UObject* WorldContextObject, const FActorLayer& ActorLayer);
    static void RemoveActorFromLayer(AActor* InActor, const FActorLayer& Layer);
};

// Size: 0x2e0
struct FColorGradingSpinBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BorderBrush;
    /* 0x00c0 */ FSlateBrush ActiveBorderBrush;
    /* 0x0170 */ FSlateBrush HoveredBorderBrush;
    /* 0x0220 */ FSlateBrush SelectorBrush;
    /* 0x02d0 */ float SelectorWidth;
};

// Size: 0x730
class URadialSlider : public UWidget {
    /* 0x0168 */ float Value;
    /* 0x016c */ FDelegate ValueDelegate;
    /* 0x017c */ bool bUseCustomDefaultValue;
    /* 0x0180 */ float CustomDefaultValue;
    /* 0x0188 */ FRuntimeFloatCurve SliderRange;
    /* 0x0210 */ TArray<float> ValueTags;
    /* 0x0220 */ float SliderHandleStartAngle;
    /* 0x0224 */ float SliderHandleEndAngle;
    /* 0x0228 */ float AngularOffset;
    /* 0x0230 */ FVector2D HandStartEndRatio;
    /* 0x0240 */ FSliderStyle WidgetStyle;
    /* 0x0680 */ FLinearColor SliderBarColor;
    /* 0x0690 */ FLinearColor SliderProgressColor;
    /* 0x06a0 */ FLinearColor SliderHandleColor;
    /* 0x06b0 */ FLinearColor CenterBackgroundColor;
    /* 0x06c0 */ bool Locked;
    /* 0x06c1 */ bool MouseUsesStep;
    /* 0x06c2 */ bool RequiresControllerLock;
    /* 0x06c4 */ float StepSize;
    /* 0x06c8 */ bool IsFocusable;
    /* 0x06c9 */ bool UseVerticalDrag;
    /* 0x06ca */ bool ShowSliderHandle;
    /* 0x06cb */ bool ShowSliderHand;
    /* 0x06d0 */ FMulticastInlineDelegate OnMouseCaptureBegin;
    /* 0x06e0 */ FMulticastInlineDelegate OnMouseCaptureEnd;
    /* 0x06f0 */ FMulticastInlineDelegate OnControllerCaptureBegin;
    /* 0x0700 */ FMulticastInlineDelegate OnControllerCaptureEnd;
    /* 0x0710 */ FMulticastInlineDelegate OnValueChanged;

    float GetCustomDefaultValue() const;
    float GetNormalizedSliderHandlePosition() const;
    float GetValue() const;
    void SetAngularOffset(float InValue);
    void SetCenterBackgroundColor(FLinearColor InValue);
    void SetCustomDefaultValue(float InValue);
    void SetHandStartEndRatio(FVector2D InValue);
    void SetLocked(bool InValue);
    void SetShowSliderHand(bool InShowSliderHand);
    void SetShowSliderHandle(bool InShowSliderHandle);
    void SetSliderBarColor(FLinearColor InValue);
    void SetSliderHandleColor(FLinearColor InValue);
    void SetSliderHandleEndAngle(float InValue);
    void SetSliderHandleStartAngle(float InValue);
    void SetSliderProgressColor(FLinearColor InValue);
    void SetSliderRange(const FRuntimeFloatCurve& InSliderRange);
    void SetStepSize(float InValue);
    void SetUseVerticalDrag(bool InUseVerticalDrag);
    void SetValue(float InValue);
    void SetValueTags(const TArray<float>& InValueTags);
};

// Size: 0x40
struct FAngularRangeLimit {
    /* 0x0000 */ FVector LimitMin;
    /* 0x0018 */ FVector LimitMax;
    /* 0x0030 */ FBoneReference bone;
};

// Size: 0x28
class UAnimExecutionContextLibrary : public UBlueprintFunctionLibrary {

    static FAnimComponentSpacePoseContext ConvertToComponentSpacePoseContext(const FAnimExecutionContext& Context, EAnimExecutionContextConversionResult& Result);
    static FAnimInitializationContext ConvertToInitializationContext(const FAnimExecutionContext& Context, EAnimExecutionContextConversionResult& Result);
    static FAnimPoseContext ConvertToPoseContext(const FAnimExecutionContext& Context, EAnimExecutionContextConversionResult& Result);
    static FAnimUpdateContext ConvertToUpdateContext(const FAnimExecutionContext& Context, EAnimExecutionContextConversionResult& Result);
    static UAnimInstance* GetAnimInstance(const FAnimExecutionContext& Context);
    static FAnimNodeReference GetAnimNodeReference(UAnimInstance* Instance, int32_t Index);
    static float GetCurrentWeight(const FAnimUpdateContext& Context);
    static float GetDeltaTime(const FAnimUpdateContext& Context);
    static bool IsActive(const FAnimExecutionContext& Context);
};

// Size: 0xf0
struct FAnimLegIKData {
};

// Size: 0x34
struct FAnimLegIKDefinition {
    /* 0x0000 */ FBoneReference IKFootBone;
    /* 0x0010 */ FBoneReference FKFootBone;
    /* 0x0020 */ int32_t NumBonesInLimb;
    /* 0x0024 */ float MinRotationAngle;
    /* 0x0028 */ uint8_t FootBoneForwardAxis;
    /* 0x0029 */ uint8_t HingeRotationAxis;
    /* 0x002a */ bool bEnableRotationLimit;
    /* 0x002b */ bool bEnableKneeTwistCorrection;
    /* 0x002c */ FName TwistOffsetCurveName;
};

// Size: 0x28
class UAnimNodeRigidBodyLibrary : public UBlueprintFunctionLibrary {

    static FRigidBodyAnimNodeReference ConvertToRigidBodyAnimNode(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToRigidBodyAnimNodePure(const FAnimNodeReference& Node, FRigidBodyAnimNodeReference& RigidBodyAnimNode, bool& Result);
    static FRigidBodyAnimNodeReference SetOverridePhysicsAsset(const FRigidBodyAnimNodeReference& Node, UPhysicsAsset* PhysicsAsset);
};

// Size: 0x1d0
struct FAnimNode_AimOffsetLookAt : public FAnimNode_BlendSpacePlayer {
    /* 0x0130 */ FPoseLink BasePose;
    /* 0x0140 */ int32_t LODThreshold;
    /* 0x0144 */ FName SourceSocketName;
    /* 0x014c */ FName PivotSocketName;
    /* 0x0158 */ FVector LookAtLocation;
    /* 0x0170 */ FVector SocketAxis;
    /* 0x0188 */ float Alpha;
};

// Size: 0x520
struct FAnimNode_AnimDynamics : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ float LinearDampingOverride;
    /* 0x00cc */ float AngularDampingOverride;
    /* 0x0190 */ FBoneReference RelativeSpaceBone;
    /* 0x01a0 */ FBoneReference BoundBone;
    /* 0x01b0 */ FBoneReference ChainEnd;
    /* 0x01c0 */ TArray<FAnimPhysBodyDefinition> PhysicsBodyDefinitions;
    /* 0x01d0 */ float GravityScale;
    /* 0x01d8 */ FVector GravityOverride;
    /* 0x01f0 */ float LinearSpringConstant;
    /* 0x01f4 */ float AngularSpringConstant;
    /* 0x01f8 */ float WindScale;
    /* 0x0200 */ FVector ComponentLinearAccScale;
    /* 0x0218 */ FVector ComponentLinearVelScale;
    /* 0x0230 */ FVector ComponentAppliedLinearAccClamp;
    /* 0x0248 */ float AngularBiasOverride;
    /* 0x024c */ int32_t NumSolverIterationsPreUpdate;
    /* 0x0250 */ int32_t NumSolverIterationsPostUpdate;
    /* 0x0258 */ TArray<FAnimPhysSphericalLimit> SphericalLimits;
    /* 0x0268 */ FVector ExternalForce;
    /* 0x0280 */ TArray<FAnimPhysPlanarLimit> PlanarLimits;
    /* 0x0290 */ AnimPhysSimSpaceType SimulationSpace;
    /* 0x0293 */ bool bUseSphericalLimits;
    /* 0x0293 */ bool bUsePlanarLimit;
    /* 0x0293 */ bool bDoUpdate;
    /* 0x0293 */ bool bDoEval;
    /* 0x0293 */ bool bOverrideLinearDamping;
    /* 0x0293 */ bool bOverrideAngularBias;
    /* 0x0293 */ bool bOverrideAngularDamping;
    /* 0x0293 */ bool bEnableWind;
    /* 0x0294 */ bool bUseGravityOverride;
    /* 0x0294 */ bool bGravityOverrideInSimSpace;
    /* 0x0294 */ bool bLinearSpring;
    /* 0x0294 */ bool bAngularSpring;
    /* 0x0294 */ bool bChain;
    /* 0x02a0 */ FRotationRetargetingInfo RetargetingSettings;
};

// Size: 0xc8
struct FAnimNode_ApplyAdditive : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink base;
    /* 0x0020 */ FPoseLink Additive;
    /* 0x0030 */ float Alpha;
    /* 0x0034 */ FInputScaleBias AlphaScaleBias;
    /* 0x003c */ int32_t LODThreshold;
    /* 0x0040 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x0088 */ FName AlphaCurveName;
    /* 0x0090 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x00c4 */ EAnimAlphaInputType AlphaInputType;
    /* 0x00c5 */ bool bAlphaBoolEnabled;
};

// Size: 0xe8
struct FAnimNode_ApplyLimits : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ TArray<FAngularRangeLimit> AngularRangeLimits;
    /* 0x00d8 */ TArray<FVector> AngularOffsets;
};

// Size: 0x68
struct FAnimNode_BlendBoneByChannel : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink A;
    /* 0x0020 */ FPoseLink B;
    /* 0x0030 */ TArray<FBlendBoneByChannelEntry> BoneDefinitions;
    /* 0x0050 */ float Alpha;
    /* 0x0058 */ FInputScaleBias AlphaScaleBias;
    /* 0x0060 */ uint8_t TransformsSpace;
};

// Size: 0x50
struct FAnimNode_BlendListBase : public FAnimNode_Base {
    /* 0x0010 */ TArray<FPoseLink> BlendPose;
};

// Size: 0x50
struct FAnimNode_BlendListByBool : public FAnimNode_BlendListBase {
};

// Size: 0x50
struct FAnimNode_BlendListByEnum : public FAnimNode_BlendListBase {
};

// Size: 0x50
struct FAnimNode_BlendListByInt : public FAnimNode_BlendListBase {
};

// Size: 0x78
struct FAnimNode_BlendSpaceEvaluator : public FAnimNode_BlendSpacePlayer {
    /* 0x0070 */ float NormalizedTime;
    /* 0x0074 */ bool bTeleportToNormalizedTime;
};

// Size: 0x68
struct FAnimNode_BlendSpaceGraph : public FAnimNode_BlendSpaceGraphBase {
};

// Size: 0x68
struct FAnimNode_BlendSpaceGraphBase : public FAnimNode_Base {
    /* 0x0010 */ float X;
    /* 0x0014 */ float Y;
    /* 0x0018 */ FName GroupName;
    /* 0x0020 */ uint8_t GroupRole;
    /* 0x0028 */ UBlendSpace* BlendSpace;
    /* 0x0030 */ TArray<FPoseLink> SamplePoseLinks;
};

// Size: 0x70
struct FAnimNode_BlendSpacePlayer : public FAnimNode_BlendSpacePlayerBase {
    /* 0x0068 */ UBlendSpace* BlendSpace;
};

// Size: 0x68
struct FAnimNode_BlendSpacePlayerBase : public FAnimNode_AssetPlayerBase {
    /* 0x0060 */ UBlendSpace* PreviousBlendSpace;
};

// Size: 0x90
struct FAnimNode_BlendSpacePlayer_Standalone : public FAnimNode_BlendSpacePlayerBase {
    /* 0x0068 */ FName GroupName;
    /* 0x0070 */ uint8_t GroupRole;
    /* 0x0071 */ bool bOverridePositionWhenJoiningSyncGroupAsLeader;
    /* 0x0072 */ EAnimSyncMethod Method;
    /* 0x0073 */ bool bIgnoreForRelevancyTest;
    /* 0x0074 */ float X;
    /* 0x0078 */ float Y;
    /* 0x007c */ float PlayRate;
    /* 0x0080 */ bool bLoop;
    /* 0x0081 */ bool bResetPlayTimeWhenBlendSpaceChanges;
    /* 0x0084 */ float StartPosition;
    /* 0x0088 */ UBlendSpace* BlendSpace;
};

// Size: 0x20
struct FAnimNode_BlendSpaceSampleResult : public FAnimNode_Root {
};

// Size: 0x128
struct FAnimNode_BoneDrivenController : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference SourceBone;
    /* 0x00d8 */ UCurveFloat* DrivingCurve;
    /* 0x00e0 */ float Multiplier;
    /* 0x00e8 */ double RangeMin;
    /* 0x00f0 */ double RangeMax;
    /* 0x00f8 */ double RemappedMin;
    /* 0x0100 */ double RemappedMax;
    /* 0x0108 */ FName ParameterName;
    /* 0x0110 */ FBoneReference TargetBone;
    /* 0x0120 */ EDrivenDestinationMode DestinationMode;
    /* 0x0121 */ EDrivenBoneModificationMode ModificationMode;
    /* 0x0122 */ uint8_t SourceComponent;
    /* 0x0123 */ bool bUseRange;
    /* 0x0123 */ bool bAffectTargetTranslationX;
    /* 0x0123 */ bool bAffectTargetTranslationY;
    /* 0x0123 */ bool bAffectTargetTranslationZ;
    /* 0x0123 */ bool bAffectTargetRotationX;
    /* 0x0123 */ bool bAffectTargetRotationY;
    /* 0x0123 */ bool bAffectTargetRotationZ;
    /* 0x0123 */ bool bAffectTargetScaleX;
    /* 0x0124 */ bool bAffectTargetScaleY;
    /* 0x0124 */ bool bAffectTargetScaleZ;
};

// Size: 0x1c0
struct FAnimNode_CCDIK : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FVector EffectorLocation;
    /* 0x00e0 */ uint8_t EffectorLocationSpace;
    /* 0x00f0 */ FBoneSocketTarget EffectorTarget;
    /* 0x0180 */ FBoneReference TipBone;
    /* 0x0190 */ FBoneReference RootBone;
    /* 0x01a0 */ float Precision;
    /* 0x01a4 */ int32_t MaxIterations;
    /* 0x01a8 */ bool bStartFromTail;
    /* 0x01a9 */ bool bEnableRotationLimit;
    /* 0x01b0 */ TArray<float> RotationLimitPerJoints;
};

// Size: 0x38
struct FAnimNode_CallFunction : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Source;
    /* 0x0034 */ EAnimFunctionCallSite CallSite;
};

// Size: 0x108
struct FAnimNode_Constraint : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference BoneToModify;
    /* 0x00d8 */ TArray<FConstraint> ConstraintSetup;
    /* 0x00e8 */ TArray<float> ConstraintWeights;
};

// Size: 0xf0
struct FAnimNode_CopyBone : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference SourceBone;
    /* 0x00d8 */ FBoneReference TargetBone;
    /* 0x00e8 */ bool bCopyTranslation;
    /* 0x00e9 */ bool bCopyRotation;
    /* 0x00ea */ bool bCopyScale;
    /* 0x00eb */ uint8_t ControlSpace;
};

// Size: 0xf8
struct FAnimNode_CopyBoneDelta : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference SourceBone;
    /* 0x00d8 */ FBoneReference TargetBone;
    /* 0x00e8 */ bool bCopyTranslation;
    /* 0x00e9 */ bool bCopyRotation;
    /* 0x00ea */ bool bCopyScale;
    /* 0x00eb */ CopyBoneDeltaMode CopyMode;
    /* 0x00ec */ float TranslationMultiplier;
    /* 0x00f0 */ float RotationMultiplier;
    /* 0x00f4 */ float ScaleMultiplier;
};

// Size: 0x158
struct FAnimNode_CopyPoseFromMesh : public FAnimNode_Base {
    /* 0x0010 */ TWeakObjectPtr<USkeletalMeshComponent> SourceMeshComponent;
    /* 0x0018 */ bool bUseAttachedParent;
    /* 0x0018 */ bool bCopyCurves;
    /* 0x0019 */ bool bCopyCustomAttributes;
    /* 0x001a */ bool bUseMeshPose;
    /* 0x001c */ FName RootBoneToCopy;
};

// Size: 0x40
struct FAnimNode_CurveSource : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink SourcePose;
    /* 0x0020 */ FName SourceBinding;
    /* 0x0028 */ float Alpha;
    /* 0x0030 */ TScriptInterface<ICurveSourceInterface> CurveSource;
};

// Size: 0x1f0
struct FAnimNode_Fabrik : public FAnimNode_SkeletalControlBase {
    /* 0x00d0 */ FTransform EffectorTransform;
    /* 0x0130 */ FBoneSocketTarget EffectorTarget;
    /* 0x01c0 */ FBoneReference TipBone;
    /* 0x01d0 */ FBoneReference RootBone;
    /* 0x01e0 */ float Precision;
    /* 0x01e4 */ int32_t MaxIterations;
    /* 0x01e8 */ uint8_t EffectorTransformSpace;
    /* 0x01e9 */ uint8_t EffectorRotationSource;
};

// Size: 0x138
struct FAnimNode_HandIKRetargeting : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference RightHandFK;
    /* 0x00d8 */ FBoneReference LeftHandFK;
    /* 0x00e8 */ FBoneReference RightHandIK;
    /* 0x00f8 */ FBoneReference LeftHandIK;
    /* 0x0108 */ TArray<FBoneReference> IKBonesToMove;
    /* 0x0118 */ FVector PerAxisAlpha;
    /* 0x0130 */ float HandFKWeight;
};

// Size: 0xe8
struct FAnimNode_LayeredBoneBlend : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink BasePose;
    /* 0x0020 */ TArray<FPoseLink> BlendPoses;
    /* 0x0030 */ ELayeredBoneBlendMode BlendMode;
    /* 0x0038 */ TArray<UBlendProfile*> BlendMasks;
    /* 0x0048 */ TArray<FInputBlendPose> LayerSetup;
    /* 0x0058 */ TArray<float> BlendWeights;
    /* 0x0088 */ TArray<FPerBoneBlendWeight> PerBoneBlendWeights;
    /* 0x00b8 */ FGuid SkeletonGuid;
    /* 0x00c8 */ FGuid VirtualBoneGuid;
    /* 0x00dc */ int32_t LODThreshold;
    /* 0x00e0 */ bool bMeshSpaceRotationBlend;
    /* 0x00e1 */ bool bRootSpaceRotationBlend;
    /* 0x00e2 */ bool bMeshSpaceScaleBlend;
    /* 0x00e3 */ uint8_t CurveBlendOption;
    /* 0x00e4 */ bool bBlendRootMotionBasedOnRootBone;
};

// Size: 0x100
struct FAnimNode_LegIK : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ float ReachPrecision;
    /* 0x00cc */ int32_t MaxIterations;
    /* 0x00d0 */ float SoftPercentLength;
    /* 0x00d4 */ float SoftAlpha;
    /* 0x00d8 */ TArray<FAnimLegIKDefinition> LegsDefinition;
};

// Size: 0x250
struct FAnimNode_LookAt : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference BoneToModify;
    /* 0x00e0 */ FBoneSocketTarget LookAtTarget;
    /* 0x0170 */ FVector LookAtLocation;
    /* 0x0188 */ FAxis LookAt_Axis;
    /* 0x01a8 */ bool bUseLookUpAxis;
    /* 0x01a9 */ uint8_t InterpolationType;
    /* 0x01b0 */ FAxis LookUp_Axis;
    /* 0x01d0 */ float LookAtClamp;
    /* 0x01d4 */ float InterpolationTime;
    /* 0x01d8 */ float InterpolationTriggerThreashold;
};

// Size: 0x38
struct FAnimNode_MakeDynamicAdditive : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink base;
    /* 0x0020 */ FPoseLink Additive;
    /* 0x0030 */ bool bMeshSpaceAdditive;
};

// Size: 0x10
struct FAnimNode_MeshSpaceRefPose : public FAnimNode_Base {
};

// Size: 0x48
struct FAnimNode_Mirror : public FAnimNode_MirrorBase {
};

// Size: 0x48
struct FAnimNode_MirrorBase : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Source;
};

// Size: 0x60
struct FAnimNode_Mirror_Standalone : public FAnimNode_MirrorBase {
    /* 0x0048 */ bool bMirror;
    /* 0x0050 */ UMirrorDataTable* MirrorDataTable;
    /* 0x0058 */ float BlendTime;
    /* 0x005c */ bool bResetChild;
    /* 0x005d */ bool bBoneMirroring;
    /* 0x005e */ bool bCurveMirroring;
    /* 0x005f */ bool bAttributeMirroring;
};

// Size: 0x128
struct FAnimNode_ModifyBone : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference BoneToModify;
    /* 0x00d8 */ FVector Translation;
    /* 0x00f0 */ FRotator Rotation;
    /* 0x0108 */ FVector Scale;
    /* 0x0120 */ uint8_t TranslationMode;
    /* 0x0121 */ uint8_t RotationMode;
    /* 0x0122 */ uint8_t ScaleMode;
    /* 0x0123 */ uint8_t TranslationSpace;
    /* 0x0124 */ uint8_t RotationSpace;
    /* 0x0125 */ uint8_t ScaleSpace;
};

// Size: 0x120
struct FAnimNode_ModifyCurve : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink SourcePose;
    /* 0x0020 */ TMap<FName, float> CurveMap;
    /* 0x0070 */ TArray<float> CurveValues;
    /* 0x0080 */ TArray<FName> CurveNames;
    /* 0x0118 */ float Alpha;
    /* 0x011c */ EModifyCurveApplyMode ApplyMode;
};

// Size: 0x50
struct FAnimNode_MultiWayBlend : public FAnimNode_Base {
    /* 0x0010 */ TArray<FPoseLink> Poses;
    /* 0x0020 */ TArray<float> DesiredAlphas;
    /* 0x0040 */ FInputScaleBias AlphaScaleBias;
    /* 0x0048 */ bool bAdditiveNode;
    /* 0x0049 */ bool bNormalizeAlpha;
};

// Size: 0x128
struct FAnimNode_ObserveBone : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference BoneToObserve;
    /* 0x00d8 */ uint8_t DisplaySpace;
    /* 0x00d9 */ bool bRelativeToRefPose;
    /* 0x00e0 */ FVector Translation;
    /* 0x00f8 */ FRotator Rotation;
    /* 0x0110 */ FVector Scale;
};

// Size: 0xd8
struct FAnimNode_PoseBlendNode : public FAnimNode_PoseHandler {
    /* 0x00a0 */ FPoseLink SourcePose;
    /* 0x00b0 */ EAlphaBlendOption BlendOption;
    /* 0x00b8 */ UCurveFloat* CustomCurve;
};

// Size: 0xb8
struct FAnimNode_PoseByName : public FAnimNode_PoseHandler {
    /* 0x00a0 */ FName PoseName;
    /* 0x00a8 */ float PoseWeight;
};

// Size: 0x1a8
struct FAnimNode_PoseDriver : public FAnimNode_PoseHandler {
    /* 0x00a0 */ FPoseLink SourcePose;
    /* 0x00b0 */ TArray<FBoneReference> SourceBones;
    /* 0x00c0 */ FBoneReference EvalSpaceBone;
    /* 0x00d0 */ bool bEvalFromRefPose;
    /* 0x00d8 */ TArray<FBoneReference> OnlyDriveBones;
    /* 0x00e8 */ TArray<FPoseDriverTarget> PoseTargets;
    /* 0x00f8 */ FRBFParams RBFParams;
    /* 0x0130 */ EPoseDriverSource DriveSource;
    /* 0x0131 */ EPoseDriverOutput DriveOutput;
    /* 0x0174 */ int32_t LODThreshold;
};

// Size: 0xa0
struct FAnimNode_PoseHandler : public FAnimNode_AssetPlayerBase {
    /* 0x0038 */ UPoseAsset* PoseAsset;
};

// Size: 0x90
struct FAnimNode_PoseSnapshot : public FAnimNode_Base {
    /* 0x0010 */ FName SnapshotName;
    /* 0x0018 */ FPoseSnapshot Snapshot;
    /* 0x0050 */ ESnapshotSourceMode Mode;
};

// Size: 0x78
struct FAnimNode_RandomPlayer : public FAnimNode_AssetPlayerRelevancyBase {
    /* 0x0010 */ TArray<FRandomPlayerSequenceEntry> Entries;
    /* 0x0070 */ float BlendWeight;
    /* 0x0074 */ bool bShuffleMode;
};

// Size: 0x10
struct FAnimNode_RefPose : public FAnimNode_Base {
};

// Size: 0xd8
struct FAnimNode_ResetRoot : public FAnimNode_SkeletalControlBase {
};

// Size: 0x930
struct FAnimNode_RigidBody : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ UPhysicsAsset* OverridePhysicsAsset;
    /* 0x00d0 */ bool bDefaultToSkeletalMeshPhysicsAsset;
    /* 0x0208 */ bool bUseLocalLODThresholdOnly;
    /* 0x0210 */ FVector OverrideWorldGravity;
    /* 0x0228 */ FVector ExternalForce;
    /* 0x0240 */ FVector ComponentLinearAccScale;
    /* 0x0258 */ FVector ComponentLinearVelScale;
    /* 0x0270 */ FVector ComponentAppliedLinearAccClamp;
    /* 0x0288 */ FSimSpaceSettings SimSpaceSettings;
    /* 0x02f0 */ float CachedBoundsScale;
    /* 0x02f4 */ FBoneReference BaseBoneRef;
    /* 0x0304 */ uint8_t OverlapChannel;
    /* 0x0305 */ ESimulationSpace SimulationSpace;
    /* 0x0306 */ bool bForceDisableCollisionBetweenConstraintBodies;
    /* 0x0307 */ bool bUseExternalClothCollision;
    /* 0x0309 */ bool bEnableWorldGeometry;
    /* 0x0309 */ bool bOverrideWorldGravity;
    /* 0x0309 */ bool bTransferBoneVelocities;
    /* 0x0309 */ bool bFreezeIncomingPoseOnStart;
    /* 0x0309 */ bool bClampLinearTranslationLimitToRefPose;
    /* 0x030c */ float WorldSpaceMinimumScale;
    /* 0x0310 */ float EvaluationResetTime;
    /* 0x0315 */ ESimulationTiming SimulationTiming;
};

// Size: 0xb0
struct FAnimNode_RotateRootBone : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink BasePose;
    /* 0x0020 */ float Pitch;
    /* 0x0024 */ float Yaw;
    /* 0x0028 */ FInputScaleBiasClamp PitchScaleBiasClamp;
    /* 0x0058 */ FInputScaleBiasClamp YawScaleBiasClamp;
    /* 0x0088 */ FRotator MeshToComponent;
    /* 0x00a0 */ bool bRotateRootMotionAttribute;
};

// Size: 0xf0
struct FAnimNode_RotationMultiplier : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference TargetBone;
    /* 0x00d8 */ FBoneReference SourceBone;
    /* 0x00e8 */ float Multiplier;
    /* 0x00ec */ uint8_t RotationAxisToRefer;
    /* 0x00ed */ bool bIsAdditive;
};

// Size: 0x118
struct FAnimNode_RotationOffsetBlendSpace : public FAnimNode_BlendSpacePlayer {
    /* 0x0070 */ FPoseLink BasePose;
    /* 0x0080 */ int32_t LODThreshold;
    /* 0x0084 */ float Alpha;
    /* 0x0088 */ FInputScaleBias AlphaScaleBias;
    /* 0x0090 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x00d8 */ FName AlphaCurveName;
    /* 0x00e0 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x0114 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0115 */ bool bAlphaBoolEnabled;
};

// Size: 0x110
struct FAnimNode_RotationOffsetBlendSpaceGraph : public FAnimNode_BlendSpaceGraphBase {
    /* 0x0068 */ FPoseLink BasePose;
    /* 0x0078 */ int32_t LODThreshold;
    /* 0x007c */ float Alpha;
    /* 0x0080 */ FInputScaleBias AlphaScaleBias;
    /* 0x0088 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x00d0 */ FName AlphaCurveName;
    /* 0x00d8 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x010c */ EAnimAlphaInputType AlphaInputType;
    /* 0x010d */ bool bAlphaBoolEnabled;
};

// Size: 0x88
struct FAnimNode_ScaleChainLength : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink InputPose;
    /* 0x0020 */ float DefaultChainLength;
    /* 0x0024 */ FBoneReference ChainStartBone;
    /* 0x0034 */ FBoneReference ChainEndBone;
    /* 0x0048 */ FVector TargetLocation;
    /* 0x0060 */ float Alpha;
    /* 0x0068 */ FInputScaleBias AlphaScaleBias;
    /* 0x0070 */ EScaleChainInitialLength ChainInitialLength;
};

// Size: 0x40
struct FAnimNode_SequenceEvaluator : public FAnimNode_SequenceEvaluatorBase {
};

// Size: 0x40
struct FAnimNode_SequenceEvaluatorBase : public FAnimNode_AssetPlayerBase {
};

// Size: 0x70
struct FAnimNode_SequenceEvaluator_Standalone : public FAnimNode_SequenceEvaluatorBase {
    /* 0x0040 */ FName GroupName;
    /* 0x0048 */ uint8_t GroupRole;
    /* 0x0049 */ EAnimSyncMethod Method;
    /* 0x004a */ bool bIgnoreForRelevancyTest;
    /* 0x0050 */ UAnimSequenceBase* Sequence;
    /* 0x0058 */ float ExplicitTime;
    /* 0x005c */ bool bUseExplicitFrame;
    /* 0x0060 */ int32_t ExplicitFrame;
    /* 0x0064 */ bool bShouldLoop;
    /* 0x0065 */ bool bTeleportToExplicitTime;
    /* 0x0066 */ uint8_t ReinitializationBehavior;
    /* 0x0068 */ float StartPosition;
};

// Size: 0xc8
struct FAnimNode_SkeletalControlBase : public FAnimNode_Base {
    /* 0x0010 */ FComponentSpacePoseLink ComponentPose;
    /* 0x0020 */ int32_t LODThreshold;
    /* 0x0024 */ float ActualAlpha;
    /* 0x0028 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0029 */ bool bAlphaBoolEnabled;
    /* 0x002c */ float Alpha;
    /* 0x0030 */ FInputScaleBias AlphaScaleBias;
    /* 0x0038 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x0080 */ FName AlphaCurveName;
    /* 0x0088 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
};

// Size: 0x48
struct FAnimNode_Slot : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Source;
    /* 0x0020 */ FName SlotName;
    /* 0x0028 */ bool bAlwaysUpdateSourcePose;
};

// Size: 0x260
struct FAnimNode_SplineIK : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference StartBone;
    /* 0x00d8 */ FBoneReference EndBone;
    /* 0x00e8 */ ESplineBoneAxis BoneAxis;
    /* 0x00e9 */ bool bAutoCalculateSpline;
    /* 0x00ec */ int32_t PointCount;
    /* 0x00f0 */ TArray<FTransform> ControlPoints;
    /* 0x0100 */ float Roll;
    /* 0x0104 */ float TwistStart;
    /* 0x0108 */ float TwistEnd;
    /* 0x0110 */ FAlphaBlend TwistBlend;
    /* 0x0140 */ float Stretch;
    /* 0x0144 */ float Offset;
};

// Size: 0x168
struct FAnimNode_SpringBone : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference SpringBone;
    /* 0x00d8 */ double MaxDisplacement;
    /* 0x00e0 */ double SpringStiffness;
    /* 0x00e8 */ double SpringDamping;
    /* 0x00f0 */ double ErrorResetThresh;
    /* 0x0164 */ bool bLimitDisplacement;
    /* 0x0164 */ bool bTranslateX;
    /* 0x0164 */ bool bTranslateY;
    /* 0x0164 */ bool bTranslateZ;
    /* 0x0164 */ bool bRotateX;
    /* 0x0164 */ bool bRotateY;
    /* 0x0164 */ bool bRotateZ;
};

// Size: 0x30
struct FAnimNode_Sync : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Source;
    /* 0x0020 */ FName GroupName;
    /* 0x0028 */ uint8_t GroupRole;
};

// Size: 0x2a0
struct FAnimNode_Trail : public FAnimNode_SkeletalControlBase {
    /* 0x0130 */ FBoneReference TrailBone;
    /* 0x0140 */ int32_t ChainLength;
    /* 0x0144 */ uint8_t ChainBoneAxis;
    /* 0x0145 */ bool bInvertChainBoneAxis;
    /* 0x0145 */ bool bLimitStretch;
    /* 0x0145 */ bool bLimitRotation;
    /* 0x0145 */ bool bUsePlanarLimit;
    /* 0x0145 */ bool bActorSpaceFakeVel;
    /* 0x0145 */ bool bReorientParentToChild;
    /* 0x0148 */ float MaxDeltaTime;
    /* 0x014c */ float RelaxationSpeedScale;
    /* 0x0150 */ FRuntimeFloatCurve TrailRelaxationSpeed;
    /* 0x01d8 */ FInputScaleBiasClamp RelaxationSpeedScaleInputProcessor;
    /* 0x0208 */ TArray<FRotationLimit> RotationLimits;
    /* 0x0218 */ TArray<FVector> RotationOffsets;
    /* 0x0228 */ TArray<FAnimPhysPlanarLimit> PlanarLimits;
    /* 0x0238 */ float StretchLimit;
    /* 0x0240 */ FVector FakeVelocity;
    /* 0x0258 */ FBoneReference BaseJoint;
    /* 0x0268 */ float LastBoneRotationAnimAlphaBlend;
};

// Size: 0x168
struct FAnimNode_TwistCorrectiveNode : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FReferenceBoneFrame BaseFrame;
    /* 0x00f8 */ FReferenceBoneFrame TwistFrame;
    /* 0x0128 */ FAxis TwistPlaneNormalAxis;
    /* 0x0148 */ float RangeMax;
    /* 0x014c */ float RemappedMin;
    /* 0x0150 */ float RemappedMax;
    /* 0x0154 */ FName CurveName;
};

// Size: 0x280
struct FAnimNode_TwoBoneIK : public FAnimNode_SkeletalControlBase {
    /* 0x00c8 */ FBoneReference IKBone;
    /* 0x00d8 */ double StartStretchRatio;
    /* 0x00e0 */ double MaxStretchScale;
    /* 0x00e8 */ FVector EffectorLocation;
    /* 0x0110 */ FBoneSocketTarget EffectorTarget;
    /* 0x01a0 */ FVector JointTargetLocation;
    /* 0x01c0 */ FBoneSocketTarget JointTarget;
    /* 0x0250 */ FAxis TwistAxis;
    /* 0x0270 */ uint8_t EffectorLocationSpace;
    /* 0x0271 */ uint8_t JointTargetLocationSpace;
    /* 0x0272 */ bool bAllowStretching;
    /* 0x0272 */ bool bTakeRotationFromEffectorSpace;
    /* 0x0272 */ bool bMaintainEffectorRelRot;
    /* 0x0272 */ bool bAllowTwist;
};

// Size: 0xc8
struct FAnimNode_TwoWayBlend : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink A;
    /* 0x0020 */ FPoseLink B;
    /* 0x0030 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0031 */ bool bAlphaBoolEnabled;
    /* 0x0031 */ bool bResetChildOnActivation;
    /* 0x0031 */ bool bAlwaysUpdateChildren;
    /* 0x0034 */ float Alpha;
    /* 0x0038 */ FInputScaleBias AlphaScaleBias;
    /* 0x0040 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x0088 */ FName AlphaCurveName;
    /* 0x0090 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
};

// Size: 0x40
class UAnimNotify_PlayMontageNotify : public UAnimNotify {
    /* 0x0038 */ FName NotifyName;
};

// Size: 0x38
class UAnimNotify_PlayMontageNotifyWindow : public UAnimNotifyState {
    /* 0x0030 */ FName NotifyName;
};

enum class AnimPhysAngularConstraintType {
    Angular = 0,
    Cone = 1,
    AnimPhysAngularConstraintType_MAX = 2,
};

// Size: 0xd0
struct FAnimPhysBodyDefinition {
    /* 0x0000 */ FBoneReference BoundBone;
    /* 0x0010 */ FVector BoxExtents;
    /* 0x0028 */ FVector LocalJointOffset;
    /* 0x0040 */ FAnimPhysConstraintSetup ConstraintSetup;
    /* 0x00c8 */ AnimPhysCollisionType CollisionType;
    /* 0x00cc */ float SphereCollisionRadius;
};

// Size: 0x88
struct FAnimPhysConstraintSetup {
    /* 0x0000 */ AnimPhysLinearConstraintType LinearXLimitType;
    /* 0x0001 */ AnimPhysLinearConstraintType LinearYLimitType;
    /* 0x0002 */ AnimPhysLinearConstraintType LinearZLimitType;
    /* 0x0008 */ FVector LinearAxesMin;
    /* 0x0020 */ FVector LinearAxesMax;
    /* 0x0038 */ AnimPhysAngularConstraintType AngularConstraintType;
    /* 0x0039 */ AnimPhysTwistAxis TwistAxis;
    /* 0x003a */ AnimPhysTwistAxis AngularTargetAxis;
    /* 0x003c */ float ConeAngle;
    /* 0x0040 */ FVector AngularLimitsMin;
    /* 0x0058 */ FVector AngularLimitsMax;
    /* 0x0070 */ FVector AngularTarget;
};

enum class AnimPhysLinearConstraintType {
    Free = 0,
    Limited = 1,
    AnimPhysLinearConstraintType_MAX = 2,
};

// Size: 0x70
struct FAnimPhysPlanarLimit {
    /* 0x0000 */ FBoneReference DrivingBone;
    /* 0x0010 */ FTransform PlaneTransform;
};

enum class AnimPhysSimSpaceType {
    Component = 0,
    Actor = 1,
    World = 2,
    RootRelative = 3,
    BoneRelative = 4,
    AnimPhysSimSpaceType_MAX = 5,
};

// Size: 0x30
struct FAnimPhysSphericalLimit {
    /* 0x0000 */ FBoneReference DrivingBone;
    /* 0x0010 */ FVector SphereLocalOffset;
    /* 0x0028 */ float LimitRadius;
    /* 0x002c */ ESphericalLimitType LimitType;
};

// Size: 0x3e0
class UAnimSequencerInstance : public UAnimInstance {
};

// Size: 0xc00
struct FAnimSequencerInstanceProxy : public FAnimInstanceProxy {
};

// Size: 0x28
class UAnimationStateMachineLibrary : public UBlueprintFunctionLibrary {

    static void ConvertToAnimationStateMachine(const FAnimNodeReference& Node, FAnimationStateMachineReference& AnimationState, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToAnimationStateMachinePure(const FAnimNodeReference& Node, FAnimationStateMachineReference& AnimationState, bool& Result);
    static void ConvertToAnimationStateResult(const FAnimNodeReference& Node, FAnimationStateResultReference& AnimationState, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToAnimationStateResultPure(const FAnimNodeReference& Node, FAnimationStateResultReference& AnimationState, bool& Result);
    static float GetRelevantAnimTimeRemaining(const FAnimUpdateContext& UpdateContext, const FAnimationStateResultReference& Node);
    static float GetRelevantAnimTimeRemainingFraction(const FAnimUpdateContext& UpdateContext, const FAnimationStateResultReference& Node);
    static FName GetState(const FAnimUpdateContext& UpdateContext, const FAnimationStateMachineReference& Node);
    static bool IsStateBlendingIn(const FAnimUpdateContext& UpdateContext, const FAnimationStateResultReference& Node);
    static bool IsStateBlendingOut(const FAnimUpdateContext& UpdateContext, const FAnimationStateResultReference& Node);
    static void SetState(const FAnimUpdateContext& UpdateContext, const FAnimationStateMachineReference& Node, FName TargetState, float Duration, uint8_t BlendType, UBlendProfile* BlendProfile, EAlphaBlendOption AlphaBlendOption, UCurveFloat* CustomBlendCurve);
};

// Size: 0x10
struct FAnimationStateMachineReference : public FAnimNodeReference {
};

// Size: 0x10
struct FAnimationStateResultReference : public FAnimNodeReference {
};

// Size: 0x24
struct FBlendBoneByChannelEntry {
    /* 0x0000 */ FBoneReference SourceBone;
    /* 0x0010 */ FBoneReference TargetBone;
    /* 0x0020 */ bool bBlendTranslation;
    /* 0x0021 */ bool bBlendRotation;
    /* 0x0022 */ bool bBlendScale;
};

// Size: 0x28
class UBlendListBaseLibrary : public UBlueprintFunctionLibrary {

    static FBlendListBaseReference ConvertToBlendListBase(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ResetNode(const FBlendListBaseReference& BlendListBase);
};

// Size: 0x10
struct FBlendListBaseReference : public FAnimNodeReference {
};

// Size: 0x28
class UBlendSpaceLibrary : public UBlueprintFunctionLibrary {

    static FBlendSpaceReference ConvertToBlendSpace(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToBlendSpacePure(const FAnimNodeReference& Node, FBlendSpaceReference& BlendSpace, bool& Result);
    static FVector GetFilteredPosition(const FBlendSpaceReference& BlendSpace);
    static FVector GetPosition(const FBlendSpaceReference& BlendSpace);
    static void SnapToPosition(const FBlendSpaceReference& BlendSpace, FVector NewPosition);
};

// Size: 0x28
class UBlendSpacePlayerLibrary : public UBlueprintFunctionLibrary {

    static FBlendSpacePlayerReference ConvertToBlendSpacePlayer(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToBlendSpacePlayerPure(const FAnimNodeReference& Node, FBlendSpacePlayerReference& BlendSpacePlayer, bool& Result);
    static UBlendSpace* GetBlendSpace(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static bool GetLoop(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static float GetPlayRate(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static FVector GetPosition(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static float GetStartPosition(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static FBlendSpacePlayerReference SetBlendSpace(const FBlendSpacePlayerReference& BlendSpacePlayer, UBlendSpace* BlendSpace);
    static FBlendSpacePlayerReference SetBlendSpaceWithInertialBlending(const FAnimUpdateContext& UpdateContext, const FBlendSpacePlayerReference& BlendSpacePlayer, UBlendSpace* BlendSpace, float BlendTime);
    static FBlendSpacePlayerReference SetLoop(const FBlendSpacePlayerReference& BlendSpacePlayer, bool bLoop);
    static FBlendSpacePlayerReference SetPlayRate(const FBlendSpacePlayerReference& BlendSpacePlayer, float PlayRate);
    static FBlendSpacePlayerReference SetResetPlayTimeWhenBlendSpaceChanges(const FBlendSpacePlayerReference& BlendSpacePlayer, bool bReset);
    static bool ShouldResetPlayTimeWhenBlendSpaceChanges(const FBlendSpacePlayerReference& BlendSpacePlayer);
    static void SnapToPosition(const FBlendSpacePlayerReference& BlendSpacePlayer, FVector NewPosition);
};

// Size: 0x10
struct FBlendSpacePlayerReference : public FAnimNodeReference {
};

// Size: 0x10
struct FBlendSpaceReference : public FAnimNodeReference {
};

// Size: 0x1c
struct FConstraint {
    /* 0x0000 */ FBoneReference TargetBone;
    /* 0x0010 */ EConstraintOffsetOption OffsetOption;
    /* 0x0011 */ ETransformConstraintType TransformType;
    /* 0x0012 */ FFilterOptionPerAxis PerAxis;
};

enum class CopyBoneDeltaMode {
    Accumulate = 0,
    Copy = 1,
    CopyBoneDeltaMode_MAX = 2,
};

enum class EAnimFunctionCallSite {
    OnInitialize = 0,
    OnUpdate = 1,
    OnBecomeRelevant = 2,
    OnEvaluate = 3,
    OnInitializePostRecursion = 4,
    OnUpdatePostRecursion = 5,
    OnBecomeRelevantPostRecursion = 6,
    OnEvaluatePostRecursion = 7,
    OnStartedBlendingOut = 8,
    OnStartedBlendingIn = 9,
    OnFinishedBlendingOut = 10,
    OnFinishedBlendingIn = 11,
    EAnimFunctionCallSite_MAX = 12,
};

enum class EBlendListChildUpdateMode {
    Default = 0,
    ResetChildOnActivate = 1,
    AlwaysTickChildren = 2,
    EBlendListChildUpdateMode_MAX = 3,
};

enum class EBlendListTransitionType {
    StandardBlend = 0,
    Inertialization = 1,
    EBlendListTransitionType_MAX = 2,
};

enum class EBoneModificationMode {
    BMM_Ignore = 0,
    BMM_Replace = 1,
    BMM_Additive = 2,
    BMM_MAX = 3,
};

enum class EConstraintOffsetOption {
    None = 0,
    Offset_RefPose = 1,
    EConstraintOffsetOption_MAX = 2,
};

enum class EDrivenBoneModificationMode {
    AddToInput = 0,
    ReplaceComponent = 1,
    AddToRefPose = 2,
    EDrivenBoneModificationMode_MAX = 3,
};

enum class EDrivenDestinationMode {
    Bone = 0,
    MorphTarget = 1,
    MaterialParameter = 2,
    EDrivenDestinationMode_MAX = 3,
};

enum class EEasingFuncType {
    Linear = 0,
    Sinusoidal = 1,
    Cubic = 2,
    QuadraticInOut = 3,
    CubicInOut = 4,
    HermiteCubic = 5,
    QuarticInOut = 6,
    QuinticInOut = 7,
    CircularIn = 8,
    CircularOut = 9,
    CircularInOut = 10,
    ExpIn = 11,
    ExpOut = 12,
    ExpInOut = 13,
    CustomCurve = 14,
    EEasingFuncType_MAX = 15,
};

enum class EInterpolationBlend {
    Linear = 0,
    Cubic = 1,
    Sinusoidal = 2,
    EaseInOutExponent2 = 3,
    EaseInOutExponent3 = 4,
    EaseInOutExponent4 = 5,
    EaseInOutExponent5 = 6,
    MAX = 7,
};

enum class ELayeredBoneBlendMode {
    BranchFilter = 0,
    BlendMask = 1,
    ELayeredBoneBlendMode_MAX = 2,
};

enum class EModifyCurveApplyMode {
    Add = 0,
    Scale = 1,
    Blend = 2,
    WeightedMovingAverage = 3,
    RemapCurve = 4,
    EModifyCurveApplyMode_MAX = 5,
};

enum class EPoseDriverOutput {
    DrivePoses = 0,
    DriveCurves = 1,
    EPoseDriverOutput_MAX = 2,
};

enum class EPoseDriverSource {
    Rotation = 0,
    Translation = 1,
    EPoseDriverSource_MAX = 2,
};

enum class EPoseDriverType {
    SwingAndTwist = 0,
    SwingOnly = 1,
    Translation = 2,
    EPoseDriverType_MAX = 3,
};

enum class ERBFDistanceMethod {
    Euclidean = 0,
    Quaternion = 1,
    SwingAngle = 2,
    TwistAngle = 3,
    DefaultMethod = 4,
    ERBFDistanceMethod_MAX = 5,
};

enum class ERBFFunctionType {
    Gaussian = 0,
    Exponential = 1,
    Linear = 2,
    Cubic = 3,
    Quintic = 4,
    DefaultFunction = 5,
    ERBFFunctionType_MAX = 6,
};

enum class ERBFNormalizeMethod {
    OnlyNormalizeAboveOne = 0,
    AlwaysNormalize = 1,
    NormalizeWithinMedian = 2,
    NoNormalization = 3,
    ERBFNormalizeMethod_MAX = 4,
};

enum class ERBFSolverType {
    Additive = 0,
    Interpolative = 1,
    ERBFSolverType_MAX = 2,
};

enum class ERefPoseType {
    EIT_LocalSpace = 0,
    EIT_Additive = 1,
    EIT_MAX = 2,
};

enum class ERotationComponent {
    EulerX = 0,
    EulerY = 1,
    EulerZ = 2,
    QuaternionAngle = 3,
    SwingAngle = 4,
    TwistAngle = 5,
    ERotationComponent_MAX = 6,
};

enum class EScaleChainInitialLength {
    FixedDefaultLengthValue = 0,
    Distance = 1,
    ChainLength = 2,
    EScaleChainInitialLength_MAX = 3,
};

enum class ESequenceEvalReinit {
    NoReset = 0,
    StartPosition = 1,
    ExplicitTime = 2,
    ESequenceEvalReinit_MAX = 3,
};

enum class ESimulationSpace {
    ComponentSpace = 0,
    WorldSpace = 1,
    BaseBoneSpace = 2,
    ESimulationSpace_MAX = 3,
};

enum class ESimulationTiming {
    Default = 0,
    Synchronous = 1,
    Deferred = 2,
    ESimulationTiming_MAX = 3,
};

enum class ESnapshotSourceMode {
    NamedSnapshot = 0,
    SnapshotPin = 1,
    ESnapshotSourceMode_MAX = 2,
};

enum class ESphericalLimitType {
    Inner = 0,
    Outer = 1,
    ESphericalLimitType_MAX = 2,
};

enum class ESplineBoneAxis {
    None = 0,
    X = 1,
    Y = 2,
    Z = 3,
    ESplineBoneAxis_MAX = 4,
};

enum class ESwapRootBone {
    SwapRootBone_Component = 0,
    SwapRootBone_Actor = 1,
    SwapRootBone_None = 2,
    SwapRootBone_MAX = 3,
};

enum class EWarpingEvaluationMode {
    Manual = 0,
    Graph = 1,
    EWarpingEvaluationMode_MAX = 2,
};

enum class EWarpingVectorMode {
    ComponentSpaceVector = 0,
    ActorSpaceVector = 1,
    WorldSpaceVector = 2,
    IKFootRootLocalSpaceVector = 3,
    EWarpingVectorMode_MAX = 4,
};

// Size: 0x50
struct FIKChain {
};

// Size: 0x70
struct FIKChainLink {
};

// Size: 0x80
struct FIKFootPelvisPullDownSolver {
    /* 0x0000 */ FVectorRK4SpringInterpolator PelvisAdjustmentInterp;
    /* 0x0060 */ double PelvisAdjustmentInterpAlpha;
    /* 0x0068 */ double PelvisAdjustmentMaxDistance;
    /* 0x0070 */ double PelvisAdjustmentErrorTolerance;
    /* 0x0078 */ int32_t PelvisAdjustmentMaxIter;
};

// Size: 0x28
class UKismetAnimationLibrary : public UBlueprintFunctionLibrary {

    static float CalculateDirection(const FVector& Velocity, const FRotator& BaseRotation);
    static float K2_CalculateVelocityFromPositionHistory(float DeltaSeconds, FVector position, FPositionHistory& History, int32_t NumberOfSamples, float VelocityMin, float VelocityMax);
    static float K2_CalculateVelocityFromSockets(float DeltaSeconds, USkeletalMeshComponent* Component, const FName SocketOrBoneName, const FName ReferenceSocketOrBone, uint8_t SocketSpace, FVector OffsetInBoneSpace, FPositionHistory& History, int32_t NumberOfSamples, float VelocityMin, float VelocityMax, EEasingFuncType EasingType, const FRuntimeFloatCurve& CustomCurve);
    static FVector K2_DirectionBetweenSockets(const USkeletalMeshComponent* Component, const FName SocketOrBoneNameFrom, const FName SocketOrBoneNameTo);
    static float K2_DistanceBetweenTwoSocketsAndMapRange(const USkeletalMeshComponent* Component, const FName SocketOrBoneNameA, uint8_t SocketSpaceA, const FName SocketOrBoneNameB, uint8_t SocketSpaceB, bool bRemapRange, float InRangeMin, float InRangeMax, float OutRangeMin, float OutRangeMax);
    static float K2_EndProfilingTimer(bool bLog, FString LogPrefix);
    static FTransform K2_LookAt(const FTransform& CurrentTransform, const FVector& TargetPosition, FVector LookAtVector, bool bUseUpVector, FVector UpVector, float ClampConeInDegree);
    static float K2_MakePerlinNoiseAndRemap(float Value, float RangeOutMin, float RangeOutMax);
    static FVector K2_MakePerlinNoiseVectorAndRemap(float X, float Y, float Z, float RangeOutMinX, float RangeOutMaxX, float RangeOutMinY, float RangeOutMaxY, float RangeOutMinZ, float RangeOutMaxZ);
    static void K2_StartProfilingTimer();
    static void K2_TwoBoneIK(const FVector& RootPos, const FVector& JointPos, const FVector& EndPos, const FVector& JointTarget, const FVector& Effector, FVector& OutJointPos, FVector& OutEndPos, bool bAllowStretching, float StartStretchRatio, float MaxStretchScale);
};

// Size: 0x28
class ULayeredBoneBlendLibrary : public UBlueprintFunctionLibrary {

    static void ConvertToLayeredBlendPerBonePure(const FAnimNodeReference& Node, FLayeredBoneBlendReference& LayeredBoneBlend, bool& Result);
    static FLayeredBoneBlendReference ConvertToLayeredBoneBlend(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static int32_t GetNumPoses(const FLayeredBoneBlendReference& LayeredBoneBlend);
    static FLayeredBoneBlendReference SetBlendMask(const FAnimUpdateContext& UpdateContext, const FLayeredBoneBlendReference& LayeredBoneBlend, int32_t PoseIndex, FName BlendMaskName);
};

// Size: 0x10
struct FLayeredBoneBlendReference : public FAnimNodeReference {
};

// Size: 0x28
class ULinkedAnimGraphLibrary : public UBlueprintFunctionLibrary {

    static FLinkedAnimGraphReference ConvertToLinkedAnimGraph(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToLinkedAnimGraphPure(const FAnimNodeReference& Node, FLinkedAnimGraphReference& LinkedAnimGraph, bool& Result);
    static UAnimInstance* GetLinkedAnimInstance(const FLinkedAnimGraphReference& Node);
    static bool HasLinkedAnimInstance(const FLinkedAnimGraphReference& Node);
};

// Size: 0x10
struct FLinkedAnimGraphReference : public FAnimNodeReference {
};

// Size: 0x28
class UMirrorAnimLibrary : public UBlueprintFunctionLibrary {

    static FMirrorAnimNodeReference ConvertToMirrorNode(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToMirrorNodePure(const FAnimNodeReference& Node, FMirrorAnimNodeReference& MirrorNode, bool& Result);
    static bool GetMirror(const FMirrorAnimNodeReference& MirrorNode);
    static UMirrorDataTable* GetMirrorDataTable(const FMirrorAnimNodeReference& MirrorNode);
    static float GetMirrorTransitionBlendTime(const FMirrorAnimNodeReference& MirrorNode);
    static FMirrorAnimNodeReference SetMirror(const FMirrorAnimNodeReference& MirrorNode, bool bInMirror);
    static FMirrorAnimNodeReference SetMirrorTransitionBlendTime(const FMirrorAnimNodeReference& MirrorNode, float InBlendTime);
};

// Size: 0x10
struct FMirrorAnimNodeReference : public FAnimNodeReference {
};

// Size: 0x28
class UModifyCurveAnimLibrary : public UBlueprintFunctionLibrary {

    static FModifyCurveAnimNodeReference ConvertToModifyCurveNode(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToModifyCurveNodePure(const FAnimNodeReference& Node, FModifyCurveAnimNodeReference& ModifyCurveNode, bool& Result);
    static float GetAlpha(const FModifyCurveAnimNodeReference& ModifyCurveNode);
    static EModifyCurveApplyMode GetApplyMode(const FModifyCurveAnimNodeReference& ModifyCurveNode);
    static FModifyCurveAnimNodeReference SetAlpha(const FModifyCurveAnimNodeReference& ModifyCurveNode, float InAlpha);
    static FModifyCurveAnimNodeReference SetApplyMode(const FModifyCurveAnimNodeReference& ModifyCurveNode, EModifyCurveApplyMode InMode);
    static FModifyCurveAnimNodeReference SetCurveMap(const FModifyCurveAnimNodeReference& ModifyCurveNode, const TMap<FName, float>& InCurveMap);
};

// Size: 0x10
struct FModifyCurveAnimNodeReference : public FAnimNodeReference {
};

// Size: 0xa8
class UPlayMontageCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnCompleted;
    /* 0x0038 */ FMulticastInlineDelegate OnBlendOut;
    /* 0x0048 */ FMulticastInlineDelegate OnInterrupted;
    /* 0x0058 */ FMulticastInlineDelegate OnNotifyBegin;
    /* 0x0068 */ FMulticastInlineDelegate OnNotifyEnd;

    static UPlayMontageCallbackProxy* CreateProxyObjectForPlayMontage(USkeletalMeshComponent* InSkeletalMeshComponent, UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, FName StartingSection, bool bShouldStopAllMontages);
    void OnMontageBlendingOut(UAnimMontage* Montage, bool bInterrupted);
    void OnMontageEnded(UAnimMontage* Montage, bool bInterrupted);
    void OnNotifyBeginReceived(FName NotifyName, const FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
    void OnNotifyEndReceived(FName NotifyName, const FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
};

// Size: 0xc8
struct FPoseDriverTarget {
    /* 0x0000 */ TArray<FPoseDriverTransform> BoneTransforms;
    /* 0x0010 */ FRotator TargetRotation;
    /* 0x0028 */ float TargetScale;
    /* 0x002c */ ERBFDistanceMethod DistanceMethod;
    /* 0x002d */ ERBFFunctionType FunctionType;
    /* 0x002e */ bool bApplyCustomCurve;
    /* 0x0030 */ FRichCurve CustomCurve;
    /* 0x00b0 */ FName DrivenName;
    /* 0x00c0 */ bool bIsHidden;
};

// Size: 0x30
struct FPoseDriverTransform {
    /* 0x0000 */ FVector TargetTranslation;
    /* 0x0018 */ FRotator TargetRotation;
};

// Size: 0x30
struct FPositionHistory {
    /* 0x0000 */ TArray<FVector> Positions;
    /* 0x0010 */ float Range;
};

// Size: 0x10
struct FRBFEntry {
    /* 0x0000 */ TArray<float> Values;
};

// Size: 0x38
struct FRBFParams {
    /* 0x0000 */ int32_t TargetDimensions;
    /* 0x0004 */ ERBFSolverType SolverType;
    /* 0x0008 */ float Radius;
    /* 0x000c */ bool bAutomaticRadius;
    /* 0x000d */ ERBFFunctionType Function;
    /* 0x000e */ ERBFDistanceMethod DistanceMethod;
    /* 0x000f */ uint8_t TwistAxis;
    /* 0x0010 */ float WeightThreshold;
    /* 0x0014 */ ERBFNormalizeMethod NormalizeMethod;
    /* 0x0018 */ FVector MedianReference;
    /* 0x0030 */ float MedianMin;
    /* 0x0034 */ float MedianMax;
};

// Size: 0xa0
struct FRBFTarget : public FRBFEntry {
    /* 0x0010 */ float ScaleFactor;
    /* 0x0014 */ bool bApplyCustomCurve;
    /* 0x0018 */ FRichCurve CustomCurve;
    /* 0x0098 */ ERBFDistanceMethod DistanceMethod;
    /* 0x0099 */ ERBFFunctionType FunctionType;
};

// Size: 0x50
struct FRandomPlayerSequenceEntry {
    /* 0x0000 */ UAnimSequenceBase* Sequence;
    /* 0x0008 */ float ChanceToPlay;
    /* 0x000c */ int32_t MinLoopCount;
    /* 0x0010 */ int32_t MaxLoopCount;
    /* 0x0014 */ float MinPlayRate;
    /* 0x0018 */ float MaxPlayRate;
    /* 0x0020 */ FAlphaBlend BlendIn;
};

// Size: 0x30
struct FReferenceBoneFrame {
    /* 0x0000 */ FBoneReference bone;
    /* 0x0010 */ FAxis Axis;
};

// Size: 0x10
struct FRigidBodyAnimNodeReference : public FAnimNodeReference {
};

// Size: 0x30
struct FRotationLimit {
    /* 0x0000 */ FVector LimitMin;
    /* 0x0018 */ FVector LimitMax;
};

// Size: 0x1a0
struct FRotationRetargetingInfo {
    /* 0x0000 */ bool bEnabled;
    /* 0x0010 */ FTransform Source;
    /* 0x0070 */ FTransform Target;
    /* 0x00d0 */ ERotationComponent RotationComponent;
    /* 0x00d8 */ FVector TwistAxis;
    /* 0x00f0 */ bool bUseAbsoluteAngle;
    /* 0x00f4 */ float SourceMinimum;
    /* 0x00f8 */ float SourceMaximum;
    /* 0x00fc */ float TargetMinimum;
    /* 0x0100 */ float TargetMaximum;
    /* 0x0104 */ EEasingFuncType EasingType;
    /* 0x0108 */ FRuntimeFloatCurve CustomCurve;
    /* 0x0190 */ bool bFlipEasing;
    /* 0x0194 */ float EasingWeight;
    /* 0x0198 */ bool bClamp;
};

// Size: 0x28
class USequenceEvaluatorLibrary : public UBlueprintFunctionLibrary {

    static FSequenceEvaluatorReference AdvanceTime(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator, float PlayRate);
    static FSequenceEvaluatorReference ConvertToSequenceEvaluator(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToSequenceEvaluatorPure(const FAnimNodeReference& Node, FSequenceEvaluatorReference& SequenceEvaluator, bool& Result);
    static float GetAccumulatedTime(const FSequenceEvaluatorReference& SequenceEvaluator);
    static UAnimSequenceBase* GetSequence(const FSequenceEvaluatorReference& SequenceEvaluator);
    static FSequenceEvaluatorReference SetExplicitFrame(const FSequenceEvaluatorReference& SequenceEvaluator, int32_t Frame);
    static FSequenceEvaluatorReference SetExplicitTime(const FSequenceEvaluatorReference& SequenceEvaluator, float Time);
    static FSequenceEvaluatorReference SetSequence(const FSequenceEvaluatorReference& SequenceEvaluator, UAnimSequenceBase* Sequence);
    static FSequenceEvaluatorReference SetSequenceWithInertialBlending(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator, UAnimSequenceBase* Sequence, float BlendTime);
};

// Size: 0x10
struct FSequenceEvaluatorReference : public FAnimNodeReference {
};

// Size: 0x28
class USequencePlayerLibrary : public UBlueprintFunctionLibrary {

    static float ComputePlayRateFromDuration(const FSequencePlayerReference& SequencePlayer, float Duration);
    static FSequencePlayerReference ConvertToSequencePlayer(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToSequencePlayerPure(const FAnimNodeReference& Node, FSequencePlayerReference& SequencePlayer, bool& Result);
    static float GetAccumulatedTime(const FSequencePlayerReference& SequencePlayer);
    static bool GetLoopAnimation(const FSequencePlayerReference& SequencePlayer);
    static float GetPlayRate(const FSequencePlayerReference& SequencePlayer);
    static FSequencePlayerReference GetSequence(const FSequencePlayerReference& SequencePlayer, UAnimSequenceBase*& SequenceBase);
    static UAnimSequenceBase* GetSequencePure(const FSequencePlayerReference& SequencePlayer);
    static float GetStartPosition(const FSequencePlayerReference& SequencePlayer);
    static FSequencePlayerReference SetAccumulatedTime(const FSequencePlayerReference& SequencePlayer, float Time);
    static FSequencePlayerReference SetPlayRate(const FSequencePlayerReference& SequencePlayer, float PlayRate);
    static FSequencePlayerReference SetSequence(const FSequencePlayerReference& SequencePlayer, UAnimSequenceBase* Sequence);
    static FSequencePlayerReference SetSequenceWithInertialBlending(const FAnimUpdateContext& UpdateContext, const FSequencePlayerReference& SequencePlayer, UAnimSequenceBase* Sequence, float BlendTime);
    static FSequencePlayerReference SetStartPosition(const FSequencePlayerReference& SequencePlayer, float StartPosition);
};

// Size: 0x10
struct FSequencePlayerReference : public FAnimNodeReference {
};

// Size: 0x28
class ISequencerAnimationOverride : public UInterface {

    bool AllowsCinematicOverride() const;
    TArray<FName> GetSequencerAnimSlotNames() const;
};

// Size: 0x28
class ISequencerAnimationSupport : public UInterface {
};

// Size: 0x68
struct FSimSpaceSettings {
    /* 0x0000 */ float WorldAlpha;
    /* 0x0004 */ float VelocityScaleZ;
    /* 0x0008 */ float DampingAlpha;
    /* 0x000c */ float MaxLinearVelocity;
    /* 0x0010 */ float MaxAngularVelocity;
    /* 0x0014 */ float MaxLinearAcceleration;
    /* 0x0018 */ float MaxAngularAcceleration;
    /* 0x0020 */ FVector ExternalLinearDragV;
    /* 0x0038 */ FVector ExternalLinearVelocity;
    /* 0x0050 */ FVector ExternalAngularVelocity;
};

// Size: 0x28
class USkeletalControlLibrary : public UBlueprintFunctionLibrary {

    static FSkeletalControlReference ConvertToSkeletalControl(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToSkeletalControlPure(const FAnimNodeReference& Node, FSkeletalControlReference& SkeletalControl, bool& Result);
    static float GetAlpha(const FSkeletalControlReference& SkeletalControl);
    static FSkeletalControlReference SetAlpha(const FSkeletalControlReference& SkeletalControl, float Alpha);
};

// Size: 0x10
struct FSkeletalControlReference : public FAnimNodeReference {
};

// Size: 0x14
struct FSplineIKCachedBoneData {
    /* 0x0000 */ FBoneReference bone;
    /* 0x0010 */ int32_t RefSkeletonIndex;
};

// Size: 0x20
struct FWarpingVectorValue {
    /* 0x0000 */ EWarpingVectorMode Mode;
    /* 0x0008 */ FVector Value;
};

// Size: 0x70
struct FAimConstraintDescription : public FConstraintDescriptionEx {
    /* 0x0010 */ FAxis LookAt_Axis;
    /* 0x0030 */ FAxis LookUp_Axis;
    /* 0x0050 */ bool bUseLookUp;
    /* 0x0058 */ FVector LookUpTarget;
};

// Size: 0x78
class UAnimationDataSourceRegistry : public UObject {
    /* 0x0028 */ TMap<FName, TWeakObjectPtr<UObject>> DataSources;
};

// Size: 0x20
struct FAxis {
    /* 0x0000 */ FVector Axis;
    /* 0x0018 */ bool bInLocalSpace;
};

// Size: 0xe0
struct FCCDIKChainLink {
};

// Size: 0xe0
struct FConstraintData {
    /* 0x0000 */ FConstraintDescriptor Constraint;
    /* 0x0010 */ float Weight;
    /* 0x0014 */ bool bMaintainOffset;
    /* 0x0020 */ FTransform Offset;
    /* 0x0080 */ FTransform CurrentTransform;
};

// Size: 0xd
struct FConstraintDescription {
    /* 0x0000 */ bool bTranslation;
    /* 0x0001 */ bool bRotation;
    /* 0x0002 */ bool bScale;
    /* 0x0003 */ bool bParent;
    /* 0x0004 */ FFilterOptionPerAxis TranslationAxes;
    /* 0x0007 */ FFilterOptionPerAxis RotationAxes;
    /* 0x000a */ FFilterOptionPerAxis ScaleAxes;
};

// Size: 0x10
struct FConstraintDescriptionEx {
    /* 0x0008 */ FFilterOptionPerAxis AxesFilterOption;
};

// Size: 0x10
struct FConstraintDescriptor {
    /* 0x0000 */ EConstraintType Type;
};

// Size: 0xc0
struct FConstraintOffset {
    /* 0x0000 */ FVector Translation;
    /* 0x0020 */ FQuat Rotation;
    /* 0x0040 */ FVector Scale;
    /* 0x0060 */ FTransform Parent;
};

enum class EConstraintType {
    Transform = 0,
    Aim = 1,
    MAX = 2,
};

enum class EEulerRotationOrder {
    XYZ = 0,
    XZY = 1,
    YXZ = 2,
    YZX = 3,
    ZXY = 4,
    ZYX = 5,
    EEulerRotationOrder_MAX = 6,
};

enum class ETransformConstraintType {
    Translation = 0,
    Rotation = 1,
    Scale = 2,
    Parent = 3,
    LookAt = 4,
    ETransformConstraintType_MAX = 5,
};

// Size: 0x48
struct FEulerTransform {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ FVector Scale;
};

// Size: 0x50
struct FFABRIKChainLink {
};

// Size: 0x3
struct FFilterOptionPerAxis {
    /* 0x0000 */ bool bX;
    /* 0x0001 */ bool bY;
    /* 0x0002 */ bool bZ;
};

// Size: 0x10
struct FNodeChain {
    /* 0x0000 */ TArray<FName> Nodes;
};

// Size: 0x70
struct FNodeHierarchyData {
    /* 0x0000 */ TArray<FNodeObject> Nodes;
    /* 0x0010 */ TArray<FTransform> Transforms;
    /* 0x0020 */ TMap<FName, int32_t> NodeNameToIndexMapping;
};

// Size: 0x78
struct FNodeHierarchyWithUserData {
    /* 0x0008 */ FNodeHierarchyData Hierarchy;
};

// Size: 0x10
struct FNodeObject {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName ParentName;
};

// Size: 0x28
struct FTransformConstraint {
    /* 0x0000 */ FConstraintDescription Operator;
    /* 0x0010 */ FName SourceNode;
    /* 0x0018 */ FName TargetNode;
    /* 0x0020 */ float Weight;
    /* 0x0024 */ bool bMaintainOffset;
};

// Size: 0x18
struct FTransformConstraintDescription : public FConstraintDescriptionEx {
    /* 0x0010 */ ETransformConstraintType TransformType;
};

// Size: 0x9
struct FTransformFilter {
    /* 0x0000 */ FFilterOptionPerAxis TranslationFilter;
    /* 0x0003 */ FFilterOptionPerAxis RotationFilter;
    /* 0x0006 */ FFilterOptionPerAxis ScaleFilter;
};

// Size: 0x40
struct FTransformNoScale {
    /* 0x0000 */ FVector Location;
    /* 0x0020 */ FQuat Rotation;
};

// Size: 0x28
class IAssetRegistry : public UInterface {

    bool GetAllAssets(TArray<FAssetData>& OutAssetData, bool bIncludeOnlyOnDiskAssets) const;
    void GetAllCachedPaths(TArray<FString>& OutPathList) const;
    bool GetAncestorClassNames(FTopLevelAssetPath ClassPathName, TArray<FTopLevelAssetPath>& OutAncestorClassNames) const;
    FAssetData GetAssetByObjectPath(const FName ObjectPath, bool bIncludeOnlyOnDiskAssets) const;
    bool GetAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets) const;
    bool GetAssetsByClass(FTopLevelAssetPath ClassPathName, TArray<FAssetData>& OutAssetData, bool bSearchSubClasses) const;
    bool GetAssetsByPackageName(FName PackageName, TArray<FAssetData>& OutAssetData, bool bIncludeOnlyOnDiskAssets, bool bSkipARFilteredAssets) const;
    bool GetAssetsByPath(FName PackagePath, TArray<FAssetData>& OutAssetData, bool bRecursive, bool bIncludeOnlyOnDiskAssets) const;
    bool GetAssetsByPaths(TArray<FName> PackagePaths, TArray<FAssetData>& OutAssetData, bool bRecursive, bool bIncludeOnlyOnDiskAssets) const;
    void GetDerivedClassNames(const TArray<FTopLevelAssetPath>& ClassNames, const TSet<FTopLevelAssetPath>& ExcludedClassNames, TSet<FTopLevelAssetPath>& OutDerivedClassNames) const;
    bool GetInMemoryAssets(const FARFilter& Filter, TArray<FAssetData>& OutAssetData, bool bSkipARFilteredAssets) const;
    void GetSubPaths(FString InBasePath, TArray<FString>& OutPathList, bool bInRecurse) const;
    bool HasAssets(const FName PackagePath, const bool bRecursive) const;
    bool IsLoadingAssets() const;
    bool IsSearchAllAssets() const;
    bool IsSearchAsync() const;
    FAssetData K2_GetAssetByObjectPath(const FSoftObjectPath& ObjectPath, bool bIncludeOnlyOnDiskAssets, bool bSkipARFilteredAssets) const;
    bool K2_GetDependencies(FName PackageName, const FAssetRegistryDependencyOptions& DependencyOptions, TArray<FName>& OutDependencies) const;
    bool K2_GetReferencers(FName PackageName, const FAssetRegistryDependencyOptions& ReferenceOptions, TArray<FName>& OutReferencers) const;
    void PrioritizeSearchPath(FString PathToPrioritize);
    void RunAssetsThroughFilter(TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const;
    void ScanFilesSynchronous(const TArray<FString>& InFilePaths, bool bForceRescan);
    void ScanModifiedAssetFiles(const TArray<FString>& InFilePaths);
    void ScanPathsSynchronous(const TArray<FString>& InPaths, bool bForceRescan, bool bIgnoreDenyListScanFilters);
    void SearchAllAssets(bool bSynchronousSearch);
    void UseFilterToExcludeAssets(TArray<FAssetData>& AssetDataList, const FARFilter& Filter) const;
    void WaitForCompletion();
    void WaitForPackage(FString PackageName);
};

// Size: 0x5
struct FAssetRegistryDependencyOptions {
    /* 0x0000 */ bool bIncludeSoftPackageReferences;
    /* 0x0001 */ bool bIncludeHardPackageReferences;
    /* 0x0002 */ bool bIncludeSearchableNames;
    /* 0x0003 */ bool bIncludeSoftManagementReferences;
    /* 0x0004 */ bool bIncludeHardManagementReferences;
};

// Size: 0x28
class UAssetRegistryHelpers : public UObject {

    static FAssetData CreateAssetData(const UObject* InAsset, bool bAllowBlueprintClass);
    static UClass* FindAssetNativeClass(const FAssetData& AssetData);
    static UObject* GetAsset(const FAssetData& InAssetData);
    static TScriptInterface<IAssetRegistry> GetAssetRegistry();
    static void GetBlueprintAssets(const FARFilter& InFilter, TArray<FAssetData>& OutAssetData);
    static UClass* GetClass(const FAssetData& InAssetData);
    static FString GetExportTextName(const FAssetData& InAssetData);
    static FString GetFullName(const FAssetData& InAssetData);
    static bool GetTagValue(const FAssetData& InAssetData, const FName& InTagName, FString& OutTagValue);
    static bool IsAssetLoaded(const FAssetData& InAssetData);
    static bool IsRedirector(const FAssetData& InAssetData);
    static bool IsUAsset(const FAssetData& InAssetData);
    static bool IsValid(const FAssetData& InAssetData);
    static FARFilter SetFilterTagsAndValues(const FARFilter& InFilter, const TArray<FTagAndValue>& InTagsAndValues);
    static void SortByAssetName(TArray<FAssetData>& Assets, EAssetRegistrySortOrder SortOrder);
    static void SortByPredicate(TArray<FAssetData>& Assets, FDelegate SortingPredicate, EAssetRegistrySortOrder SortOrder);
    bool SortingPredicate__DelegateSignature(const FAssetData& Left, const FAssetData& Right);
    static FSoftObjectPath ToSoftObjectPath(const FAssetData& InAssetData);
};

// Size: 0x11a0
class UAssetRegistryImpl : public UObject {
};

enum class EAssetRegistrySortOrder {
    Ascending = 0,
    Descending = 1,
    EAssetRegistrySortOrder_MAX = 2,
};

// Size: 0x18
struct FTagAndValue {
    /* 0x0000 */ FName Tag;
    /* 0x0008 */ FString Value;
};

// Size: 0x4b0
struct FALoadingScreenSettings {
    /* 0x0000 */ float MinimumLoadingScreenDisplayTime;
    /* 0x0004 */ bool bAutoCompleteWhenLoadingCompletes;
    /* 0x0005 */ bool bMoviesAreSkippable;
    /* 0x0006 */ bool bWaitForManualStop;
    /* 0x0007 */ bool bAllowInEarlyStartup;
    /* 0x0008 */ bool bAllowEngineTick;
    /* 0x0009 */ uint8_t PlaybackType;
    /* 0x0010 */ TArray<FString> MoviePaths;
    /* 0x0020 */ bool bShuffle;
    /* 0x0021 */ bool bSetDisplayMovieIndexManually;
    /* 0x0022 */ bool bShowWidgetOverlay;
    /* 0x0023 */ bool bShowLoadingCompleteText;
    /* 0x0028 */ FLoadingCompleteTextSettings LoadingCompleteTextSettings;
    /* 0x00f8 */ FBackgroundSettings Background;
    /* 0x0130 */ FTipSettings TipWidget;
    /* 0x01f0 */ FLoadingWidgetSettings LoadingWidget;
    /* 0x04a0 */ EAsyncLoadingScreenLayout Layout;
};

// Size: 0x28
class UAsyncLoadingScreenLibrary : public UBlueprintFunctionLibrary {

    static bool GetIsEnableLoadingScreen();
    static void PreloadBackgroundImages();
    static void RemovePreloadedBackgroundImages();
    static void SetDisplayBackgroundIndex(int32_t BackgroundIndex);
    static void SetDisplayMovieIndex(int32_t MovieIndex);
    static void SetDisplayTipTextIndex(int32_t TipTextIndex);
    static void SetEnableLoadingScreen(bool bIsEnableLoadingScreen);
    static void StopLoadingScreen();
};

// Size: 0x38
struct FBackgroundSettings {
    /* 0x0000 */ TArray<FSoftObjectPath> Images;
    /* 0x0010 */ uint8_t ImageStretch;
    /* 0x0014 */ FMargin Padding;
    /* 0x0024 */ FLinearColor BackgroundColor;
    /* 0x0034 */ bool bSetDisplayBackgroundManually;
};

// Size: 0xd0
struct FCenterLayoutSettings {
    /* 0x0000 */ bool bIsTipAtBottom;
    /* 0x0001 */ FWidgetAlignment TipAlignment;
    /* 0x0003 */ uint8_t BorderHorizontalAlignment;
    /* 0x0004 */ float BorderVerticalOffset;
    /* 0x0008 */ FMargin BorderPadding;
    /* 0x0020 */ FSlateBrush BorderBackground;
};

// Size: 0xc0
struct FCircularThrobberSettings {
    /* 0x0000 */ int32_t NumberOfPieces;
    /* 0x0004 */ float Period;
    /* 0x0008 */ float Radius;
    /* 0x0010 */ FSlateBrush Image;
};

// Size: 0xd0
struct FClassicLayoutSettings {
    /* 0x0000 */ bool bIsWidgetAtBottom;
    /* 0x0001 */ bool bIsLoadingWidgetAtLeft;
    /* 0x0004 */ float Space;
    /* 0x0008 */ FWidgetAlignment TipAlignment;
    /* 0x000a */ uint8_t BorderHorizontalAlignment;
    /* 0x000c */ FMargin BorderPadding;
    /* 0x0020 */ FSlateBrush BorderBackground;
};

// Size: 0x190
struct FDualSidebarLayoutSettings {
    /* 0x0000 */ bool bIsLoadingWidgetAtRight;
    /* 0x0001 */ uint8_t LeftVerticalAlignment;
    /* 0x0002 */ uint8_t RightVerticalAlignment;
    /* 0x0003 */ uint8_t LeftBorderVerticalAlignment;
    /* 0x0004 */ uint8_t RightBorderVerticalAlignment;
    /* 0x0008 */ FMargin LeftBorderPadding;
    /* 0x0018 */ FMargin RightBorderPadding;
    /* 0x0030 */ FSlateBrush LeftBorderBackground;
    /* 0x00e0 */ FSlateBrush RightBorderBackground;
};

enum class EAsyncLoadingScreenLayout {
    ALSL_Classic = 0,
    ALSL_Center = 1,
    ALSL_Letterbox = 2,
    ALSL_Sidebar = 3,
    ALSL_DualSidebar = 4,
    ALSL_MAX = 5,
};

enum class ELoadingIconType {
    LIT_Throbber = 0,
    LIT_CircularThrobber = 1,
    LIT_ImageSequence = 2,
    LIT_MAX = 3,
};

enum class ELoadingWidgetType {
    LWT_Horizontal = 0,
    LWT_Vertical = 1,
    LWT_MAX = 2,
};

// Size: 0x28
struct FImageSequenceSettings {
    /* 0x0000 */ TArray<UTexture2D*> Images;
    /* 0x0010 */ FVector2D Scale;
    /* 0x0020 */ float interval;
    /* 0x0024 */ bool bPlayReverse;
};

// Size: 0x190
struct FLetterboxLayoutSettings {
    /* 0x0000 */ bool bIsLoadingWidgetAtTop;
    /* 0x0001 */ FWidgetAlignment TipAlignment;
    /* 0x0003 */ FWidgetAlignment LoadingWidgetAlignment;
    /* 0x0005 */ uint8_t TopBorderHorizontalAlignment;
    /* 0x0006 */ uint8_t BottomBorderHorizontalAlignment;
    /* 0x0008 */ FMargin TopBorderPadding;
    /* 0x0018 */ FMargin BottomBorderPadding;
    /* 0x0030 */ FSlateBrush TopBorderBackground;
    /* 0x00e0 */ FSlateBrush BottomBorderBackground;
};

// Size: 0xd0
struct FLoadingCompleteTextSettings {
    /* 0x0000 */ FText LoadingCompleteText;
    /* 0x0010 */ FTextAppearance Appearance;
    /* 0x00b0 */ FWidgetAlignment Alignment;
    /* 0x00b4 */ FMargin Padding;
    /* 0x00c4 */ bool bFadeInOutAnim;
    /* 0x00c8 */ float AnimationSpeed;
};

// Size: 0xf40
class ULoadingScreenSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bPreloadBackgroundImages;
    /* 0x0040 */ FALoadingScreenSettings StartupLoadingScreen;
    /* 0x04f0 */ FALoadingScreenSettings DefaultLoadingScreen;
    /* 0x09a0 */ FClassicLayoutSettings Classic;
    /* 0x0a70 */ FCenterLayoutSettings Center;
    /* 0x0b40 */ FLetterboxLayoutSettings Letterbox;
    /* 0x0cd0 */ FSidebarLayoutSettings Sidebar;
    /* 0x0db0 */ FDualSidebarLayoutSettings DualSidebar;
};

// Size: 0x2b0
struct FLoadingWidgetSettings {
    /* 0x0000 */ ELoadingIconType LoadingIconType;
    /* 0x0001 */ ELoadingWidgetType LoadingWidgetType;
    /* 0x0008 */ FVector2D TransformTranslation;
    /* 0x0018 */ FVector2D TransformScale;
    /* 0x0028 */ FVector2D TransformPivot;
    /* 0x0038 */ FText LoadingText;
    /* 0x0048 */ bool bLoadingTextRightPosition;
    /* 0x0049 */ bool bLoadingTextTopPosition;
    /* 0x0050 */ FTextAppearance Appearance;
    /* 0x00f0 */ FThrobberSettings ThrobberSettings;
    /* 0x01b0 */ FCircularThrobberSettings CircularThrobberSettings;
    /* 0x0270 */ FImageSequenceSettings ImageSequenceSettings;
    /* 0x0298 */ FWidgetAlignment TextAlignment;
    /* 0x029a */ FWidgetAlignment LoadingIconAlignment;
    /* 0x029c */ float Space;
    /* 0x02a0 */ bool bHideLoadingWidgetWhenCompletes;
};

// Size: 0xe0
struct FSidebarLayoutSettings {
    /* 0x0000 */ bool bIsWidgetAtRight;
    /* 0x0001 */ bool bIsLoadingWidgetAtTop;
    /* 0x0004 */ float Space;
    /* 0x0008 */ uint8_t VerticalAlignment;
    /* 0x0009 */ FWidgetAlignment LoadingWidgetAlignment;
    /* 0x000b */ FWidgetAlignment TipAlignment;
    /* 0x000d */ uint8_t BorderVerticalAlignment;
    /* 0x0010 */ float BorderHorizontalOffset;
    /* 0x0014 */ FMargin BorderPadding;
    /* 0x0030 */ FSlateBrush BorderBackground;
};

// Size: 0xa0
struct FTextAppearance {
    /* 0x0000 */ FSlateColor ColorAndOpacity;
    /* 0x0018 */ FSlateFontInfo Font;
    /* 0x0078 */ FVector2D ShadowOffset;
    /* 0x0088 */ FLinearColor ShadowColorAndOpacity;
    /* 0x0098 */ uint8_t Justification;
};

// Size: 0xc0
struct FThrobberSettings {
    /* 0x0000 */ int32_t NumberOfPieces;
    /* 0x0004 */ bool bAnimateHorizontally;
    /* 0x0005 */ bool bAnimateVertically;
    /* 0x0006 */ bool bAnimateOpacity;
    /* 0x0010 */ FSlateBrush Image;
};

// Size: 0xb8
struct FTipSettings {
    /* 0x0000 */ TArray<FText> TipText;
    /* 0x0010 */ FTextAppearance Appearance;
    /* 0x00b0 */ float TipWrapAt;
    /* 0x00b4 */ bool bSetDisplayTipTextManually;
};

// Size: 0x2
struct FWidgetAlignment {
    /* 0x0000 */ uint8_t HorizontalAlignment;
    /* 0x0001 */ uint8_t VerticalAlignment;
};

// Size: 0xa0
class UAudioAnalyzer : public UObject {
    /* 0x0028 */ UAudioBus* AudioBus;
    /* 0x0038 */ UAudioAnalyzerSubsystem* AudioAnalyzerSubsystem;

    void StartAnalyzing(const UObject* WorldContextObject, UAudioBus* AudioBusToAnalyze);
    void StopAnalyzing(const UObject* WorldContextObject);
};

// Size: 0x28
class UAudioAnalyzerAssetBase : public UObject {
};

// Size: 0x78
class UAudioAnalyzerNRT : public UAudioAnalyzerAssetBase {
    /* 0x0028 */ USoundWave* Sound;
    /* 0x0030 */ float DurationInSeconds;
};

// Size: 0x28
class UAudioAnalyzerNRTSettings : public UAudioAnalyzerAssetBase {
};

// Size: 0x28
class UAudioAnalyzerSettings : public UAudioAnalyzerAssetBase {
};

// Size: 0x50
class UAudioAnalyzerSubsystem : public UEngineSubsystem {
    /* 0x0030 */ TArray<UAudioAnalyzer*> AudioAnalyzers;
};

// Size: 0xb0
class UAudioCapture : public UAudioGenerator {

    bool GetAudioCaptureDeviceInfo(FAudioCaptureDeviceInfo& OutInfo);
    bool IsCapturingAudio();
    void StartCapturingAudio();
    void StopCapturingAudio();
};

// Size: 0x28
class UAudioCaptureBlueprintLibrary : public UBlueprintFunctionLibrary {

    static FString Conv_AudioInputDeviceInfoToString(const FAudioInputDeviceInfo& Info);
    static void GetAvailableAudioInputDevices(const UObject* WorldContextObject, const FDelegate& OnObtainDevicesEvent);
};

// Size: 0x960
class UAudioCaptureComponent : public USynthComponent {
    /* 0x08a0 */ int32_t JitterLatencyFrames;
};

// Size: 0x10
struct FAudioCaptureDeviceInfo {
    /* 0x0000 */ FName DeviceName;
    /* 0x0008 */ int32_t NumInputChannels;
    /* 0x000c */ int32_t SampleRate;
};

// Size: 0x28
class UAudioCaptureFunctionLibrary : public UBlueprintFunctionLibrary {

    static UAudioCapture* CreateAudioCapture();
};

// Size: 0x30
struct FAudioInputDeviceInfo {
    /* 0x0000 */ FString DeviceName;
    /* 0x0010 */ FString DeviceID;
    /* 0x0020 */ int32_t InputChannels;
    /* 0x0024 */ int32_t PreferredSampleRate;
    /* 0x0028 */ bool bSupportsHardwareAEC;
};

// Size: 0x28
class UAudioEndpointSettingsBase : public UObject {
};

// Size: 0xa0
struct FAudioParameter {
    /* 0x0000 */ FName paramName;
    /* 0x0008 */ float FloatParam;
    /* 0x000c */ bool BoolParam;
    /* 0x0010 */ int32_t IntParam;
    /* 0x0018 */ UObject* ObjectParam;
    /* 0x0020 */ FString StringParam;
    /* 0x0030 */ TArray<float> ArrayFloatParam;
    /* 0x0040 */ TArray<bool> ArrayBoolParam;
    /* 0x0050 */ TArray<int32_t> ArrayIntParam;
    /* 0x0060 */ TArray<UObject*> ArrayObjectParam;
    /* 0x0070 */ TArray<FString> ArrayStringParam;
    /* 0x0080 */ EAudioParameterType ParamType;
    /* 0x0084 */ FName TypeName;
};

// Size: 0x28
class IAudioParameterControllerInterface : public UInterface {

    void ResetParameters();
    void SetBoolArrayParameter(FName InName, const TArray<bool>& InValue);
    void SetBoolParameter(FName InName, bool InBool);
    void SetFloatArrayParameter(FName InName, const TArray<float>& InValue);
    void SetFloatParameter(FName InName, float InFloat);
    void SetIntArrayParameter(FName InName, const TArray<int32_t>& InValue);
    void SetIntParameter(FName InName, int32_t inInt);
    void SetObjectArrayParameter(FName InName, const TArray<UObject*>& InValue);
    void SetObjectParameter(FName InName, UObject* InValue);
    void SetParameters_Blueprint(const TArray<FAudioParameter>& InParameters);
    void SetStringArrayParameter(FName InName, const TArray<FString>& InValue);
    void SetStringParameter(FName InName, FString InValue);
    void SetTriggerParameter(FName InName);
};

// Size: 0x28
class UAudioPropertiesSheetAssetBase : public UObject {
};

// Size: 0x28
class IAudioPropertiesSheetAssetUserInterface : public UInterface {
};

// Size: 0x28
class UDummyEndpointSettings : public UAudioEndpointSettingsBase {
};

enum class EAudioParameterType {
    None = 0,
    Boolean = 1,
    Integer = 2,
    Float = 3,
    String = 4,
    Object = 5,
    NoneArray = 6,
    BooleanArray = 7,
    IntegerArray = 8,
    FloatArray = 9,
    StringArray = 10,
    ObjectArray = 11,
    Trigger = 12,
    COUNT = 13,
    EAudioParameterType_MAX = 14,
};

enum class ESoundWaveCloudStreamingPlatformEnableType {
    Inherited = 0,
    Disabled = 1,
    SWC_MultipleValues = 2,
    ESoundWaveCloudStreamingPlatformEnableType_MAX = 3,
};

enum class ESoundWaveCloudStreamingPlatformProjectEnableType {
    Enabled = 0,
    Disabled = 1,
    ESoundWaveCloudStreamingPlatformProjectEnableType_MAX = 2,
};

// Size: 0x28
class UOcclusionPluginSourceSettingsBase : public UObject {
};

// Size: 0x28
class UReverbPluginSourceSettingsBase : public UObject {
};

// Size: 0x8
struct FSoundGeneratorOutput {
    /* 0x0000 */ FName Name;
};

// Size: 0x30
class USoundModulatorBase : public UObject {
};

// Size: 0x1
struct FSoundWaveCloudStreamingPlatformProjectSettings {
    /* 0x0000 */ ESoundWaveCloudStreamingPlatformProjectEnableType EnablementSetting;
};

// Size: 0x1
struct FSoundWaveCloudStreamingPlatformSettings {
    /* 0x0000 */ ESoundWaveCloudStreamingPlatformEnableType EnablementSetting;
};

// Size: 0x30
struct FSoundWaveCuePoint {
    /* 0x0000 */ int32_t CuePointID;
    /* 0x0008 */ FString Label;
    /* 0x0018 */ int64_t FramePosition;
    /* 0x0020 */ int64_t FrameLength;
    /* 0x0028 */ bool bIsLoopRegion;
};

// Size: 0x30
class USoundfieldEffectBase : public UObject {
    /* 0x0028 */ USoundfieldEffectSettingsBase* Settings;
};

// Size: 0x28
class USoundfieldEffectSettingsBase : public UObject {
};

// Size: 0x28
class USoundfieldEncodingSettingsBase : public UObject {
};

// Size: 0x28
class USoundfieldEndpointSettingsBase : public UObject {
};

// Size: 0x28
class USourceDataOverridePluginSourceSettingsBase : public UObject {
};

// Size: 0x28
class USpatializationPluginSourceSettingsBase : public UObject {
};

// Size: 0x28
class UWaveformTransformationBase : public UObject {
};

// Size: 0x38
class UWaveformTransformationChain : public UObject {
    /* 0x0028 */ TArray<UWaveformTransformationBase*> Transformations;
};

// Size: 0x38
class UAudioLinkSettingsAbstract : public UObject {
};

// Size: 0x28
class IAudioLinkBlueprintInterface : public UInterface {

    bool IsLinkPlaying() const;
    void PlayLink(float StartTime);
    void SetLinkSound(USoundBase* NewSound);
    void StopLink();
};

// Size: 0x108
class UAudioBusSubsystem : public UAudioEngineSubsystem {
};

// Size: 0x128
class UAudioDeviceNotificationSubsystem : public UEngineSubsystem {
    /* 0x0038 */ FMulticastInlineDelegate DefaultCaptureDeviceChanged;
    /* 0x0060 */ FMulticastInlineDelegate DefaultRenderDeviceChanged;
    /* 0x0088 */ FMulticastInlineDelegate DeviceAdded;
    /* 0x00b0 */ FMulticastInlineDelegate DeviceRemoved;
    /* 0x00d8 */ FMulticastInlineDelegate DeviceStateChanged;
    /* 0x0100 */ FMulticastInlineDelegate DeviceSwitched;
};

// Size: 0xa8
class UAudioGenerator : public UObject {
};

// Size: 0x28
class UAudioMixerBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void AddMasterSubmixEffect(const UObject* WorldContextObject, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void AddSourceEffectToPresetChain(const UObject* WorldContextObject, USoundEffectSourcePresetChain* PresetChain, FSourceEffectChainEntry Entry);
    static int32_t AddSubmixEffect(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void ClearMasterSubmixEffects(const UObject* WorldContextObject);
    static void ClearSubmixEffectChainOverride(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, float FadeTimeSec);
    static void ClearSubmixEffects(const UObject* WorldContextObject, USoundSubmix* SoundSubmix);
    static FString Conv_AudioOutputDeviceInfoToString(const FAudioOutputDeviceInfo& Info);
    static void GetAvailableAudioOutputDevices(const UObject* WorldContextObject, const FDelegate& OnObtainDevicesEvent);
    static void GetCurrentAudioOutputDeviceName(const UObject* WorldContextObject, const FDelegate& OnObtainCurrentDeviceEvent);
    static void GetMagnitudeForFrequencies(const UObject* WorldContextObject, const TArray<float>& Frequencies, TArray<float>& Magnitudes, USoundSubmix* SubmixToAnalyze);
    static int32_t GetNumberOfEntriesInSourceEffectChain(const UObject* WorldContextObject, USoundEffectSourcePresetChain* PresetChain);
    static void GetPhaseForFrequencies(const UObject* WorldContextObject, const TArray<float>& Frequencies, TArray<float>& Phases, USoundSubmix* SubmixToAnalyze);
    static bool IsAudioBusActive(const UObject* WorldContextObject, UAudioBus* AudioBus);
    static TArray<FSoundSubmixSpectralAnalysisBandSettings> MakeFullSpectrumSpectralAnalysisBandSettings(int32_t InNumBands, float InMinimumFrequency, float InMaximumFrequency, int32_t InAttackTimeMsec, int32_t InReleaseTimeMsec);
    static TArray<FSoundSubmixSpectralAnalysisBandSettings> MakeMusicalSpectralAnalysisBandSettings(int32_t InNumSemitones, EMusicalNoteName InStartingMusicalNote, int32_t InStartingOctave, int32_t InAttackTimeMsec, int32_t InReleaseTimeMsec);
    static TArray<FSoundSubmixSpectralAnalysisBandSettings> MakePresetSpectralAnalysisBandSettings(EAudioSpectrumBandPresetType InBandPresetType, int32_t InNumBands, int32_t InAttackTimeMsec, int32_t InReleaseTimeMsec);
    static void PauseRecordingOutput(const UObject* WorldContextObject, USoundSubmix* SubmixToPause);
    static void PrimeSoundCueForPlayback(USoundCue* SoundCue);
    static void PrimeSoundForPlayback(USoundWave* SoundWave, const FDelegate OnLoadCompletion);
    static void RegisterAudioBusToSubmix(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, UAudioBus* AudioBus);
    static void RemoveMasterSubmixEffect(const UObject* WorldContextObject, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void RemoveSourceEffectFromPresetChain(const UObject* WorldContextObject, USoundEffectSourcePresetChain* PresetChain, int32_t EntryIndex);
    static void RemoveSubmixEffect(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void RemoveSubmixEffectAtIndex(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, int32_t SubmixChainIndex);
    static void RemoveSubmixEffectPreset(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void RemoveSubmixEffectPresetAtIndex(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, int32_t SubmixChainIndex);
    static void ReplaceSoundEffectSubmix(const UObject* WorldContextObject, USoundSubmix* InSoundSubmix, int32_t SubmixChainIndex, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void ReplaceSubmixEffect(const UObject* WorldContextObject, USoundSubmix* InSoundSubmix, int32_t SubmixChainIndex, USoundEffectSubmixPreset* SubmixEffectPreset);
    static void ResumeRecordingOutput(const UObject* WorldContextObject, USoundSubmix* SubmixToPause);
    static void SetBypassSourceEffectChainEntry(const UObject* WorldContextObject, USoundEffectSourcePresetChain* PresetChain, int32_t EntryIndex, bool bBypassed);
    static void SetSubmixEffectChainOverride(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, TArray<USoundEffectSubmixPreset*> SubmixEffectPresetChain, float FadeTimeSec);
    static void StartAnalyzingOutput(const UObject* WorldContextObject, USoundSubmix* SubmixToAnalyze, EFFTSize FFTSize, EFFTPeakInterpolationMethod InterpolationMethod, EFFTWindowType WindowType, float HopSize, EAudioSpectrumType SpectrumType);
    static void StartAudioBus(const UObject* WorldContextObject, UAudioBus* AudioBus);
    static void StartRecordingOutput(const UObject* WorldContextObject, float ExpectedDuration, USoundSubmix* SubmixToRecord);
    static void StopAnalyzingOutput(const UObject* WorldContextObject, USoundSubmix* SubmixToStopAnalyzing);
    static void StopAudioBus(const UObject* WorldContextObject, UAudioBus* AudioBus);
    static USoundWave* StopRecordingOutput(const UObject* WorldContextObject, EAudioRecordingExportType ExportType, FString Name, FString Path, USoundSubmix* SubmixToRecord, USoundWave* ExistingSoundWaveToOverwrite);
    static void SwapAudioOutputDevice(const UObject* WorldContextObject, FString NewDeviceId, const FDelegate& OnCompletedDeviceSwap);
    static float TrimAudioCache(float InMegabytesToFree);
    static void UnregisterAudioBusFromSubmix(const UObject* WorldContextObject, USoundSubmix* SoundSubmix, UAudioBus* AudioBus);
};

// Size: 0x48
struct FAudioOutputDeviceInfo {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString DeviceID;
    /* 0x0020 */ int32_t NumChannels;
    /* 0x0024 */ int32_t SampleRate;
    /* 0x0028 */ EAudioMixerStreamDataFormatType Format;
    /* 0x0030 */ TArray<EAudioMixerChannelType> OutputChannelArray;
    /* 0x0040 */ bool bIsSystemDefault;
    /* 0x0040 */ bool bIsCurrentDevice;
};

enum class EAudioDeviceChangedRole {
    Invalid = 0,
    Console = 1,
    Multimedia = 2,
    Communications = 3,
    Count = 4,
    EAudioDeviceChangedRole_MAX = 5,
};

enum class EAudioDeviceChangedState {
    Invalid = 0,
    Active = 1,
    Disabled = 2,
    NotPresent = 3,
    Unplugged = 4,
    Count = 5,
    EAudioDeviceChangedState_MAX = 6,
};

enum class EAudioMixerChannelType {
    FrontLeft = 0,
    FrontRight = 1,
    FrontCenter = 2,
    LowFrequency = 3,
    BackLeft = 4,
    BackRight = 5,
    FrontLeftOfCenter = 6,
    FrontRightOfCenter = 7,
    BackCenter = 8,
    SideLeft = 9,
    SideRight = 10,
    TopCenter = 11,
    TopFrontLeft = 12,
    TopFrontCenter = 13,
    TopFrontRight = 14,
    TopBackLeft = 15,
    TopBackCenter = 16,
    TopBackRight = 17,
    Unknown = 18,
    ChannelTypeCount = 19,
    DefaultChannel = 0,
    EAudioMixerChannelType_MAX = 20,
};

enum class EAudioMixerStreamDataFormatType {
    Unknown = 0,
    Float = 1,
    Int16 = 2,
    Unsupported = 3,
    EAudioMixerStreamDataFormatType_MAX = 4,
};

enum class EMusicalNoteName {
    C = 0,
    Db = 1,
    D = 2,
    Eb = 3,
    E = 4,
    F = 5,
    Gb = 6,
    G = 7,
    Ab = 8,
    A = 9,
    Bb = 10,
    B = 11,
    EMusicalNoteName_MAX = 12,
};

enum class ERequiredSubmixes {
    Main = 0,
    BaseDefault = 1,
    Reverb = 2,
    EQ = 3,
    Count = 4,
    ERequiredSubmixes_MAX = 5,
};

enum class ESourceManagerRenderThreadPhase {
    Begin = 0,
    PumpMpscCmds = 1,
    PumpCmds = 2,
    ProcessModulators = 3,
    UpdatePendingReleaseData = 4,
    GenerateSrcAudio_WithBusses = 5,
    ComputeBusses = 6,
    GenerateSrcAudio_WithoutBusses = 7,
    UpdateBusses = 8,
    SpatialInterface_OnAllSourcesProcessed = 9,
    SourceDataOverride_OnAllSourcesProcessed = 10,
    UpdateGameThreadCopies = 11,
    Finished = 12,
    ESourceManagerRenderThreadPhase_MAX = 13,
};

enum class ESubmixEffectDynamicsChannelLinkMode {
    Disabled = 0,
    Average = 1,
    Peak = 2,
    Count = 3,
    ESubmixEffectDynamicsChannelLinkMode_MAX = 4,
};

enum class ESubmixEffectDynamicsKeySource {
    Default = 0,
    AudioBus = 1,
    Submix = 2,
    Count = 3,
    ESubmixEffectDynamicsKeySource_MAX = 4,
};

enum class ESubmixEffectDynamicsPeakMode {
    MeanSquared = 0,
    RootMeanSquared = 1,
    Peak = 2,
    Count = 3,
    ESubmixEffectDynamicsPeakMode_MAX = 4,
};

enum class ESubmixEffectDynamicsProcessorType {
    Compressor = 0,
    Limiter = 1,
    Expander = 2,
    Gate = 3,
    UpwardsCompressor = 4,
    Count = 5,
    ESubmixEffectDynamicsProcessorType_MAX = 6,
};

enum class ESwapAudioOutputDeviceResultState {
    Failure = 0,
    Success = 1,
    None = 2,
    ESwapAudioOutputDeviceResultState_MAX = 3,
};

// Size: 0x208
class UQuartzClockHandle : public UObject {

    float GetBeatProgressPercent(EQuartzCommandQuantization QuantizationBoundary, float PhaseOffset, float MsOffset);
    float GetBeatsPerMinute(const UObject* WorldContextObject) const;
    FQuartzTransportTimeStamp GetCurrentTimestamp(const UObject* WorldContextObject);
    float GetDurationOfQuantizationTypeInSeconds(const UObject* WorldContextObject, const EQuartzCommandQuantization& QuantizationType, float Multiplier);
    float GetEstimatedRunTime(const UObject* WorldContextObject);
    float GetMillisecondsPerTick(const UObject* WorldContextObject) const;
    float GetSecondsPerTick(const UObject* WorldContextObject) const;
    float GetThirtySecondNotesPerMinute(const UObject* WorldContextObject) const;
    float GetTicksPerSecond(const UObject* WorldContextObject) const;
    bool IsClockRunning(const UObject* WorldContextObject);
    void NotifyOnQuantizationBoundary(const UObject* WorldContextObject, FQuartzQuantizationBoundary InQuantizationBoundary, const FDelegate& InDelegate, float InMsOffset);
    void PauseClock(const UObject* WorldContextObject, UQuartzClockHandle*& ClockHandle);
    void ResetTransport(const UObject* WorldContextObject, const FDelegate& InDelegate);
    void ResetTransportQuantized(const UObject* WorldContextObject, FQuartzQuantizationBoundary InQuantizationBoundary, const FDelegate& InDelegate, UQuartzClockHandle*& ClockHandle);
    void ResumeClock(const UObject* WorldContextObject, UQuartzClockHandle*& ClockHandle);
    void SetBeatsPerMinute(const UObject* WorldContextObject, const FQuartzQuantizationBoundary& QuantizationBoundary, const FDelegate& Delegate, UQuartzClockHandle*& ClockHandle, float beatsPerMinute);
    void SetMillisecondsPerTick(const UObject* WorldContextObject, const FQuartzQuantizationBoundary& QuantizationBoundary, const FDelegate& Delegate, UQuartzClockHandle*& ClockHandle, float MillisecondsPerTick);
    void SetSecondsPerTick(const UObject* WorldContextObject, const FQuartzQuantizationBoundary& QuantizationBoundary, const FDelegate& Delegate, UQuartzClockHandle*& ClockHandle, float SecondsPerTick);
    void SetThirtySecondNotesPerMinute(const UObject* WorldContextObject, const FQuartzQuantizationBoundary& QuantizationBoundary, const FDelegate& Delegate, UQuartzClockHandle*& ClockHandle, float ThirtySecondsNotesPerMinute);
    void SetTicksPerSecond(const UObject* WorldContextObject, const FQuartzQuantizationBoundary& QuantizationBoundary, const FDelegate& Delegate, UQuartzClockHandle*& ClockHandle, float TicksPerSecond);
    void StartClock(const UObject* WorldContextObject, UQuartzClockHandle*& ClockHandle);
    void StartOtherClock(const UObject* WorldContextObject, FName OtherClockName, FQuartzQuantizationBoundary InQuantizationBoundary, const FDelegate& InDelegate);
    void StopClock(const UObject* WorldContextObject, bool CancelPendingEvents, UQuartzClockHandle*& ClockHandle);
    void SubscribeToAllQuantizationEvents(const UObject* WorldContextObject, const FDelegate& OnQuantizationEvent, UQuartzClockHandle*& ClockHandle);
    void SubscribeToQuantizationEvent(const UObject* WorldContextObject, EQuartzCommandQuantization InQuantizationBoundary, const FDelegate& OnQuantizationEvent, UQuartzClockHandle*& ClockHandle);
    void UnsubscribeFromAllTimeDivisions(const UObject* WorldContextObject, UQuartzClockHandle*& ClockHandle);
    void UnsubscribeFromTimeDivision(const UObject* WorldContextObject, EQuartzCommandQuantization InQuantizationBoundary, UQuartzClockHandle*& ClockHandle);
};

// Size: 0x68
class UQuartzSubsystem : public UTickableWorldSubsystem {

    UQuartzClockHandle* CreateNewClock(const UObject* WorldContextObject, FName ClockName, FQuartzClockSettings InSettings, bool bOverrideSettingsIfClockExists, bool bUseAudioEngineClockManager);
    void DeleteClockByHandle(const UObject* WorldContextObject, UQuartzClockHandle*& InClockHandle);
    void DeleteClockByName(const UObject* WorldContextObject, FName ClockName);
    bool DoesClockExist(const UObject* WorldContextObject, FName ClockName);
    float GetAudioRenderThreadToGameThreadAverageLatency();
    float GetAudioRenderThreadToGameThreadMaxLatency();
    float GetAudioRenderThreadToGameThreadMinLatency();
    FQuartzTransportTimeStamp GetCurrentClockTimestamp(const UObject* WorldContextObject, const FName& InClockName);
    float GetDurationOfQuantizationTypeInSeconds(const UObject* WorldContextObject, FName ClockName, const EQuartzCommandQuantization& QuantizationType, float Multiplier);
    float GetEstimatedClockRunTime(const UObject* WorldContextObject, const FName& InClockName);
    float GetGameThreadToAudioRenderThreadAverageLatency(const UObject* WorldContextObject);
    float GetGameThreadToAudioRenderThreadMaxLatency(const UObject* WorldContextObject);
    float GetGameThreadToAudioRenderThreadMinLatency(const UObject* WorldContextObject);
    UQuartzClockHandle* GetHandleForClock(const UObject* WorldContextObject, FName ClockName);
    float GetRoundTripAverageLatency(const UObject* WorldContextObject);
    float GetRoundTripMaxLatency(const UObject* WorldContextObject);
    float GetRoundTripMinLatency(const UObject* WorldContextObject);
    bool IsClockRunning(const UObject* WorldContextObject, FName ClockName);
    bool IsQuartzEnabled();
    void SetQuartzSubsystemTickableWhenPaused(const bool bInTickableWhenPaused);
};

// Size: 0x438
class UScrubbedSound : public USoundWave {
    /* 0x0430 */ USoundWave* SoundWaveToScrub;

    float GetPlayheadTime() const;
    void SetGrainDurationRange(const FVector2D& InGrainDurationRangeSeconds);
    void SetIsScrubbing(bool bInIsScrubbing);
    void SetIsScrubbingWhileStationary(bool bInScrubWhileStationary);
    void SetPlayheadTime(float InPlayheadTimeSeconds);
    void SetSoundWave(USoundWave* InSoundWave);
};

// Size: 0xc
struct FSubmixEffectDynamicProcessorFilterSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Cutoff;
    /* 0x0008 */ float GainDb;
};

// Size: 0x150
class USubmixEffectDynamicsProcessorPreset : public USoundEffectSubmixPreset {
    /* 0x00f0 */ FSubmixEffectDynamicsProcessorSettings Settings;

    void ResetKey();
    void SetAudioBus(UAudioBus* AudioBus);
    void SetExternalSubmix(USoundSubmix* Submix);
    void SetSettings(const FSubmixEffectDynamicsProcessorSettings& Settings);
};

// Size: 0x60
struct FSubmixEffectDynamicsProcessorSettings {
    /* 0x0000 */ ESubmixEffectDynamicsProcessorType DynamicsProcessorType;
    /* 0x0001 */ ESubmixEffectDynamicsPeakMode PeakMode;
    /* 0x0002 */ ESubmixEffectDynamicsChannelLinkMode LinkMode;
    /* 0x0004 */ float InputGainDb;
    /* 0x0008 */ float ThresholdDb;
    /* 0x000c */ float Ratio;
    /* 0x0010 */ float KneeBandwidthDb;
    /* 0x0014 */ float LookAheadMsec;
    /* 0x0018 */ float AttackTimeMsec;
    /* 0x001c */ float ReleaseTimeMsec;
    /* 0x0020 */ ESubmixEffectDynamicsKeySource KeySource;
    /* 0x0028 */ UAudioBus* ExternalAudioBus;
    /* 0x0030 */ USoundSubmix* ExternalSubmix;
    /* 0x0038 */ bool bChannelLinked;
    /* 0x0038 */ bool bAnalogMode;
    /* 0x0038 */ bool bBypass;
    /* 0x0038 */ bool bKeyAudition;
    /* 0x003c */ float KeyGainDb;
    /* 0x0040 */ float OutputGainDb;
    /* 0x0044 */ FSubmixEffectDynamicProcessorFilterSettings KeyHighshelf;
    /* 0x0050 */ FSubmixEffectDynamicProcessorFilterSettings KeyLowshelf;
};

// Size: 0x10
struct FSubmixEffectEQBand {
    /* 0x0000 */ float Frequency;
    /* 0x0004 */ float Bandwidth;
    /* 0x0008 */ float GainDb;
    /* 0x000c */ bool bEnabled;
};

// Size: 0x110
class USubmixEffectReverbPreset : public USoundEffectSubmixPreset {
    /* 0x00d0 */ FSubmixEffectReverbSettings Settings;

    void SetSettings(const FSubmixEffectReverbSettings& InSettings);
    void SetSettingsWithReverbEffect(const UReverbEffect* InReverbEffect, const float WetLevel, const float DryLevel);
};

// Size: 0x40
struct FSubmixEffectReverbSettings {
    /* 0x0000 */ bool bBypassEarlyReflections;
    /* 0x0004 */ float ReflectionsDelay;
    /* 0x0008 */ float GainHF;
    /* 0x000c */ float ReflectionsGain;
    /* 0x0010 */ bool bBypassLateReflections;
    /* 0x0014 */ float LateDelay;
    /* 0x0018 */ float DecayTime;
    /* 0x001c */ float Density;
    /* 0x0020 */ float Diffusion;
    /* 0x0024 */ float AirAbsorptionGainHF;
    /* 0x0028 */ float DecayHFRatio;
    /* 0x002c */ float LateGain;
    /* 0x0030 */ float Gain;
    /* 0x0034 */ float WetLevel;
    /* 0x0038 */ float DryLevel;
    /* 0x003c */ bool bBypass;
};

// Size: 0xb0
class USubmixEffectSubmixEQPreset : public USoundEffectSubmixPreset {
    /* 0x00a0 */ FSubmixEffectSubmixEQSettings Settings;

    void SetSettings(const FSubmixEffectSubmixEQSettings& InSettings);
};

// Size: 0x10
struct FSubmixEffectSubmixEQSettings {
    /* 0x0000 */ TArray<FSubmixEffectEQBand> EQBands;
};

// Size: 0x28
struct FSwapAudioOutputResult {
    /* 0x0000 */ FString CurrentDeviceId;
    /* 0x0010 */ FString RequestedDeviceId;
    /* 0x0020 */ ESwapAudioOutputDeviceResultState Result;
};

// Size: 0x8a0
class USynthComponent : public USceneComponent {
    /* 0x0240 */ bool bAutoDestroy;
    /* 0x0240 */ bool bStopWhenOwnerDestroyed;
    /* 0x0240 */ bool bAllowSpatialization;
    /* 0x0240 */ bool bOverrideAttenuation;
    /* 0x0244 */ bool bEnableBusSends;
    /* 0x0244 */ bool bEnableBaseSubmix;
    /* 0x0244 */ bool bEnableSubmixSends;
    /* 0x0248 */ USoundAttenuation* AttenuationSettings;
    /* 0x0250 */ FSoundAttenuationSettings AttenuationOverrides;
    /* 0x0620 */ USoundConcurrency* ConcurrencySettings;
    /* 0x0628 */ TSet<USoundConcurrency*> ConcurrencySet;
    /* 0x0678 */ FSoundModulationDefaultRoutingSettings ModulationRouting;
    /* 0x07e0 */ USoundClass* SoundClass;
    /* 0x07e8 */ USoundEffectSourcePresetChain* SourceEffectChain;
    /* 0x07f0 */ USoundSubmixBase* SoundSubmix;
    /* 0x07f8 */ TArray<FSoundSubmixSendInfo> SoundSubmixSends;
    /* 0x0808 */ TArray<FSoundSourceBusSendInfo> BusSends;
    /* 0x0818 */ TArray<FSoundSourceBusSendInfo> PreEffectBusSends;
    /* 0x0828 */ bool bIsUISound;
    /* 0x0828 */ bool bIsPreviewSound;
    /* 0x082c */ int32_t EnvelopeFollowerAttackTime;
    /* 0x0830 */ int32_t EnvelopeFollowerReleaseTime;
    /* 0x0838 */ FMulticastInlineDelegate OnAudioEnvelopeValue;
    /* 0x0868 */ USynthSound* Synth;
    /* 0x0870 */ UAudioComponent* AudioComponent;

    void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, const EAudioFaderCurve FadeCurve) const;
    void FadeIn(float FadeInDuration, float FadeVolumeLevel, float StartTime, const EAudioFaderCurve FadeCurve) const;
    void FadeOut(float FadeOutDuration, float FadeVolumeLevel, const EAudioFaderCurve FadeCurve) const;
    TSet<USoundModulatorBase*> GetModulators(const EModulationDestination destination);
    bool IsPlaying() const;
    void SetAudioBusSendPostEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
    void SetAudioBusSendPreEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
    void SetLowPassFilterEnabled(bool InLowPassFilterEnabled);
    void SetLowPassFilterFrequency(float InLowPassFilterFrequency);
    void SetModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination destination, const EModulationRouting RoutingMethod);
    void SetOutputToBusOnly(bool bInOutputToBusOnly);
    void SetSourceBusSendPostEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
    void SetSourceBusSendPreEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
    void SetSubmixSend(USoundSubmixBase* Submix, float SendLevel);
    void SetVolumeMultiplier(float VolumeMultiplier);
    void Start();
    void Stop();
};

// Size: 0x470
class USynthSound : public USoundWaveProcedural {
    /* 0x0450 */ TWeakObjectPtr<USynthComponent> OwningSynthComponent;
};

enum class ESoundwaveSampleRateSettings {
    Max = 0,
    High = 1,
    Medium = 2,
    Low = 3,
    Min = 4,
};

// Size: 0x10
struct FPlatformRuntimeAudioCompressionOverrides {
    /* 0x0000 */ bool bOverrideCompressionTimes;
    /* 0x0004 */ float DurationThreshold;
    /* 0x0008 */ int32_t MaxNumRandomBranches;
    /* 0x000c */ int32_t SoundCueQualityIndex;
};

// Size: 0x78
class UAudioSynesthesiaNRT : public UAudioAnalyzerNRT {
};

// Size: 0x28
class UAudioSynesthesiaNRTSettings : public UAudioAnalyzerNRTSettings {
};

// Size: 0x28
class UAudioSynesthesiaSettings : public UAudioAnalyzerSettings {
};

// Size: 0xf8
class UConstantQAnalyzer : public UAudioAnalyzer {
    /* 0x00a0 */ UConstantQSettings* Settings;
    /* 0x00a8 */ FMulticastInlineDelegate OnConstantQResults;
    /* 0x00d0 */ FMulticastInlineDelegate OnLatestConstantQResults;

    void GetCenterFrequencies(TArray<float>& OutCenterFrequencies);
    int32_t GetNumCenterFrequencies() const;
};

// Size: 0x80
class UConstantQNRT : public UAudioSynesthesiaNRT {
    /* 0x0078 */ UConstantQNRTSettings* Settings;

    void GetChannelConstantQAtTime(const float InSeconds, const int32_t InChannel, TArray<float>& OutConstantQ) const;
    void GetNormalizedChannelConstantQAtTime(const float InSeconds, const int32_t InChannel, TArray<float>& OutConstantQ) const;
};

// Size: 0x48
class UConstantQNRTSettings : public UAudioSynesthesiaNRTSettings {
    /* 0x0028 */ float StartingFrequency;
    /* 0x002c */ int32_t NumBands;
    /* 0x0030 */ float NumBandsPerOctave;
    /* 0x0034 */ float AnalysisPeriod;
    /* 0x0038 */ bool bDownmixToMono;
    /* 0x0039 */ EConstantQFFTSizeEnum FFTSize;
    /* 0x003a */ EFFTWindowType WindowType;
    /* 0x003b */ EAudioSpectrumType SpectrumType;
    /* 0x003c */ float BandWidthStretch;
    /* 0x0040 */ EConstantQNormalizationEnum CQTNormalization;
    /* 0x0044 */ float NoiseFloorDb;
};

// Size: 0x18
struct FConstantQResults {
    /* 0x0000 */ float TimeSeconds;
    /* 0x0008 */ TArray<float> SpectrumValues;
};

// Size: 0x48
class UConstantQSettings : public UAudioSynesthesiaSettings {
    /* 0x0028 */ float StartingFrequencyHz;
    /* 0x002c */ int32_t NumBands;
    /* 0x0030 */ float NumBandsPerOctave;
    /* 0x0034 */ float AnalysisPeriodInSeconds;
    /* 0x0038 */ bool bDownmixToMono;
    /* 0x0039 */ EConstantQFFTSizeEnum FFTSize;
    /* 0x003a */ EFFTWindowType WindowType;
    /* 0x003b */ EAudioSpectrumType SpectrumType;
    /* 0x003c */ float BandWidthStretch;
    /* 0x0040 */ EConstantQNormalizationEnum CQTNormalization;
    /* 0x0044 */ float NoiseFloorDb;
};

enum class EConstantQFFTSizeEnum {
    Min = 0,
    XXSmall = 1,
    XSmall = 2,
    Small = 3,
    Medium = 4,
    Large = 5,
    XLarge = 6,
    XXLarge = 7,
    Max = 8,
};

enum class EConstantQNormalizationEnum {
    EqualEuclideanNorm = 0,
    EqualEnergy = 1,
    EqualAmplitude = 2,
    EConstantQNormalizationEnum_MAX = 3,
};

enum class ELoudnessCurveTypeEnum {
    A = 0,
    B = 1,
    C = 2,
    D = 3,
    K = 4,
    None = 5,
    ELoudnessCurveTypeEnum_MAX = 6,
};

enum class ELoudnessNRTCurveTypeEnum {
    A = 0,
    B = 1,
    C = 2,
    D = 3,
    K = 4,
    None = 5,
    ELoudnessNRTCurveTypeEnum_MAX = 6,
};

enum class EMeterPeakType {
    MeanSquared = 0,
    RootMeanSquared = 1,
    Peak = 2,
    Count = 3,
    EMeterPeakType_MAX = 4,
};

// Size: 0xe8
class ULoudnessAnalyzer : public UAudioAnalyzer {
    /* 0x00a0 */ ULoudnessSettings* Settings;
    /* 0x00a8 */ FMulticastInlineDelegate OnOverallLoudnessResults;
    /* 0x00b8 */ FMulticastInlineDelegate OnPerChannelLoudnessResults;
    /* 0x00c8 */ FMulticastInlineDelegate OnLatestOverallLoudnessResults;
    /* 0x00d8 */ FMulticastInlineDelegate OnLatestPerChannelLoudnessResults;
};

// Size: 0x80
class ULoudnessNRT : public UAudioSynesthesiaNRT {
    /* 0x0078 */ ULoudnessNRTSettings* Settings;

    void GetChannelLoudnessAtTime(const float InSeconds, const int32_t InChannel, float& OutLoudness) const;
    void GetLoudnessAtTime(const float InSeconds, float& OutLoudness) const;
    void GetNormalizedChannelLoudnessAtTime(const float InSeconds, const int32_t InChannel, float& OutLoudness) const;
    void GetNormalizedLoudnessAtTime(const float InSeconds, float& OutLoudness) const;
};

// Size: 0x40
class ULoudnessNRTSettings : public UAudioSynesthesiaNRTSettings {
    /* 0x0028 */ float AnalysisPeriod;
    /* 0x002c */ float MinimumFrequency;
    /* 0x0030 */ float MaximumFrequency;
    /* 0x0034 */ ELoudnessNRTCurveTypeEnum CurveType;
    /* 0x0038 */ float NoiseFloorDb;
};

// Size: 0x10
struct FLoudnessResults {
    /* 0x0000 */ float Loudness;
    /* 0x0004 */ float NormalizedLoudness;
    /* 0x0008 */ float PerceptualEnergy;
    /* 0x000c */ float TimeSeconds;
};

// Size: 0x40
class ULoudnessSettings : public UAudioSynesthesiaSettings {
    /* 0x0028 */ float AnalysisPeriod;
    /* 0x002c */ float MinimumFrequency;
    /* 0x0030 */ float MaximumFrequency;
    /* 0x0034 */ ELoudnessCurveTypeEnum CurveType;
    /* 0x0038 */ float NoiseFloorDb;
    /* 0x003c */ float ExpectedMaxLoudness;
};

// Size: 0x148
class UMeterAnalyzer : public UAudioAnalyzer {
    /* 0x00a0 */ UMeterSettings* Settings;
    /* 0x00a8 */ FMulticastInlineDelegate OnOverallMeterResults;
    /* 0x00d0 */ FMulticastInlineDelegate OnPerChannelMeterResults;
    /* 0x00f8 */ FMulticastInlineDelegate OnLatestOverallMeterResults;
    /* 0x0120 */ FMulticastInlineDelegate OnLatestPerChannelMeterResults;
};

// Size: 0x14
struct FMeterResults {
    /* 0x0000 */ float TimeSeconds;
    /* 0x0004 */ float MeterValue;
    /* 0x0008 */ float PeakValue;
    /* 0x000c */ int32_t NumSamplesClipping;
    /* 0x0010 */ float ClippingValue;
};

// Size: 0x40
class UMeterSettings : public UAudioSynesthesiaSettings {
    /* 0x0028 */ float AnalysisPeriod;
    /* 0x002c */ EMeterPeakType PeakMode;
    /* 0x0030 */ int32_t MeterAttackTime;
    /* 0x0034 */ int32_t MeterReleaseTime;
    /* 0x0038 */ int32_t PeakHoldTime;
    /* 0x003c */ float ClippingThreshold;
};

// Size: 0x80
class UOnsetNRT : public UAudioSynesthesiaNRT {
    /* 0x0078 */ UOnsetNRTSettings* Settings;

    void GetChannelOnsetsBetweenTimes(const float InStartSeconds, const float InEndSeconds, const int32_t InChannel, TArray<float>& OutOnsetTimestamps, TArray<float>& OutOnsetStrengths) const;
    void GetNormalizedChannelOnsetsBetweenTimes(const float InStartSeconds, const float InEndSeconds, const int32_t InChannel, TArray<float>& OutOnsetTimestamps, TArray<float>& OutOnsetStrengths) const;
};

// Size: 0x40
class UOnsetNRTSettings : public UAudioSynesthesiaNRTSettings {
    /* 0x0028 */ bool bDownmixToMono;
    /* 0x002c */ float GranularityInSeconds;
    /* 0x0030 */ float Sensitivity;
    /* 0x0034 */ float MinimumFrequency;
    /* 0x0038 */ float MaximumFrequency;
};

// Size: 0x30
class USynesthesiaSpectrumAnalysisSettings : public UAudioSynesthesiaSettings {
    /* 0x0028 */ float AnalysisPeriod;
    /* 0x002c */ EFFTSize FFTSize;
    /* 0x002d */ EAudioSpectrumType SpectrumType;
    /* 0x002e */ EFFTWindowType WindowType;
    /* 0x002f */ bool bDownmixToMono;
};

// Size: 0xf8
class USynesthesiaSpectrumAnalyzer : public UAudioAnalyzer {
    /* 0x00a0 */ USynesthesiaSpectrumAnalysisSettings* Settings;
    /* 0x00a8 */ FMulticastInlineDelegate OnSpectrumResults;
    /* 0x00d0 */ FMulticastInlineDelegate OnLatestSpectrumResults;

    void GetCenterFrequencies(const float InSampleRate, TArray<float>& OutCenterFrequencies);
    int32_t GetNumCenterFrequencies() const;
};

// Size: 0x18
struct FSynesthesiaSpectrumResults {
    /* 0x0000 */ float TimeSeconds;
    /* 0x0008 */ TArray<float> SpectrumValues;
};

// Size: 0x360
class UAudioFrequencyRadialSlider : public UAudioRadialSlider {
};

// Size: 0x8c0
class UAudioFrequencySlider : public UAudioSliderBase {
    /* 0x08b0 */ FVector2D OutputRange;
};

// Size: 0x218
class UAudioMaterialButton : public UWidget {
    /* 0x0168 */ FAudioMaterialButtonStyle WidgetStyle;
    /* 0x01f0 */ FMulticastInlineDelegate OnButtonPressedChangedEvent;
    /* 0x0200 */ bool bIsPressed;

    bool GetIsPressed() const;
    void SetIsPressed(bool InPressed);
};

// Size: 0x88
struct FAudioMaterialButtonStyle : public FAudioMaterialWidgetStyle {
    /* 0x0018 */ FLinearColor ButtonMainColor;
    /* 0x0028 */ FLinearColor ButtonMainColorTint_1;
    /* 0x0038 */ FLinearColor ButtonMainColorTint_2;
    /* 0x0048 */ FLinearColor ButtonAccentColor;
    /* 0x0058 */ FLinearColor ButtonShadowColor;
    /* 0x0068 */ FLinearColor ButtonUnpressedOutlineColor;
    /* 0x0078 */ FLinearColor ButtonPressedOutlineColor;
};

// Size: 0xb8
class UAudioMaterialButtonWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FAudioMaterialButtonStyle ButtonStyle;
};

// Size: 0x1e8
class UAudioMaterialEnvelope : public UWidget {
    /* 0x0168 */ FAudioMaterialEnvelopeStyle WidgetStyle;
    /* 0x01b0 */ FAudioMaterialEnvelopeSettings EnvelopeSettings;
};

// Size: 0x24
struct FAudioMaterialEnvelopeSettings {
    /* 0x0000 */ EAudioMaterialEnvelopeType EnvelopeType;
    /* 0x0004 */ float AttackCurve;
    /* 0x0008 */ float AttackValue;
    /* 0x000c */ float AttackTime;
    /* 0x0010 */ float DecayCurve;
    /* 0x0014 */ float DecayTime;
    /* 0x0018 */ float SustainValue;
    /* 0x001c */ float ReleaseCurve;
    /* 0x0020 */ float ReleaseTime;
};

// Size: 0x48
struct FAudioMaterialEnvelopeStyle : public FAudioMaterialWidgetStyle {
    /* 0x0018 */ FLinearColor CurveColor;
    /* 0x0028 */ FLinearColor BackgroundColor;
    /* 0x0038 */ FLinearColor OutlineColor;
};

// Size: 0x370
class UAudioMaterialKnob : public UWidget {
    /* 0x0170 */ FAudioMaterialKnobStyle WidgetStyle;
    /* 0x0330 */ FMulticastInlineDelegate OnKnobValueChanged;
    /* 0x0340 */ float Value;
    /* 0x0344 */ float TuneSpeed;
    /* 0x0348 */ float FineTuneSpeed;
    /* 0x034c */ bool bLocked;
    /* 0x034d */ bool bMouseUsesStep;
    /* 0x0350 */ float StepSize;

    float GetFineTuneSpeed() const;
    bool GetIsLocked() const;
    bool GetMouseUsesStep() const;
    float GetStepSize() const;
    float GetTuneSpeed() const;
    float GetValue();
    void SetFineTuneSpeed(float InValue);
    void SetLocked(bool InLocked);
    void SetMouseUsesStep(bool InUsesStep);
    void SetStepSize(float InValue);
    void SetTuneSpeed(float InValue);
    void SetValue(float InValue);
};

// Size: 0x1c0
struct FAudioMaterialKnobStyle : public FAudioMaterialWidgetStyle {
    /* 0x0018 */ FLinearColor KnobMainColor;
    /* 0x0028 */ FLinearColor KnobAccentColor;
    /* 0x0038 */ FLinearColor KnobShadowColor;
    /* 0x0048 */ FLinearColor KnobSmoothBevelColor;
    /* 0x0058 */ FLinearColor KnobIndicatorDotColor;
    /* 0x0068 */ FLinearColor KnobEdgeFillColor;
    /* 0x0078 */ FLinearColor KnobBarColor;
    /* 0x0088 */ FLinearColor KnobBarShadowColor;
    /* 0x0098 */ FLinearColor KnobBarFillMinColor;
    /* 0x00a8 */ FLinearColor KnobBarFillMidColor;
    /* 0x00b8 */ FLinearColor KnobBarFillMaxColor;
    /* 0x00c8 */ FLinearColor KnobBarFillTintColor;
    /* 0x00e0 */ FAudioTextBoxStyle TextBoxStyle;
};

// Size: 0x1f0
class UAudioMaterialKnobWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FAudioMaterialKnobStyle KnobStyle;
};

// Size: 0x290
class UAudioMaterialMeter : public UWidget {
    /* 0x0168 */ FAudioMaterialMeterStyle WidgetStyle;
    /* 0x0258 */ uint8_t Orientation;
    /* 0x025c */ FDelegate MeterChannelInfoDelegate;
    /* 0x0280 */ TArray<FMeterChannelInfo> MeterChannelInfo;

    TArray<FMeterChannelInfo> GetMeterChannelInfo() const;
    TArray<FMeterChannelInfo> GetMeterChannelInfo__DelegateSignature();
    void SetMeterChannelInfo(const TArray<FMeterChannelInfo>& InMeterChannelInfo);
};

// Size: 0xf0
struct FAudioMaterialMeterStyle : public FAudioMaterialWidgetStyle {
    /* 0x0018 */ FLinearColor MeterFillMinColor;
    /* 0x0028 */ FLinearColor MeterFillMidColor;
    /* 0x0038 */ FLinearColor MeterFillMaxColor;
    /* 0x0048 */ FLinearColor MeterFillBackgroundColor;
    /* 0x0058 */ FVector2D MeterPadding;
    /* 0x0068 */ FVector2D ValueRangeDb;
    /* 0x0078 */ bool bShowScale;
    /* 0x0079 */ bool bScaleSide;
    /* 0x007c */ float ScaleHashOffset;
    /* 0x0080 */ float ScaleHashWidth;
    /* 0x0084 */ float ScaleHashHeight;
    /* 0x0088 */ int32_t DecibelsPerHash;
    /* 0x0090 */ FSlateFontInfo Font;
};

// Size: 0x120
class UAudioMaterialMeterWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FAudioMaterialMeterStyle MeterStyle;
};

// Size: 0x300
class UAudioMaterialSlider : public UWidget {
    /* 0x0170 */ FAudioMaterialSliderStyle WidgetStyle;
    /* 0x02c0 */ FMulticastInlineDelegate OnValueChanged;
    /* 0x02d0 */ float Value;
    /* 0x02d4 */ uint8_t Orientation;
    /* 0x02d8 */ float TuneSpeed;
    /* 0x02dc */ float FineTuneSpeed;
    /* 0x02e0 */ bool bLocked;
    /* 0x02e1 */ bool bMouseUsesStep;
    /* 0x02e4 */ float StepSize;

    float GetFineTuneSpeed() const;
    bool GetIsLocked() const;
    bool GetMouseUsesStep() const;
    float GetStepSize() const;
    float GetTuneSpeed() const;
    float GetValue() const;
    void SetFineTuneSpeed(const float InValue);
    void SetLocked(bool bInLocked);
    void SetMouseUsesStep(bool bInUsesStep);
    void SetStepSize(float InValue);
    void SetTuneSpeed(const float InValue);
    void SetValue(float InValue);
};

// Size: 0x150
struct FAudioMaterialSliderStyle : public FAudioMaterialWidgetStyle {
    /* 0x0018 */ FLinearColor SliderBackgroundColor;
    /* 0x0028 */ FLinearColor SliderBackgroundAccentColor;
    /* 0x0038 */ FLinearColor SliderValueMainColor;
    /* 0x0048 */ FLinearColor SliderHandleMainColor;
    /* 0x0058 */ FLinearColor SliderHandleOutlineColor;
    /* 0x0070 */ FAudioTextBoxStyle TextBoxStyle;
};

// Size: 0x180
class UAudioMaterialSliderWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FAudioMaterialSliderStyle SliderStyle;
};

// Size: 0x18
struct FAudioMaterialWidgetStyle : public FSlateWidgetStyle {
    /* 0x0008 */ UMaterialInterface* Material;
    /* 0x0010 */ FVector2f DesiredSize;
};

// Size: 0x650
class UAudioMeter : public UWidget {
    /* 0x0168 */ TArray<FMeterChannelInfo> MeterChannelInfo;
    /* 0x0178 */ FDelegate MeterChannelInfoDelegate;
    /* 0x0190 */ FAudioMeterStyle WidgetStyle;
    /* 0x05c0 */ uint8_t Orientation;
    /* 0x05c4 */ FLinearColor BackgroundColor;
    /* 0x05d4 */ FLinearColor MeterBackgroundColor;
    /* 0x05e4 */ FLinearColor MeterValueColor;
    /* 0x05f4 */ FLinearColor MeterPeakColor;
    /* 0x0604 */ FLinearColor MeterClippingColor;
    /* 0x0614 */ FLinearColor MeterScaleColor;
    /* 0x0624 */ FLinearColor MeterScaleLabelColor;

    TArray<FMeterChannelInfo> GetMeterChannelInfo() const;
    TArray<FMeterChannelInfo> GetMeterChannelInfo__DelegateSignature();
    void SetBackgroundColor(FLinearColor InValue);
    void SetMeterBackgroundColor(FLinearColor InValue);
    void SetMeterChannelInfo(const TArray<FMeterChannelInfo>& InMeterChannelInfo);
    void SetMeterClippingColor(FLinearColor InValue);
    void SetMeterPeakColor(FLinearColor InValue);
    void SetMeterScaleColor(FLinearColor InValue);
    void SetMeterScaleLabelColor(FLinearColor InValue);
    void SetMeterValueColor(FLinearColor InValue);
};

// Size: 0x68
struct FAudioMeterDefaultColorStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FLinearColor MeterBackgroundColor;
    /* 0x0018 */ FLinearColor MeterValueColor;
    /* 0x0028 */ FLinearColor MeterPeakColor;
    /* 0x0038 */ FLinearColor MeterClippingColor;
    /* 0x0048 */ FLinearColor MeterScaleColor;
    /* 0x0058 */ FLinearColor MeterScaleLabelColor;
};

// Size: 0x430
struct FAudioMeterStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush MeterValueImage;
    /* 0x00c0 */ FSlateBrush BackgroundImage;
    /* 0x0170 */ FSlateBrush MeterBackgroundImage;
    /* 0x0220 */ FSlateBrush MeterValueBackgroundImage;
    /* 0x02d0 */ FSlateBrush MeterPeakImage;
    /* 0x0380 */ FVector2D MeterSize;
    /* 0x0390 */ FVector2D MeterPadding;
    /* 0x03a0 */ float MeterValuePadding;
    /* 0x03a4 */ float PeakValueWidth;
    /* 0x03a8 */ FVector2D ValueRangeDb;
    /* 0x03b8 */ bool bShowScale;
    /* 0x03b9 */ bool bScaleSide;
    /* 0x03bc */ float ScaleHashOffset;
    /* 0x03c0 */ float ScaleHashWidth;
    /* 0x03c4 */ float ScaleHashHeight;
    /* 0x03c8 */ int32_t DecibelsPerHash;
    /* 0x03d0 */ FSlateFontInfo Font;
};

// Size: 0x630
class UAudioOscilloscope : public UWidget {
    /* 0x0170 */ FAudioOscilloscopePanelStyle OscilloscopeStyle;
    /* 0x05b0 */ UAudioBus* AudioBus;
    /* 0x05b8 */ float MaxTimeWindowMs;
    /* 0x05bc */ float TimeWindowMs;
    /* 0x05c0 */ float AnalysisPeriodMs;
    /* 0x05c4 */ bool bShowTimeGrid;
    /* 0x05c5 */ EXAxisLabelsUnit TimeGridLabelsUnit;
    /* 0x05c6 */ bool bShowAmplitudeGrid;
    /* 0x05c7 */ bool bShowAmplitudeLabels;
    /* 0x05c8 */ EYAxisLabelsUnit AmplitudeGridLabelsUnit;
    /* 0x05c9 */ EAudioOscilloscopeTriggerMode TriggerMode;
    /* 0x05cc */ float TriggerThreshold;
    /* 0x05d0 */ EAudioPanelLayoutType PanelLayoutType;
    /* 0x05d4 */ int32_t ChannelToAnalyze;

    bool CanTriggeringBeSet();
    TArray<float> GetOscilloscopeAudioSamples__DelegateSignature();
    void StartProcessing();
    void StopProcessing();
};

// Size: 0x440
struct FAudioOscilloscopePanelStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FFixedSampleSequenceRulerStyle TimeRulerStyle;
    /* 0x0240 */ FSampledSequenceValueGridOverlayStyle ValueGridStyle;
    /* 0x02e0 */ FSampledSequenceViewerStyle WaveViewerStyle;
    /* 0x0420 */ FTriggerThresholdLineStyle TriggerThresholdLineStyle;
};

// Size: 0x360
class UAudioRadialSlider : public UWidget {
    /* 0x0168 */ float Value;
    /* 0x016c */ FDelegate ValueDelegate;
    /* 0x017c */ uint8_t WidgetLayout;
    /* 0x0180 */ FLinearColor CenterBackgroundColor;
    /* 0x0190 */ FLinearColor SliderProgressColor;
    /* 0x01a0 */ FLinearColor SliderBarColor;
    /* 0x01b0 */ FVector2D HandStartEndRatio;
    /* 0x01c0 */ FText UnitsText;
    /* 0x01d0 */ FLinearColor TextLabelBackgroundColor;
    /* 0x01e0 */ bool ShowLabelOnlyOnHover;
    /* 0x01e1 */ bool ShowUnitsText;
    /* 0x01e2 */ bool IsUnitsTextReadOnly;
    /* 0x01e3 */ bool IsValueTextReadOnly;
    /* 0x01e4 */ float SliderThickness;
    /* 0x01e8 */ FVector2D OutputRange;
    /* 0x01f8 */ FMulticastInlineDelegate OnValueChanged;

    float GetOutputValue(const float InSliderValue);
    float GetSliderValue(const float OutputValue);
    void SetCenterBackgroundColor(FLinearColor InValue);
    void SetHandStartEndRatio(const FVector2D InHandStartEndRatio);
    void SetOutputRange(const FVector2D InOutputRange);
    void SetShowLabelOnlyOnHover(const bool bShowLabelOnlyOnHover);
    void SetShowUnitsText(const bool bShowUnitsText);
    void SetSliderBarColor(FLinearColor InValue);
    void SetSliderProgressColor(FLinearColor InValue);
    void SetSliderThickness(const float InThickness);
    void SetTextLabelBackgroundColor(FSlateColor InColor);
    void SetUnitsText(const FText Units);
    void SetUnitsTextReadOnly(const bool bIsReadOnly);
    void SetValueTextReadOnly(const bool bIsReadOnly);
    void SetWidgetLayout(uint8_t InLayout);
};

// Size: 0x140
struct FAudioRadialSliderStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FAudioTextBoxStyle TextBoxStyle;
    /* 0x00f0 */ FSlateColor CenterBackgroundColor;
    /* 0x0104 */ FSlateColor SliderBarColor;
    /* 0x0118 */ FSlateColor SliderProgressColor;
    /* 0x012c */ float LabelPadding;
    /* 0x0130 */ float DefaultSliderRadius;
};

// Size: 0x8c0
class UAudioSlider : public UAudioSliderBase {
    /* 0x08b0 */ TWeakObjectPtr<UCurveFloat> LinToOutputCurve;
    /* 0x08b8 */ TWeakObjectPtr<UCurveFloat> OutputToLinCurve;
};

// Size: 0x8b0
class UAudioSliderBase : public UWidget {
    /* 0x0168 */ float Value;
    /* 0x0170 */ FText UnitsText;
    /* 0x0180 */ FLinearColor TextLabelBackgroundColor;
    /* 0x0190 */ FDelegate TextLabelBackgroundColorDelegate;
    /* 0x01a0 */ bool ShowLabelOnlyOnHover;
    /* 0x01a1 */ bool ShowUnitsText;
    /* 0x01a2 */ bool IsUnitsTextReadOnly;
    /* 0x01a3 */ bool IsValueTextReadOnly;
    /* 0x01a4 */ FDelegate ValueDelegate;
    /* 0x01b4 */ FLinearColor SliderBackgroundColor;
    /* 0x01c4 */ FDelegate SliderBackgroundColorDelegate;
    /* 0x01d4 */ FLinearColor SliderBarColor;
    /* 0x01e4 */ FDelegate SliderBarColorDelegate;
    /* 0x01f4 */ FLinearColor SliderThumbColor;
    /* 0x0204 */ FDelegate SliderThumbColorDelegate;
    /* 0x0214 */ FLinearColor WidgetBackgroundColor;
    /* 0x0224 */ FDelegate WidgetBackgroundColorDelegate;
    /* 0x0234 */ uint8_t Orientation;
    /* 0x0238 */ FMulticastInlineDelegate OnValueChanged;

    float GetLinValue(const float OutputValue);
    float GetOutputValue(const float InSliderValue);
    float GetSliderValue(const float OutputValue);
    void SetShowLabelOnlyOnHover(const bool bShowLabelOnlyOnHover);
    void SetShowUnitsText(const bool bShowUnitsText);
    void SetSliderBackgroundColor(FLinearColor InValue);
    void SetSliderBarColor(FLinearColor InValue);
    void SetSliderThumbColor(FLinearColor InValue);
    void SetTextLabelBackgroundColor(FSlateColor InColor);
    void SetUnitsText(const FText Units);
    void SetUnitsTextReadOnly(const bool bIsReadOnly);
    void SetValueTextReadOnly(const bool bIsReadOnly);
    void SetWidgetBackgroundColor(FLinearColor InValue);
};

// Size: 0x650
struct FAudioSliderStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSliderStyle SliderStyle;
    /* 0x0450 */ FAudioTextBoxStyle TextBoxStyle;
    /* 0x0530 */ FSlateBrush WidgetBackgroundImage;
    /* 0x05e0 */ FSlateColor SliderBackgroundColor;
    /* 0x05f8 */ FVector2D SliderBackgroundSize;
    /* 0x0608 */ float LabelPadding;
    /* 0x060c */ FSlateColor SliderBarColor;
    /* 0x0620 */ FSlateColor SliderThumbColor;
    /* 0x0634 */ FSlateColor WidgetBackgroundColor;
};

// Size: 0x130
struct FAudioSpectrumPlotStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateColor BackgroundColor;
    /* 0x001c */ FSlateColor GridColor;
    /* 0x0030 */ FSlateColor AxisLabelColor;
    /* 0x0048 */ FSlateFontInfo AxisLabelFont;
    /* 0x00a8 */ FSlateColor SpectrumColor;
    /* 0x00bc */ FSlateColor CrosshairColor;
    /* 0x00d0 */ FSlateFontInfo CrosshairLabelFont;
};

// Size: 0xe0
struct FAudioTextBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundImage;
    /* 0x00c0 */ FSlateColor BackgroundColor;
};

// Size: 0x380
class UAudioVectorscope : public UWidget {
    /* 0x0170 */ FAudioVectorscopePanelStyle VectorscopeStyle;
    /* 0x0310 */ UAudioBus* AudioBus;
    /* 0x0318 */ bool bShowGrid;
    /* 0x031c */ int32_t GridDivisions;
    /* 0x0320 */ float MaxDisplayPersistenceMs;
    /* 0x0324 */ float DisplayPersistenceMs;
    /* 0x0328 */ float Scale;
    /* 0x032c */ EAudioPanelLayoutType PanelLayoutType;

    TArray<float> GetVectorscopeAudioSamples__DelegateSignature();
    void StartProcessing();
    void StopProcessing();
};

// Size: 0x1a0
struct FAudioVectorscopePanelStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSampledSequenceValueGridOverlayStyle ValueGridStyle;
    /* 0x00b0 */ FSampledSequenceVectorViewerStyle VectorViewerStyle;
};

// Size: 0x360
class UAudioVolumeRadialSlider : public UAudioRadialSlider {
};

// Size: 0x8c0
class UAudioVolumeSlider : public UAudioSlider {
};

enum class EAudioColorGradient {
    BlackToWhite = 0,
    WhiteToBlack = 1,
    EAudioColorGradient_MAX = 2,
};

enum class EAudioMaterialEnvelopeType {
    AD = 0,
    ADSR = 1,
    EAudioMaterialEnvelopeType_MAX = 2,
};

enum class EAudioOscilloscopeTriggerMode {
    None = 0,
    Rising = 1,
    Falling = 2,
    EAudioOscilloscopeTriggerMode_MAX = 3,
};

enum class EAudioPanelLayoutType {
    Basic = 0,
    Advanced = 1,
    EAudioPanelLayoutType_MAX = 2,
};

enum class EAudioRadialSliderLayout {
    Layout_LabelTop = 0,
    Layout_LabelCenter = 1,
    Layout_LabelBottom = 2,
    Layout_MAX = 3,
};

enum class EAudioSpectrogramFrequencyAxisPixelBucketMode {
    Sample = 0,
    Peak = 1,
    Average = 2,
    EAudioSpectrogramFrequencyAxisPixelBucketMode_MAX = 3,
};

enum class EAudioSpectrogramFrequencyAxisScale {
    Linear = 0,
    Logarithmic = 1,
    EAudioSpectrogramFrequencyAxisScale_MAX = 2,
};

enum class EAudioSpectrumAnalyzerBallistics {
    Analog = 0,
    Digital = 1,
    EAudioSpectrumAnalyzerBallistics_MAX = 2,
};

enum class EAudioSpectrumAnalyzerType {
    FFT = 0,
    CQT = 1,
    EAudioSpectrumAnalyzerType_MAX = 2,
};

enum class EAudioSpectrumPlotFrequencyAxisPixelBucketMode {
    Sample = 0,
    Peak = 1,
    Average = 2,
    EAudioSpectrumPlotFrequencyAxisPixelBucketMode_MAX = 3,
};

enum class EAudioSpectrumPlotFrequencyAxisScale {
    Linear = 0,
    Logarithmic = 1,
    EAudioSpectrumPlotFrequencyAxisScale_MAX = 2,
};

enum class EAudioSpectrumPlotTilt {
    NoTilt = 0,
    Plus1_5dBPerOctave = 1,
    Plus3dBPerOctave = 2,
    Plus4_5dBPerOctave = 3,
    Plus6dBPerOctave = 4,
    EAudioSpectrumPlotTilt_MAX = 5,
};

enum class EAudioUnitsValueType {
    Linear = 0,
    Frequency = 1,
    Volume = 2,
    EAudioUnitsValueType_MAX = 3,
};

enum class EXAxisLabelsUnit {
    Samples = 0,
    Seconds = 1,
    EXAxisLabelsUnit_MAX = 2,
};

enum class EYAxisLabelsUnit {
    Linear = 0,
    Db = 1,
    EYAxisLabelsUnit_MAX = 2,
};

// Size: 0x230
struct FFixedSampleSequenceRulerStyle : public FSlateWidgetStyle {
    /* 0x0008 */ float HandleWidth;
    /* 0x000c */ FSlateColor HandleColor;
    /* 0x0020 */ FSlateBrush HandleBrush;
    /* 0x00d0 */ FSlateColor TicksColor;
    /* 0x00e4 */ FSlateColor TicksTextColor;
    /* 0x00f8 */ FSlateFontInfo TicksTextFont;
    /* 0x0158 */ float TicksTextOffset;
    /* 0x015c */ FSlateColor BackgroundColor;
    /* 0x0170 */ FSlateBrush BackgroundBrush;
    /* 0x0220 */ float DesiredWidth;
    /* 0x0224 */ float DesiredHeight;
};

// Size: 0xc
struct FMeterChannelInfo {
    /* 0x0000 */ float MeterValue;
    /* 0x0004 */ float PeakValue;
    /* 0x0008 */ float ClippingValue;
};

// Size: 0x28
struct FPlayheadOverlayStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateColor PlayheadColor;
    /* 0x001c */ float PlayheadWidth;
    /* 0x0020 */ float DesiredWidth;
    /* 0x0024 */ float DesiredHeight;
};

// Size: 0xa0
struct FSampledSequenceValueGridOverlayStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateColor GridColor;
    /* 0x001c */ float GridThickness;
    /* 0x0020 */ FSlateColor LabelTextColor;
    /* 0x0038 */ FSlateFontInfo LabelTextFont;
    /* 0x0098 */ float DesiredWidth;
    /* 0x009c */ float DesiredHeight;
};

// Size: 0xf0
struct FSampledSequenceVectorViewerStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateColor BackgroundColor;
    /* 0x0020 */ FSlateBrush BackgroundBrush;
    /* 0x00d0 */ FLinearColor LineColor;
    /* 0x00e0 */ float LineThickness;
};

// Size: 0x140
struct FSampledSequenceViewerStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateColor SequenceColor;
    /* 0x001c */ float SequenceLineThickness;
    /* 0x0020 */ FSlateColor MajorGridLineColor;
    /* 0x0034 */ FSlateColor MinorGridLineColor;
    /* 0x0048 */ FSlateColor ZeroCrossingLineColor;
    /* 0x005c */ float ZeroCrossingLineThickness;
    /* 0x0060 */ float SampleMarkersSize;
    /* 0x0064 */ FSlateColor SequenceBackgroundColor;
    /* 0x0080 */ FSlateBrush BackgroundBrush;
    /* 0x0130 */ float DesiredWidth;
    /* 0x0134 */ float DesiredHeight;
};

// Size: 0x7
struct FSpectrogramRackUnitSettings {
    /* 0x0000 */ EAudioSpectrumAnalyzerType AnalyzerType;
    /* 0x0001 */ EFFTSize FFTAnalyzerFFTSize;
    /* 0x0002 */ EConstantQFFTSizeEnum CQTAnalyzerFFTSize;
    /* 0x0003 */ EAudioSpectrogramFrequencyAxisPixelBucketMode PixelPlotMode;
    /* 0x0004 */ EAudioSpectrogramFrequencyAxisScale FrequencyScale;
    /* 0x0005 */ EAudioColorGradient ColorMap;
    /* 0x0006 */ uint8_t Orientation;
};

// Size: 0x9
struct FSpectrumAnalyzerRackUnitSettings {
    /* 0x0000 */ EAudioSpectrumAnalyzerBallistics Ballistics;
    /* 0x0001 */ EAudioSpectrumAnalyzerType AnalyzerType;
    /* 0x0002 */ EFFTSize FFTAnalyzerFFTSize;
    /* 0x0003 */ EConstantQFFTSizeEnum CQTAnalyzerFFTSize;
    /* 0x0004 */ EAudioSpectrumPlotTilt TiltSpectrum;
    /* 0x0005 */ EAudioSpectrumPlotFrequencyAxisPixelBucketMode PixelPlotMode;
    /* 0x0006 */ EAudioSpectrumPlotFrequencyAxisScale FrequencyScale;
    /* 0x0007 */ bool bDisplayFrequencyAxisLabels;
    /* 0x0008 */ bool bDisplaySoundLevelAxisLabels;
};

// Size: 0x18
struct FTriggerThresholdLineStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FLinearColor LineColor;
};

// Size: 0x28
class UAutomationUtilsBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void TakeGameplayAutomationScreenshot(const FString ScreenshotName, float MaxGlobalError, float MaxLocalError, FString MapNameOverride);
};

// Size: 0x120
class UBuildPatchManifest : public UObject {
    /* 0x0028 */ uint8_t ManifestFileVersion;
    /* 0x0029 */ bool bIsFileData;
    /* 0x002c */ uint32_t AppID;
    /* 0x0030 */ FString AppName;
    /* 0x0040 */ FString BuildVersion;
    /* 0x0050 */ FString LaunchExe;
    /* 0x0060 */ FString LaunchCommand;
    /* 0x0070 */ TSet<FString> PrereqIds;
    /* 0x00c0 */ FString PrereqName;
    /* 0x00d0 */ FString PrereqPath;
    /* 0x00e0 */ FString PrereqArgs;
    /* 0x00f0 */ TArray<FFileManifestData> FileManifestList;
    /* 0x0100 */ TArray<FChunkInfoData> ChunkList;
    /* 0x0110 */ TArray<FCustomFieldData> CustomFields;
};

// Size: 0x40
struct FChunkInfoData {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ uint64_t Hash;
    /* 0x0018 */ FSHAHashData ShaHash;
    /* 0x0030 */ int64_t FileSize;
    /* 0x0038 */ uint8_t GroupNumber;
};

// Size: 0x18
struct FChunkPartData {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ uint32_t Offset;
    /* 0x0014 */ uint32_t Size;
};

// Size: 0x20
struct FCustomFieldData {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ FString Value;
};

// Size: 0x68
struct FFileManifestData {
    /* 0x0000 */ FString Filename;
    /* 0x0010 */ FSHAHashData FileHash;
    /* 0x0028 */ TArray<FChunkPartData> FileChunkParts;
    /* 0x0038 */ TArray<FString> InstallTags;
    /* 0x0048 */ bool bIsUnixExecutable;
    /* 0x0050 */ FString SymlinkTarget;
    /* 0x0060 */ bool bIsReadOnly;
    /* 0x0061 */ bool bIsCompressed;
};

// Size: 0x14
struct FSHAHashData {
    /* 0x0000 */ uint8_t Hash[20];
};

// Size: 0x2b0
class ACableActor : public AActor {
    /* 0x02a8 */ UCableComponent* CableComponent;
};

// Size: 0x740
class UCableComponent : public UMeshComponent {
    /* 0x0568 */ bool bAttachStart;
    /* 0x0569 */ bool bAttachEnd;
    /* 0x0570 */ FComponentReference AttachEndTo;
    /* 0x0598 */ FName AttachEndToSocketName;
    /* 0x05a0 */ FVector EndLocation;
    /* 0x05b8 */ float CableLength;
    /* 0x05bc */ int32_t NumSegments;
    /* 0x05c0 */ float SubstepTime;
    /* 0x05c4 */ int32_t SolverIterations;
    /* 0x05c8 */ bool bEnableStiffness;
    /* 0x05c9 */ bool bUseSubstepping;
    /* 0x05ca */ bool bSkipCableUpdateWhenNotVisible;
    /* 0x05cb */ bool bSkipCableUpdateWhenNotOwnerRecentlyRendered;
    /* 0x05cc */ bool bEnableCollision;
    /* 0x05d0 */ float CollisionFriction;
    /* 0x05d8 */ FVector CableForce;
    /* 0x05f0 */ float CableGravityScale;
    /* 0x05f4 */ float CableWidth;
    /* 0x05f8 */ int32_t NumSides;
    /* 0x05fc */ float TileMaterial;
    /* 0x0600 */ bool bResetAfterTeleport;
    /* 0x0604 */ float TeleportDistanceThreshold;
    /* 0x0608 */ float TeleportRotationThreshold;
    /* 0x060c */ bool bTeleportAfterReattach;

    AActor* GetAttachedActor() const;
    USceneComponent* GetAttachedComponent() const;
    void GetCableParticleLocations(TArray<FVector>& Locations) const;
    void SetAttachEndTo(AActor* Actor, FName ComponentProperty, FName SocketName);
    void SetAttachEndToComponent(USceneComponent* Component, FName SocketName);
};

// Size: 0x38
struct FAnamorphicDistortionParameters {
    /* 0x0000 */ float PixelAspect;
    /* 0x0004 */ float CX02;
    /* 0x0008 */ float CX04;
    /* 0x000c */ float CX22;
    /* 0x0010 */ float CX24;
    /* 0x0014 */ float CX44;
    /* 0x0018 */ float CY02;
    /* 0x001c */ float CY04;
    /* 0x0020 */ float CY22;
    /* 0x0024 */ float CY24;
    /* 0x0028 */ float CY44;
    /* 0x002c */ float SqueezeX;
    /* 0x0030 */ float SqueezeY;
    /* 0x0034 */ float LensRotation;
};

// Size: 0x108
class UAnamorphicLensDistortionModelHandler : public ULensDistortionModelHandlerBase {
};

// Size: 0x28
class UAnamorphicLensModel : public ULensModel {
};

// Size: 0x1
struct FBaseFocusCurve {
};

// Size: 0x8
struct FBaseFocusPoint {
};

// Size: 0x10
struct FBaseLensTable {
    /* 0x0008 */ TWeakObjectPtr<ULensFile> LensFile;
};

// Size: 0x3
struct FCalibratedMapFormat {
    /* 0x0000 */ ECalibratedMapPixelOrigin PixelOrigin;
    /* 0x0001 */ ECalibratedMapChannels UndistortionChannels;
    /* 0x0002 */ ECalibratedMapChannels DistortionChannels;
};

// Size: 0x650
class UCalibrationPointComponent : public UProceduralMeshComponent {
    /* 0x05e8 */ TMap<FString, FVector> SubPoints;
    /* 0x0638 */ bool bVisualizePointsInEditor;
    /* 0x063c */ float PointVisualizationScale;
    /* 0x0640 */ uint8_t VisualizationShape;

    void GetNamespacedPointNames(TArray<FString>& OutNamespacedNames) const;
    bool GetWorldLocation(FString InPointName, FVector& OutLocation) const;
    bool NamespacedSubpointName(FString InSubpointName, FString& OutNamespacedName) const;
    void RebuildVertices();
};

// Size: 0x300
class ACameraCalibrationCheckerboard : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UCalibrationPointComponent* TopLeft;
    /* 0x02b8 */ UCalibrationPointComponent* TopRight;
    /* 0x02c0 */ UCalibrationPointComponent* BottomLeft;
    /* 0x02c8 */ UCalibrationPointComponent* BottomRight;
    /* 0x02d0 */ UCalibrationPointComponent* Center;
    /* 0x02d8 */ int32_t NumCornerRows;
    /* 0x02dc */ int32_t NumCornerCols;
    /* 0x02e0 */ float SquareSideLength;
    /* 0x02e4 */ float Thickness;
    /* 0x02e8 */ UStaticMesh* CubeMesh;
    /* 0x02f0 */ UMaterialInterface* OddCubeMaterial;
    /* 0x02f8 */ UMaterialInterface* EvenCubeMaterial;

    void Rebuild();
};

// Size: 0x38
class UCameraCalibrationEditorSettings : public UDeveloperSettings {
};

// Size: 0x170
class UCameraCalibrationSettings : public UDeveloperSettings {
    /* 0x0038 */ TSoftObjectPtr<ULensFile> StartupLensFile;
    /* 0x0060 */ FIntPoint DisplacementMapResolution;
    /* 0x0068 */ float CalibrationInputTolerance;
    /* 0x006c */ float CheckerboardDetectionTimeout;
    /* 0x0070 */ TMap<UClass*, TSoftObjectPtr<UMaterialInterface>> DefaultUndistortionDisplacementMaterials;
    /* 0x00c0 */ TMap<UClass*, TSoftObjectPtr<UMaterialInterface>> DefaultDistortionDisplacementMaterials;
    /* 0x0110 */ TMap<UClass*, TSoftObjectPtr<UMaterialInterface>> DefaultDistortionMaterials;
    /* 0x0160 */ bool bEnableCalibrationDatasetImportExport;
};

// Size: 0x28
class UCameraCalibrationStep : public UObject {
};

// Size: 0x230
class UCameraCalibrationSubsystem : public UEngineSubsystem {
    /* 0x0030 */ ULensFile* DefaultLensFile;
    /* 0x0038 */ TMap<FName, UClass*> LensModelMap;
    /* 0x0088 */ TMap<FName, UClass*> CameraNodalOffsetAlgosMap;
    /* 0x00d8 */ TMap<FName, UClass*> CameraImageCenterAlgosMap;
    /* 0x0128 */ TMap<FName, UClass*> CameraCalibrationStepsMap;

    ULensDistortionModelHandlerBase* FindDistortionModelHandler(FDistortionHandlerPicker& DistortionHandlerPicker, bool bUpdatePicker) const;
    ULensDistortionModelHandlerBase* FindOrCreateDistortionModelHandler(FDistortionHandlerPicker& DistortionHandlerPicker, const UClass* LensModelClass);
    UClass* GetCameraCalibrationStep(FName Name) const;
    TArray<FName> GetCameraCalibrationSteps() const;
    UClass* GetCameraImageCenterAlgo(FName Name) const;
    TArray<FName> GetCameraImageCenterAlgos() const;
    UClass* GetCameraNodalOffsetAlgo(FName Name) const;
    TArray<FName> GetCameraNodalOffsetAlgos() const;
    ULensFile* GetDefaultLensFile() const;
    TArray<ULensDistortionModelHandlerBase*> GetDistortionModelHandlers(UCineCameraComponent* Component);
    ULensFile* GetLensFile(const FLensFilePicker& Picker) const;
    UMaterialInterface* GetOverlayMaterial(const FName& OverlayName) const;
    TArray<FName> GetOverlayMaterialNames() const;
    UClass* GetRegisteredLensModel(FName ModelName) const;
    void SetDefaultLensFile(ULensFile* NewDefaultLensFile);
    void UnregisterDistortionModelHandler(UCineCameraComponent* Component, ULensDistortionModelHandlerBase* handler);
};

// Size: 0x10
struct FCameraFeedInfo {
    /* 0x0000 */ FIntPoint Dimensions;
    /* 0x0008 */ float AspectRatio;
};

// Size: 0x30
class UCameraImageCenterAlgo : public UObject {
};

// Size: 0x28
class UCameraLensDistortionAlgo : public UObject {
};

// Size: 0x28
class UCameraNodalOffsetAlgo : public UObject {
};

// Size: 0x8
struct FDataTablePointInfoBase {
    /* 0x0000 */ float focus;
    /* 0x0004 */ float Zoom;
};

// Size: 0x30
struct FDerivedDistortionData {
    /* 0x0000 */ FDistortionData DistortionData;
    /* 0x0018 */ UTextureRenderTarget2D* UndistortionDisplacementMap;
    /* 0x0020 */ UTextureRenderTarget2D* DistortionDisplacementMap;
};

// Size: 0xc0
struct FDistortionCalibrationResult {
    /* 0x0000 */ float EvaluatedFocus;
    /* 0x0004 */ float EvaluatedZoom;
    /* 0x0008 */ double ReprojectionError;
    /* 0x0010 */ FFocalLengthInfo FocalLength;
    /* 0x0020 */ FImageCenterInfo ImageCenter;
    /* 0x0030 */ TArray<FTransform> CameraPoses;
    /* 0x0040 */ FNodalPointOffset NodalOffset;
    /* 0x0080 */ FDistortionInfo Parameters;
    /* 0x0090 */ FSTMapInfo STMap;
    /* 0x00a0 */ FString STMapFullPath;
    /* 0x00b0 */ FText ErrorMessage;
};

// Size: 0x18
struct FDistortionData {
    /* 0x0000 */ TArray<FVector2D> DistortedUVs;
    /* 0x0010 */ float OverscanFactor;
};

// Size: 0x88
struct FDistortionFocusCurve : public FBaseFocusCurve {
    /* 0x0000 */ FRichCurve MapBlendingCurve;
    /* 0x0080 */ float Zoom;
};

// Size: 0xa0
struct FDistortionFocusPoint : public FBaseFocusPoint {
    /* 0x0008 */ float focus;
    /* 0x0010 */ FRichCurve MapBlendingCurve;
    /* 0x0090 */ TArray<FDistortionZoomPoint> ZoomPoints;
};

// Size: 0x28
struct FDistortionHandlerPicker {
    /* 0x0000 */ UCineCameraComponent* TargetCameraComponent;
    /* 0x0008 */ FGuid DistortionProducerID;
    /* 0x0018 */ FString HandlerDisplayName;
};

// Size: 0x10
struct FDistortionInfo {
    /* 0x0000 */ TArray<float> Parameters;
};

// Size: 0x18
struct FDistortionPointInfo : public FDataTablePointInfoBase {
    /* 0x0008 */ FDistortionInfo DistortionInfo;
};

// Size: 0x30
struct FDistortionTable : public FBaseLensTable {
    /* 0x0010 */ TArray<FDistortionFocusPoint> FocusPoints;
    /* 0x0020 */ TArray<FDistortionFocusCurve> FocusCurves;
};

// Size: 0x18
struct FDistortionZoomPoint {
    /* 0x0000 */ float Zoom;
    /* 0x0008 */ FDistortionInfo DistortionInfo;
};

enum class ECalibratedMapChannels {
    RG = 0,
    BA = 1,
    None = 2,
    MAX = 3,
};

enum class ECalibratedMapPixelOrigin {
    TopLeft = 0,
    BottomLeft = 1,
    MAX = 2,
};

enum class ECalibrationPointVisualization {
    CalibrationPointVisualizationCube = 0,
    CalibrationPointVisualizationPyramid = 1,
    ECalibrationPointVisualization_MAX = 2,
};

enum class ELensDataCategory {
    Focus = 0,
    Iris = 1,
    Zoom = 2,
    Distortion = 3,
    ImageCenter = 4,
    STMap = 5,
    NodalOffset = 6,
    ELensDataCategory_MAX = 7,
};

enum class ELensDataMode {
    Parameters = 0,
    STMap = 1,
    ELensDataMode_MAX = 2,
};

enum class ELensDisplayUnit {
    Millimeters = 0,
    Pixels = 1,
    Normalized = 2,
    ELensDisplayUnit_MAX = 3,
};

// Size: 0x100
struct FEncodersTable {
    /* 0x0000 */ FRichCurve focus;
    /* 0x0080 */ FRichCurve Iris;
};

// Size: 0x108
struct FFocalLengthFocusCurve : public FBaseFocusCurve {
    /* 0x0000 */ FRichCurve Fx;
    /* 0x0080 */ FRichCurve Fy;
    /* 0x0100 */ float Zoom;
};

// Size: 0x120
struct FFocalLengthFocusPoint : public FBaseFocusPoint {
    /* 0x0008 */ float focus;
    /* 0x0010 */ FRichCurve Fx;
    /* 0x0090 */ FRichCurve Fy;
    /* 0x0110 */ TArray<FFocalLengthZoomPoint> ZoomPoints;
};

// Size: 0x10
struct FFocalLengthInfo {
    /* 0x0000 */ FVector2D FxFy;
};

// Size: 0x18
struct FFocalLengthPointInfo : public FDataTablePointInfoBase {
    /* 0x0008 */ FFocalLengthInfo FocalLengthInfo;
};

// Size: 0x30
struct FFocalLengthTable : public FBaseLensTable {
    /* 0x0010 */ TArray<FFocalLengthFocusPoint> FocusPoints;
    /* 0x0020 */ TArray<FFocalLengthFocusCurve> FocusCurves;
};

// Size: 0x20
struct FFocalLengthZoomPoint {
    /* 0x0000 */ float Zoom;
    /* 0x0008 */ FFocalLengthInfo FocalLengthInfo;
    /* 0x0018 */ bool bIsCalibrationPoint;
};

// Size: 0x108
struct FImageCenterFocusCurve : public FBaseFocusCurve {
    /* 0x0000 */ FRichCurve Cx;
    /* 0x0080 */ FRichCurve Cy;
    /* 0x0100 */ float Zoom;
};

// Size: 0x110
struct FImageCenterFocusPoint : public FBaseFocusPoint {
    /* 0x0008 */ float focus;
    /* 0x0010 */ FRichCurve Cx;
    /* 0x0090 */ FRichCurve Cy;
};

// Size: 0x10
struct FImageCenterInfo {
    /* 0x0000 */ FVector2D PrincipalPoint;
};

// Size: 0x18
struct FImageCenterPointInfo : public FDataTablePointInfoBase {
    /* 0x0008 */ FImageCenterInfo ImageCenterInfo;
};

// Size: 0x30
struct FImageCenterTable : public FBaseLensTable {
    /* 0x0010 */ TArray<FImageCenterFocusPoint> FocusPoints;
    /* 0x0020 */ TArray<FImageCenterFocusCurve> FocusCurves;
};

// Size: 0x1c
struct FLensDataCategoryEditorColor {
    /* 0x0000 */ FColor focus;
    /* 0x0004 */ FColor Iris;
    /* 0x0008 */ FColor Zoom;
    /* 0x000c */ FColor Distortion;
    /* 0x0010 */ FColor ImageCenter;
    /* 0x0014 */ FColor STMap;
    /* 0x0018 */ FColor NodalOffset;
};

// Size: 0xd0
class ULensDistortionModelHandlerBase : public UObject {
    /* 0x0028 */ UClass* LensModelClass;
    /* 0x0030 */ UMaterialInstanceDynamic* DistortionPostProcessMID;
    /* 0x0038 */ FLensDistortionState CurrentState;
    /* 0x0068 */ FCameraFilmbackSettings CameraFilmback;
    /* 0x0080 */ FString DisplayName;
    /* 0x0090 */ float OverscanFactor;
    /* 0x0098 */ UMaterialInstanceDynamic* UndistortionDisplacementMapMID;
    /* 0x00a0 */ UMaterialInstanceDynamic* DistortionDisplacementMapMID;
    /* 0x00a8 */ UTextureRenderTarget2D* UndistortionDisplacementMapRT;
    /* 0x00b0 */ UTextureRenderTarget2D* DistortionDisplacementMapRT;
    /* 0x00b8 */ FGuid DistortionProducerID;

    UTextureRenderTarget2D* GetDistortionDisplacementMap() const;
    UTextureRenderTarget2D* GetUndistortionDisplacementMap() const;
    bool IsModelSupported(const UClass*& ModelToSupport) const;
    void SetDistortionState(const FLensDistortionState& InNewState);
};

// Size: 0x30
struct FLensDistortionState {
    /* 0x0000 */ FDistortionInfo DistortionInfo;
    /* 0x0010 */ FFocalLengthInfo FocalLengthInfo;
    /* 0x0020 */ FImageCenterInfo ImageCenter;
};

// Size: 0x308
class ULensFile : public UObject {
    /* 0x0030 */ FLensInfo LensInfo;
    /* 0x0078 */ ELensDataMode DataMode;
    /* 0x0080 */ TMap<FString, FString> UserMetadata;
    /* 0x00d0 */ FEncodersTable EncodersTable;
    /* 0x01d0 */ FDistortionTable DistortionTable;
    /* 0x0200 */ FFocalLengthTable FocalLengthTable;
    /* 0x0230 */ FImageCenterTable ImageCenterTable;
    /* 0x0260 */ FNodalOffsetTable NodalOffsetTable;
    /* 0x0290 */ FSTMapTable STMapTable;
    /* 0x02d0 */ TArray<UTextureRenderTarget2D*> UndistortionDisplacementMapHolders;
    /* 0x02e0 */ TArray<UTextureRenderTarget2D*> DistortionDisplacementMapHolders;

    void AddDistortionPoint(float NewFocus, float NewZoom, const FDistortionInfo& NewPoint, const FFocalLengthInfo& NewFocalLength);
    void AddFocalLengthPoint(float NewFocus, float NewZoom, const FFocalLengthInfo& NewFocalLength);
    void AddImageCenterPoint(float NewFocus, float NewZoom, const FImageCenterInfo& NewPoint);
    void AddNodalOffsetPoint(float NewFocus, float NewZoom, const FNodalPointOffset& NewPoint);
    void AddSTMapPoint(float NewFocus, float NewZoom, const FSTMapInfo& NewPoint);
    void ChangeFocusPoint(ELensDataCategory InDataCategory, float InExistingFocus, float InNewFocus);
    void ChangeZoomPoint(ELensDataCategory InDataCategory, float InFocus, float InExistingZoom, float InNewZoom);
    void ClearAll();
    void ClearData(ELensDataCategory InDataCategory);
    bool EvaluateDistortionData(float InFocus, float InZoom, FVector2D InFilmback, ULensDistortionModelHandlerBase* InLensHandler) const;
    bool EvaluateDistortionParameters(float InFocus, float InZoom, FDistortionInfo& OutEvaluatedValue) const;
    bool EvaluateFocalLength(float InFocus, float InZoom, FFocalLengthInfo& OutEvaluatedValue) const;
    bool EvaluateImageCenterParameters(float InFocus, float InZoom, FImageCenterInfo& OutEvaluatedValue) const;
    bool EvaluateNodalPointOffset(float InFocus, float InZoom, FNodalPointOffset& OutEvaluatedValue) const;
    float EvaluateNormalizedFocus(float InNormalizedValue) const;
    float EvaluateNormalizedIris(float InNormalizedValue) const;
    bool GetDistortionPoint(float InFocus, float InZoom, FDistortionInfo& OutDistortionInfo) const;
    TArray<FDistortionPointInfo> GetDistortionPoints() const;
    bool GetFocalLengthPoint(float InFocus, float InZoom, FFocalLengthInfo& OutFocalLengthInfo) const;
    TArray<FFocalLengthPointInfo> GetFocalLengthPoints() const;
    bool GetImageCenterPoint(float InFocus, float InZoom, FImageCenterInfo& OutImageCenterInfo) const;
    TArray<FImageCenterPointInfo> GetImageCenterPoints() const;
    bool GetNodalOffsetPoint(float InFocus, float InZoom, FNodalPointOffset& OutNodalPointOffset) const;
    TArray<FNodalOffsetPointInfo> GetNodalOffsetPoints() const;
    bool GetSTMapPoint(float InFocus, float InZoom, FSTMapInfo& OutSTMapInfo) const;
    TArray<FSTMapPointInfo> GetSTMapPoints() const;
    int32_t GetTotalPointNum(ELensDataCategory InDataCategory) const;
    bool HasFocusEncoderMapping() const;
    bool HasFocusPoint(ELensDataCategory InDataCategory, float InFocus) const;
    bool HasIrisEncoderMapping() const;
    bool HasSamples(ELensDataCategory InDataCategory) const;
    bool HasZoomPoint(ELensDataCategory InDataCategory, float InFocus, float InZoom);
    void MergeFocusPoint(ELensDataCategory InDataCategory, float InSrcFocus, float InDestFocus, bool bReplaceExistingZoomPoints);
    void RemoveFocusPoint(ELensDataCategory InDataCategory, float InFocus);
    void RemoveZoomPoint(ELensDataCategory InDataCategory, float InFocus, float InZoom);
};

// Size: 0x24
struct FLensFileEvaluationInputs {
    /* 0x0000 */ float focus;
    /* 0x0004 */ float Iris;
    /* 0x0008 */ float Zoom;
    /* 0x000c */ FCameraFilmbackSettings Filmback;
    /* 0x0020 */ bool bIsValid;
};

// Size: 0x10
struct FLensFilePicker {
    /* 0x0000 */ bool bUseDefaultLensFile;
    /* 0x0008 */ ULensFile* LensFile;
};

// Size: 0x48
struct FLensInfo {
    /* 0x0000 */ FString LensModelName;
    /* 0x0010 */ FString LensSerialNumber;
    /* 0x0020 */ UClass* LensModel;
    /* 0x0028 */ FVector2D SensorDimensions;
    /* 0x0038 */ FIntPoint ImageDimensions;
    /* 0x0040 */ float SqueezeFactor;
};

// Size: 0x28
class ULensModel : public UObject {
};

// Size: 0x308
struct FNodalOffsetFocusCurve : public FBaseFocusCurve {
    /* 0x0000 */ FRichCurve LocationOffset[3];
    /* 0x0180 */ FRichCurve RotationOffset[3];
    /* 0x0300 */ float Zoom;
};

// Size: 0x310
struct FNodalOffsetFocusPoint : public FBaseFocusPoint {
    /* 0x0008 */ float focus;
    /* 0x0010 */ FRichCurve LocationOffset[3];
    /* 0x0190 */ FRichCurve RotationOffset[3];
};

// Size: 0x50
struct FNodalOffsetPointInfo : public FDataTablePointInfoBase {
    /* 0x0010 */ FNodalPointOffset NodalPointOffset;
};

// Size: 0x30
struct FNodalOffsetTable : public FBaseLensTable {
    /* 0x0010 */ TArray<FNodalOffsetFocusPoint> FocusPoints;
    /* 0x0020 */ TArray<FNodalOffsetFocusCurve> FocusCurves;
};

// Size: 0x40
struct FNodalPointOffset {
    /* 0x0000 */ FVector LocationOffset;
    /* 0x0020 */ FQuat RotationOffset;
};

// Size: 0x88
struct FSTMapFocusCurve : public FBaseFocusCurve {
    /* 0x0000 */ FRichCurve MapBlendingCurve;
    /* 0x0080 */ float Zoom;
};

// Size: 0xa0
struct FSTMapFocusPoint : public FBaseFocusPoint {
    /* 0x0008 */ float focus;
    /* 0x0010 */ FRichCurve MapBlendingCurve;
    /* 0x0090 */ TArray<FSTMapZoomPoint> ZoomPoints;
};

// Size: 0x10
struct FSTMapInfo {
    /* 0x0000 */ UTexture* DistortionMap;
    /* 0x0008 */ FCalibratedMapFormat MapFormat;
};

// Size: 0x18
struct FSTMapPointInfo : public FDataTablePointInfoBase {
    /* 0x0008 */ FSTMapInfo STMapInfo;
};

// Size: 0x30
struct FSTMapTable : public FBaseLensTable {
    /* 0x0010 */ TArray<FSTMapFocusPoint> FocusPoints;
    /* 0x0020 */ TArray<FSTMapFocusCurve> FocusCurves;
};

// Size: 0x50
struct FSTMapZoomPoint {
    /* 0x0000 */ float Zoom;
    /* 0x0008 */ FSTMapInfo STMapInfo;
    /* 0x0018 */ FDerivedDistortionData DerivedDistortionData;
    /* 0x0048 */ bool bIsCalibrationPoint;
};

// Size: 0x10
struct FSimulcamInfo {
    /* 0x0000 */ FIntPoint MediaResolution;
    /* 0x0008 */ float MediaPlateAspectRatio;
    /* 0x000c */ float CGLayerAspectRatio;
};

// Size: 0x14
struct FSphericalDistortionParameters {
    /* 0x0000 */ float K1;
    /* 0x0004 */ float K2;
    /* 0x0008 */ float K3;
    /* 0x000c */ float P1;
    /* 0x0010 */ float P2;
};

// Size: 0xe8
class USphericalLensDistortionModelHandler : public ULensDistortionModelHandlerBase {
};

// Size: 0x28
class USphericalLensModel : public ULensModel {
};

enum class ChaosDeformableSimSpace {
    World = 0,
    ComponentXf = 1,
    bone = 2,
    ChaosDeformableSimSpace_MAX = 3,
};

// Size: 0x84
struct FChaosSolverConfiguration {
    /* 0x0000 */ int32_t PositionIterations;
    /* 0x0004 */ int32_t VelocityIterations;
    /* 0x0008 */ int32_t ProjectionIterations;
    /* 0x000c */ float CollisionMarginFraction;
    /* 0x0010 */ float CollisionMarginMax;
    /* 0x0014 */ float CollisionCullDistance;
    /* 0x0018 */ float CollisionMaxPushOutVelocity;
    /* 0x001c */ float CollisionInitialOverlapDepenetrationVelocity;
    /* 0x0020 */ float ClusterConnectionFactor;
    /* 0x0024 */ EClusterUnionMethod ClusterUnionConnectionType;
    /* 0x0028 */ FChaosSolverDestructionSettings DestructionSettings;
    /* 0x003c */ bool bGenerateCollisionData;
    /* 0x0040 */ FSolverCollisionFilterSettings CollisionFilterSettings;
    /* 0x0050 */ bool bGenerateBreakData;
    /* 0x0054 */ FSolverBreakingFilterSettings BreakingFilterSettings;
    /* 0x0064 */ bool bGenerateTrailingData;
    /* 0x0068 */ FSolverTrailingFilterSettings TrailingFilterSettings;
    /* 0x0078 */ int32_t Iterations;
    /* 0x007c */ int32_t PushOutIterations;
    /* 0x0080 */ bool bGenerateContactGraph;
};

// Size: 0x14
struct FChaosSolverDestructionSettings {
    /* 0x0000 */ int32_t PerAdvanceBreaksAllowed;
    /* 0x0004 */ int32_t PerAdvanceBreaksRescheduleLimit;
    /* 0x0008 */ int32_t ClusteringParticleReleaseThrottlingMinCount;
    /* 0x000c */ int32_t ClusteringParticleReleaseThrottlingMaxCount;
    /* 0x0010 */ bool bOptimizeForRuntimeMemory;
};

// Size: 0x28
struct FClosestPhysicsObjectResult {
};

enum class EAllowConvexMergeMethod {
    ByProximity = 0,
    Any = 1,
    EAllowConvexMergeMethod_MAX = 2,
};

enum class EChaosBufferMode {
    Double = 0,
    Triple = 1,
    Num = 2,
    Invalid = 3,
    EChaosBufferMode_MAX = 4,
};

enum class EChaosSoftsSimulationSpace {
    WorldSpace = 0,
    ComponentSpace = 1,
    ReferenceBoneSpace = 2,
    EChaosSoftsSimulationSpace_MAX = 3,
};

enum class EChaosSolverTickMode {
    Fixed = 0,
    Variable = 1,
    VariableCapped = 2,
    VariableCappedWithTarget = 3,
    EChaosSolverTickMode_MAX = 4,
};

enum class EChaosThreadingMode {
    DedicatedThread = 0,
    TaskGraph = 1,
    SingleThread = 2,
    Num = 3,
    Invalid = 4,
    EChaosThreadingMode_MAX = 5,
};

enum class EClusterUnionMethod {
    PointImplicit = 0,
    DelaunayTriangulation = 1,
    MinimalSpanningSubsetDelaunayTriangulation = 2,
    PointImplicitAugmentedWithMinimalDelaunay = 3,
    BoundsOverlapFilteredDelaunayTriangulation = 4,
    None = 5,
    EClusterUnionMethod_MAX = 6,
};

enum class ECollisionTypeEnum {
    Chaos_Volumetric = 0,
    Chaos_Surface_Volumetric = 1,
    Chaos_Max = 2,
};

enum class EConnectionContactMethod {
    None = 0,
    ConvexHullContactArea = 1,
    EConnectionContactMethod_MAX = 2,
};

enum class EConvexHullProximityFilter {
    None = 0,
    BoundingBox = 1,
    EConvexHullProximityFilter_MAX = 2,
};

enum class EConvexOverlapRemoval {
    None = 0,
    All = 1,
    OnlyClusters = 2,
    OnlyClustersVsClusters = 3,
    EConvexOverlapRemoval_MAX = 4,
};

enum class EDamageModelTypeEnum {
    Chaos_Damage_Model_UserDefined_Damage_Threshold = 0,
    Chaos_Damage_Model_Material_Strength_And_Connectivity_DamageThreshold = 1,
    Chaos_Max = 2,
};

enum class EEmissionPatternTypeEnum {
    Chaos_Emission_Pattern_First_Frame = 0,
    Chaos_Emission_Pattern_On_Demand = 1,
    Chaos_Max = 2,
};

enum class EFieldCullingOperationType {
    Field_Culling_Inside = 0,
    Field_Culling_Outside = 1,
    Field_Culling_Operation_Max = 2,
    Field_Culling_MAX = 3,
};

enum class EFieldFalloffType {
    Field_FallOff_None = 0,
    Field_Falloff_Linear = 1,
    Field_Falloff_Inverse = 2,
    Field_Falloff_Squared = 3,
    Field_Falloff_Logarithmic = 4,
    Field_Falloff_Max = 5,
};

enum class EFieldFilterType {
    Field_Filter_Dynamic = 0,
    Field_Filter_Kinematic = 1,
    Field_Filter_Static = 2,
    Field_Filter_All = 3,
    Field_Filter_Sleeping = 4,
    Field_Filter_Disabled = 5,
    Field_Filter_Max = 6,
};

enum class EFieldIntegerType {
    Integer_DynamicState = 0,
    Integer_ActivateDisabled = 1,
    Integer_CollisionGroup = 2,
    Integer_PositionAnimated = 3,
    Integer_PositionStatic = 4,
    Integer_TargetMax = 5,
    Integer_MAX = 6,
};

enum class EFieldObjectType {
    Field_Object_Rigid = 0,
    Field_Object_Cloth = 1,
    Field_Object_Destruction = 2,
    Field_Object_Character = 3,
    Field_Object_All = 4,
    Field_Object_Max = 5,
};

enum class EFieldOperationType {
    Field_Multiply = 0,
    Field_Divide = 1,
    Field_Add = 2,
    Field_Substract = 3,
    Field_Operation_Max = 4,
};

enum class EFieldOutputType {
    Field_Output_Vector = 0,
    Field_Output_Scalar = 1,
    Field_Output_Integer = 2,
    Field_Output_Max = 3,
};

enum class EFieldPhysicsDefaultFields {
    Field_RadialIntMask = 0,
    Field_RadialFalloff = 1,
    Field_UniformVector = 2,
    Field_RadialVector = 3,
    Field_RadialVectorFalloff = 4,
    Field_EFieldPhysicsDefaultFields_Max = 5,
};

enum class EFieldPhysicsType {
    Field_None = 0,
    Field_DynamicState = 1,
    Field_LinearForce = 2,
    Field_ExternalClusterStrain = 3,
    Field_Kill = 4,
    Field_LinearVelocity = 5,
    Field_AngularVelociy = 6,
    Field_AngularTorque = 7,
    Field_InternalClusterStrain = 8,
    Field_DisableThreshold = 9,
    Field_SleepingThreshold = 10,
    Field_PositionStatic = 11,
    Field_PositionAnimated = 12,
    Field_PositionTarget = 13,
    Field_DynamicConstraint = 14,
    Field_CollisionGroup = 15,
    Field_ActivateDisabled = 16,
    Field_InitialLinearVelocity = 17,
    Field_InitialAngularVelocity = 18,
    Field_LinearImpulse = 19,
    Field_PhysicsType_Max = 20,
};

enum class EFieldPositionType {
    Field_Position_CenterOfMass = 0,
    Field_Position_PivotPoint = 1,
    Field_Position_Max = 2,
};

enum class EFieldResolutionType {
    Field_Resolution_Minimal = 0,
    Field_Resolution_DisabledParents = 1,
    Field_Resolution_Maximum = 2,
    Field_Resolution_Max = 3,
};

enum class EFieldScalarType {
    Scalar_ExternalClusterStrain = 0,
    Scalar_Kill = 1,
    Scalar_DisableThreshold = 2,
    Scalar_SleepingThreshold = 3,
    Scalar_InternalClusterStrain = 4,
    Scalar_DynamicConstraint = 5,
    Scalar_TargetMax = 6,
    Scalar_MAX = 7,
};

enum class EFieldVectorType {
    Vector_LinearForce = 0,
    Vector_LinearVelocity = 1,
    Vector_AngularVelocity = 2,
    Vector_AngularTorque = 3,
    Vector_PositionTarget = 4,
    Vector_InitialLinearVelocity = 5,
    Vector_InitialAngularVelocity = 6,
    Vector_LinearImpulse = 7,
    Vector_TargetMax = 8,
    Vector_MAX = 9,
};

enum class EGenerateConvexMethod {
    ExternalCollision = 0,
    ComputedFromGeometry = 1,
    IntersectExternalWithComputed = 2,
    EGenerateConvexMethod_MAX = 3,
};

enum class EGeometryCollectionCacheType {
    None = 0,
    Record = 1,
    Play = 2,
    RecordAndPlay = 3,
    EGeometryCollectionCacheType_MAX = 4,
};

enum class EGeometryCollectionPhysicsTypeEnum {
    Chaos_AngularVelocity = 0,
    Chaos_DynamicState = 1,
    Chaos_LinearVelocity = 2,
    Chaos_InitialAngularVelocity = 3,
    Chaos_InitialLinearVelocity = 4,
    Chaos_CollisionGroup = 5,
    Chaos_LinearForce = 6,
    Chaos_AngularTorque = 7,
    Chaos_DisableThreshold = 8,
    Chaos_SleepingThreshold = 9,
    Chaos_ExternalClusterStrain = 10,
    Chaos_InternalClusterStrain = 11,
    Chaos_LinearImpulse = 12,
    Chaos_Max = 13,
};

enum class EImplicitTypeEnum {
    Chaos_Implicit_Box = 0,
    Chaos_Implicit_Sphere = 1,
    Chaos_Implicit_Capsule = 2,
    Chaos_Implicit_LevelSet = 3,
    Chaos_Implicit_None = 4,
    Chaos_Implicit_Convex = 5,
    Chaos_Max = 6,
};

enum class EInitialVelocityTypeEnum {
    Chaos_Initial_Velocity_User_Defined = 0,
    Chaos_Initial_Velocity_None = 1,
    Chaos_Max = 2,
};

enum class EObjectStateTypeEnum {
    Chaos_NONE = 0,
    Chaos_Object_Sleeping = 1,
    Chaos_Object_Kinematic = 2,
    Chaos_Object_Static = 3,
    Chaos_Object_Dynamic = 4,
    Chaos_Object_UserDefined = 100,
    Chaos_Max = 101,
};

enum class EProximityContactMethod {
    MinOverlapInProjectionToMajorAxes = 0,
    ConvexHullSharpContact = 1,
    ConvexHullAreaContact = 2,
    EProximityContactMethod_MAX = 3,
};

enum class EProximityMethod {
    Precise = 0,
    ConvexHull = 1,
    EProximityMethod_MAX = 2,
};

enum class ESetMaskConditionType {
    Field_Set_Always = 0,
    Field_Set_IFF_NOT_Interior = 1,
    Field_Set_IFF_NOT_Exterior = 2,
    Field_MaskCondition_Max = 3,
    Field_MAX = 4,
};

enum class EWaveFunctionType {
    Field_Wave_Cosine = 0,
    Field_Wave_Gaussian = 1,
    Field_Wave_Falloff = 2,
    Field_Wave_Decay = 3,
    Field_Wave_Max = 4,
};

// Size: 0xb0
struct FFieldCollection : public FManagedArrayCollection {
};

// Size: 0xb0
struct FManagedArrayCollection {
};

// Size: 0xb8
struct FRecordedFrame {
    /* 0x0000 */ TArray<FTransform> Transforms;
    /* 0x0010 */ TArray<int32_t> TransformIndices;
    /* 0x0020 */ TArray<int32_t> PreviousTransformIndices;
    /* 0x0030 */ TArray<bool> DisabledFlags;
    /* 0x0040 */ TArray<FSolverCollisionData> Collisions;
    /* 0x0050 */ TArray<FSolverBreakingData> Breakings;
    /* 0x0060 */ TSet<FSolverTrailingData> Trailings;
    /* 0x00b0 */ float Timestamp;
};

// Size: 0x10
struct FRecordedTransformTrack {
    /* 0x0000 */ TArray<FRecordedFrame> Records;
};

// Size: 0x50
struct FSerializedSolverScene {
    /* 0x0000 */ TArray<FChaosVDParticleDataWrapper> ParticleData;
    /* 0x0010 */ TArray<FChaosVDJointConstraint> JointConstraintData;
    /* 0x0020 */ TArray<FChaosVDCharacterGroundConstraint> CharacterGroundConstraintData;
    /* 0x0030 */ TArray<FChaosVDParticlePairMidPhase> CollisionMidPhaseData;
};

// Size: 0x58
struct FSolverBreakingData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Velocity;
    /* 0x0030 */ FVector AngularVelocity;
    /* 0x0048 */ float Mass;
    /* 0x004c */ int32_t ParticleIndex;
    /* 0x0050 */ int32_t ParticleIndexMesh;
};

// Size: 0x10
struct FSolverBreakingFilterSettings {
    /* 0x0000 */ bool FilterEnabled;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinVolume;
};

// Size: 0xc0
struct FSolverCollisionData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector AccumulatedImpulse;
    /* 0x0030 */ FVector Normal;
    /* 0x0048 */ FVector Velocity1;
    /* 0x0060 */ FVector Velocity2;
    /* 0x0078 */ FVector AngularVelocity1;
    /* 0x0090 */ FVector AngularVelocity2;
    /* 0x00a8 */ float Mass1;
    /* 0x00ac */ float Mass2;
    /* 0x00b0 */ int32_t ParticleIndex;
    /* 0x00b4 */ int32_t LevelsetIndex;
    /* 0x00b8 */ int32_t ParticleIndexMesh;
    /* 0x00bc */ int32_t LevelsetIndexMesh;
};

// Size: 0x10
struct FSolverCollisionFilterSettings {
    /* 0x0000 */ bool FilterEnabled;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinImpulse;
};

// Size: 0xc
struct FSolverRemovalFilterSettings {
    /* 0x0000 */ bool FilterEnabled;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinVolume;
};

// Size: 0x58
struct FSolverTrailingData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Velocity;
    /* 0x0030 */ FVector AngularVelocity;
    /* 0x0048 */ float Mass;
    /* 0x004c */ int32_t ParticleIndex;
    /* 0x0050 */ int32_t ParticleIndexMesh;
};

// Size: 0x10
struct FSolverTrailingFilterSettings {
    /* 0x0000 */ bool FilterEnabled;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinVolume;
};

// Size: 0xc0
struct FBreakingEvent : public FCacheEventBase {
    /* 0x0008 */ int32_t Index;
    /* 0x0010 */ FVector Location;
    /* 0x0030 */ FQuat Orientation;
    /* 0x0050 */ FVector Velocity;
    /* 0x0068 */ FVector AngularVelocity;
    /* 0x0080 */ float Mass;
    /* 0x0088 */ FVector BoundingBoxMin;
    /* 0x00a0 */ FVector BoundingBoxMax;
};

// Size: 0x8
struct FCacheEventBase {
};

// Size: 0x38
struct FCacheEventTrack {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UScriptStruct* Struct;
    /* 0x0010 */ TArray<float> TimeStamps;
};

// Size: 0xd0
struct FCacheSpawnableTemplate {
    /* 0x0000 */ UObject* DuplicatedTemplate;
    /* 0x0010 */ FTransform InitialTransform;
    /* 0x0070 */ FTransform ComponentTransform;
};

// Size: 0x390
class UChaosCache : public UObject {
    /* 0x0028 */ float RecordedDuration;
    /* 0x002c */ uint32_t NumRecordedFrames;
    /* 0x0030 */ EChaosCacheInterpolationMode InterpolationMode;
    /* 0x0038 */ TArray<int32_t> TrackToParticle;
    /* 0x0048 */ TArray<FPerParticleCacheData> ParticleTracks;
    /* 0x0058 */ TArray<int32_t> ChannelCurveToParticle;
    /* 0x0068 */ TMap<FName, FRichCurves> ChannelsTracks;
    /* 0x00b8 */ TMap<FName, FCompressedRichCurves> CompressedChannelsTracks;
    /* 0x0108 */ TMap<FName, FRichCurve> CurveData;
    /* 0x0158 */ TMap<FName, FParticleTransformTrack> NamedTransformTracks;
    /* 0x01a8 */ bool bCompressChannels;
    /* 0x01ac */ float ChannelsCompressionErrorThreshold;
    /* 0x01b0 */ float ChannelsCompressionSampleRate;
    /* 0x01b8 */ TScriptInterface<IChaosCacheData> CacheData;
    /* 0x01c8 */ TMap<FName, FCacheEventTrack> EventTracks;
    /* 0x0220 */ FCacheSpawnableTemplate Spawnable;
    /* 0x02f0 */ FGuid AdapterGuid;
    /* 0x0300 */ int32_t Version;
};

// Size: 0x40
class UChaosCacheCollection : public UObject {
    /* 0x0028 */ TArray<UChaosCache*> Caches;
    /* 0x0038 */ EChaosCacheInterpolationMode InterpolationMode;
};

// Size: 0x28
class IChaosCacheData : public UInterface {
};

// Size: 0x360
class AChaosCacheManager : public AActor {
    /* 0x02a8 */ UChaosCacheCollection* CacheCollection;
    /* 0x02b0 */ ECacheMode CacheMode;
    /* 0x02b1 */ EStartMode StartMode;
    /* 0x02b4 */ float StartTime;
    /* 0x02c0 */ TArray<FObservedComponent> ObservedComponents;

    void EnablePlayback(int32_t Index, bool bEnable);
    void EnablePlaybackByCache(FName InCacheName, bool bEnable);
    void ResetAllComponentTransforms();
    void ResetSingleTransform(int32_t InIndex);
    void SetCacheCollection(UChaosCacheCollection* InCacheCollection);
    void SetCurrentTime(float CurrentTime);
    void SetStartTime(float InStartTime);
    void TriggerAll();
    void TriggerComponent(UPrimitiveComponent* InComponent);
    void TriggerComponentByCache(FName InCacheName);
};

// Size: 0x360
class AChaosCachePlayer : public AChaosCacheManager {
};

// Size: 0xf0
struct FCollisionEvent : public FCacheEventBase {
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FVector AccumulatedImpulse;
    /* 0x0038 */ FVector Normal;
    /* 0x0050 */ FVector Velocity1;
    /* 0x0068 */ FVector Velocity2;
    /* 0x0080 */ FVector DeltaVelocity1;
    /* 0x0098 */ FVector DeltaVelocity2;
    /* 0x00b0 */ FVector AngularVelocity1;
    /* 0x00c8 */ FVector AngularVelocity2;
    /* 0x00e0 */ float Mass1;
    /* 0x00e4 */ float Mass2;
    /* 0x00e8 */ float PenetrationDepth;
};

// Size: 0x10
struct FCompressedRichCurves {
    /* 0x0000 */ TArray<FCompressedRichCurve> CompressedRichCurves;
};

enum class ECacheMode {
    None = 0,
    Play = 1,
    Record = 2,
    ECacheMode_MAX = 3,
};

enum class EChaosCacheInterpolationMode {
    QuatInterp = 0,
    EulerInterp = 1,
    DualQuatInterp = 2,
    EChaosCacheInterpolationMode_MAX = 3,
};

enum class EStartMode {
    Timed = 0,
    Triggered = 1,
    EStartMode_MAX = 2,
};

// Size: 0x10
struct FEnableStateEvent : public FCacheEventBase {
    /* 0x0008 */ int32_t Index;
    /* 0x000c */ bool bEnable;
};

// Size: 0x28
struct FMovieSceneChaosCacheParams : public FMovieSceneBaseCacheParams {
    /* 0x0020 */ UChaosCacheCollection* CacheCollection;
};

// Size: 0x138
class UMovieSceneChaosCacheSection : public UMovieSceneBaseCacheSection {
    /* 0x0110 */ FMovieSceneChaosCacheParams Params;
};

// Size: 0x50
struct FMovieSceneChaosCacheSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneChaosCacheSectionTemplateParameters Params;
};

// Size: 0x30
struct FMovieSceneChaosCacheSectionTemplateParameters : public FMovieSceneBaseCacheSectionTemplateParameters {
    /* 0x0008 */ FMovieSceneChaosCacheParams ChaosCacheParams;
};

// Size: 0x128
class UMovieSceneChaosCacheTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> AnimationSections;
};

// Size: 0x48
class UMovieSceneSpawnableChaosCacheBinding : public UMovieSceneSpawnableActorBinding {
};

// Size: 0x180
struct FObservedComponent {
    /* 0x0000 */ FName CacheName;
    /* 0x0008 */ FComponentReference ComponentRef;
    /* 0x0030 */ FSoftComponentReference SoftComponentRef;
    /* 0x0078 */ bool bIsSimulating;
    /* 0x0079 */ bool bPlaybackEnabled;
    /* 0x0080 */ FDirectoryPath USDCacheDirectory;
};

// Size: 0x48
struct FParticleTransformTrack {
    /* 0x0000 */ FRawAnimSequenceTrack RawTransformTrack;
    /* 0x0030 */ float BeginOffset;
    /* 0x0034 */ bool bDeactivateOnEnd;
    /* 0x0038 */ TArray<float> KeyTimestamps;
};

// Size: 0x98
struct FPerParticleCacheData {
    /* 0x0000 */ FParticleTransformTrack TransformData;
    /* 0x0048 */ TMap<FName, FRichCurve> CurveData;
};

// Size: 0x10
struct FRichCurves {
    /* 0x0000 */ TArray<FRichCurve> RichCurves;
};

// Size: 0xb0
struct FTrailingEvent : public FCacheEventBase {
    /* 0x0008 */ int32_t Index;
    /* 0x0010 */ FVector Location;
    /* 0x0030 */ FQuat Orientation;
    /* 0x0050 */ FVector Velocity;
    /* 0x0068 */ FVector AngularVelocity;
    /* 0x0080 */ FVector BoundingBoxMin;
    /* 0x0098 */ FVector BoundingBoxMax;
};

// Size: 0x180
class UChaosClothConfig : public UClothConfigCommon {
    /* 0x0028 */ EClothMassMode MassMode;
    /* 0x002c */ float UniformMass;
    /* 0x0030 */ float TotalMass;
    /* 0x0034 */ float Density;
    /* 0x0038 */ float MinPerParticleMass;
    /* 0x003c */ FChaosClothWeightedValue EdgeStiffnessWeighted;
    /* 0x0044 */ FChaosClothWeightedValue BendingStiffnessWeighted;
    /* 0x004c */ bool bUseBendingElements;
    /* 0x0050 */ float BucklingRatio;
    /* 0x0054 */ FChaosClothWeightedValue BucklingStiffnessWeighted;
    /* 0x005c */ FChaosClothWeightedValue FlatnessRatio;
    /* 0x0064 */ FChaosClothWeightedValue AreaStiffnessWeighted;
    /* 0x006c */ float VolumeStiffness;
    /* 0x0070 */ FChaosClothWeightedValue TetherStiffness;
    /* 0x0078 */ FChaosClothWeightedValue TetherScale;
    /* 0x0080 */ bool bUseGeodesicDistance;
    /* 0x0084 */ float ShapeTargetStiffness;
    /* 0x0088 */ float CollisionThickness;
    /* 0x008c */ float FrictionCoefficient;
    /* 0x0090 */ bool bUseCCD;
    /* 0x0091 */ bool bUseSelfCollisions;
    /* 0x0094 */ float SelfCollisionThickness;
    /* 0x0098 */ float SelfCollisionFriction;
    /* 0x009c */ bool bUseSelfIntersections;
    /* 0x009d */ bool bUseSelfCollisionSpheres;
    /* 0x00a0 */ float SelfCollisionSphereRadius;
    /* 0x00a4 */ float SelfCollisionSphereStiffness;
    /* 0x00a8 */ float SelfCollisionSphereRadiusCullMultiplier;
    /* 0x00ac */ bool bUseLegacyBackstop;
    /* 0x00b0 */ float DampingCoefficient;
    /* 0x00b4 */ float LocalDampingCoefficient;
    /* 0x00b8 */ bool bUsePointBasedWindModel;
    /* 0x00bc */ FChaosClothWeightedValue Drag;
    /* 0x00c4 */ bool bEnableOuterDrag;
    /* 0x00c8 */ FChaosClothWeightedValue OuterDrag;
    /* 0x00d0 */ FChaosClothWeightedValue Lift;
    /* 0x00d8 */ bool bEnableOuterLift;
    /* 0x00dc */ FChaosClothWeightedValue OuterLift;
    /* 0x00e4 */ bool bUseGravityOverride;
    /* 0x00e8 */ float GravityScale;
    /* 0x00f0 */ FVector Gravity;
    /* 0x0108 */ FChaosClothWeightedValue Pressure;
    /* 0x0110 */ FChaosClothWeightedValue AnimDriveStiffness;
    /* 0x0118 */ FChaosClothWeightedValue AnimDriveDamping;
    /* 0x0120 */ EChaosSoftsSimulationSpace VelocityScaleSpace;
    /* 0x0128 */ FVector LinearVelocityScale;
    /* 0x0140 */ bool bEnableLinearVelocityClamping;
    /* 0x0144 */ FVector3f MaxLinearVelocity;
    /* 0x0150 */ bool bEnableLinearAccelerationClamping;
    /* 0x0154 */ FVector3f MaxLinearAcceleration;
    /* 0x0160 */ float AngularVelocityScale;
    /* 0x0164 */ bool bEnableAngularVelocityClamping;
    /* 0x0168 */ float MaxAngularVelocity;
    /* 0x016c */ bool bEnableAngularAccelerationClamping;
    /* 0x0170 */ float MaxAngularAcceleration;
    /* 0x0174 */ float FictitiousAngularScale;
    /* 0x0178 */ bool bUseTetrahedralConstraints;
    /* 0x0179 */ bool bUseThinShellVolumeConstraints;
    /* 0x017a */ bool bUseContinuousCollisionDetection;
};

// Size: 0x38
class UChaosClothSharedSimConfig : public UClothSharedConfigCommon {
    /* 0x0028 */ int32_t IterationCount;
    /* 0x002c */ int32_t MaxIterationCount;
    /* 0x0030 */ int32_t SubdivisionCount;
    /* 0x0034 */ bool bUseLocalSpaceSimulation;
    /* 0x0035 */ bool bUseXPBDConstraints;
};

// Size: 0x8
struct FChaosClothWeightedValue {
    /* 0x0000 */ float Low;
    /* 0x0004 */ float High;
};

// Size: 0x50
class UChaosClothingInteractor : public UClothingInteractor {

    void ResetAndTeleport(bool bReset, bool bTeleport);
    void SetAerodynamics(float DragCoefficient, float LiftCoefficient, FVector WindVelocity);
    void SetAnimDrive(FVector2D AnimDriveStiffness, FVector2D AnimDriveDamping);
    void SetAnimDriveLinear(float AnimDriveStiffness);
    void SetBackstop(bool bEnabled);
    void SetCollision(float CollisionThickness, float FrictionCoefficient, bool bUseCCD, float SelfCollisionThickness);
    void SetDamping(float DampingCoefficient, float LocalDampingCoefficient);
    void SetGravity(float GravityScale, bool bIsGravityOverridden, FVector GravityOverride);
    void SetLongRangeAttachment(FVector2D TetherStiffness, FVector2D TetherScale);
    void SetLongRangeAttachmentLinear(float TetherStiffness, float TetherScale);
    void SetMaterial(FVector2D EdgeStiffness, FVector2D BendingStiffness, FVector2D AreaStiffness);
    void SetMaterialBuckling(FVector2D BucklingRatio, FVector2D BucklingStiffness);
    void SetMaterialLinear(float EdgeStiffness, float BendingStiffness, float AreaStiffness);
    void SetPressure(FVector2D Pressure);
    void SetVelocityClamps(bool bEnableLinearVelocityClamping, FVector MaxLinearVelocity, bool bEnableLinearAccelerationClamping, FVector MaxLinearAcceleration, bool bEnableAngularVelocityClamping, float MaxAngularVelocity, bool bEnableAngularAccelerationClamping, float MaxAngularAcceleration);
    void SetVelocityScale(FVector LinearVelocityScale, float AngularVelocityScale, float FictitiousAngularScale);
    void SetWind(FVector2D Drag, FVector2D Lift, float AirDensity, FVector WindVelocity, FVector2D OuterDrag, FVector2D OuterLift);
};

// Size: 0x28
class UChaosClothingSimulationFactory : public UClothingSimulationFactory {
};

// Size: 0xb0
class UChaosClothingSimulationInteractor : public UClothingSimulationInteractor {
};

enum class EChaosClothTetherMode {
    FastTetherFastLength = 0,
    AccurateTetherFastLength = 1,
    AccurateTetherAccurateLength = 2,
    MaxChaosClothTetherMode = 3,
    EChaosClothTetherMode_MAX = 4,
};

enum class EChaosWeightMapTarget {
    None = 0,
    MaxDistance = 1,
    BackstopDistance = 2,
    BackstopRadius = 3,
    AnimDriveStiffness = 4,
    TetherEndsMask = 201,
    AnimDriveDamping = 5,
    TetherStiffness = 6,
    TetherScale = 7,
    Drag = 8,
    Lift = 9,
    EdgeStiffness = 10,
    BendingStiffness = 11,
    AreaStiffness = 12,
    BucklingStiffness = 13,
    Pressure = 14,
    FlatnessRatio = 15,
    OuterDrag = 16,
    OuterLift = 17,
    MAX = 18,
};

// Size: 0x30
struct FBreakEventCallbackWrapper {
};

// Size: 0xc0
class UChaosDebugDrawComponent : public UActorComponent {
};

// Size: 0x30
class UChaosDebugDrawSubsystem : public UWorldSubsystem {
};

// Size: 0x3
struct FChaosDebugSubstepControl {
    /* 0x0000 */ bool bPause;
    /* 0x0001 */ bool bSubstep;
    /* 0x0002 */ bool bStep;
};

// Size: 0xc0
class UChaosEventListenerComponent : public UActorComponent {
};

// Size: 0x2d0
class UChaosGameplayEventDispatcher : public UChaosEventListenerComponent {
    /* 0x0180 */ TMap<UPrimitiveComponent*, FChaosHandlerSet> CollisionEventRegistrations;
    /* 0x01d0 */ TMap<UPrimitiveComponent*, FBreakEventCallbackWrapper> BreakEventRegistrations;
    /* 0x0220 */ TMap<UPrimitiveComponent*, FRemovalEventCallbackWrapper> RemovalEventRegistrations;
    /* 0x0270 */ TMap<UPrimitiveComponent*, FCrumblingEventCallbackWrapper> CrumblingEventRegistrations;
};

// Size: 0x58
struct FChaosHandlerSet {
    /* 0x0008 */ TSet<UObject*> ChaosHandlers;
};

// Size: 0x28
class IChaosNotifyHandlerInterface : public UInterface {
};

// Size: 0xc0
struct FChaosPhysicsCollisionInfo {
    /* 0x0000 */ UPrimitiveComponent* Component;
    /* 0x0008 */ UPrimitiveComponent* OtherComponent;
    /* 0x0010 */ FVector Location;
    /* 0x0028 */ FVector Normal;
    /* 0x0040 */ FVector AccumulatedImpulse;
    /* 0x0058 */ FVector Velocity;
    /* 0x0070 */ FVector OtherVelocity;
    /* 0x0088 */ FVector AngularVelocity;
    /* 0x00a0 */ FVector OtherAngularVelocity;
    /* 0x00b8 */ float Mass;
    /* 0x00bc */ float OtherMass;
};

// Size: 0x28
class UChaosSolver : public UObject {
};

// Size: 0x4a8
class AChaosSolverActor : public AActor {
    /* 0x02b0 */ FChaosSolverConfiguration Properties;
    /* 0x0334 */ float TimeStepMultiplier;
    /* 0x0338 */ int32_t CollisionIterations;
    /* 0x033c */ int32_t PushOutIterations;
    /* 0x0340 */ int32_t PushOutPairIterations;
    /* 0x0344 */ float ClusterConnectionFactor;
    /* 0x0348 */ EClusterConnectionTypeEnum ClusterUnionConnectionType;
    /* 0x0349 */ bool DoGenerateCollisionData;
    /* 0x034c */ FSolverCollisionFilterSettings CollisionFilterSettings;
    /* 0x035c */ bool DoGenerateBreakingData;
    /* 0x0360 */ FSolverBreakingFilterSettings BreakingFilterSettings;
    /* 0x0370 */ bool DoGenerateTrailingData;
    /* 0x0374 */ FSolverTrailingFilterSettings TrailingFilterSettings;
    /* 0x0384 */ float MassScale;
    /* 0x0388 */ bool bHasFloor;
    /* 0x038c */ float FloorHeight;
    /* 0x0390 */ FChaosDebugSubstepControl ChaosDebugSubstepControl;
    /* 0x0398 */ UBillboardComponent* SpriteComponent;
    /* 0x03a0 */ FDataflowSimulationAsset SimulationAsset;
    /* 0x0498 */ UChaosGameplayEventDispatcher* GameplayEventDispatcherComponent;

    void SetAsCurrentWorldSolver();
    void SetSolverActive(bool bActive);
};

// Size: 0x28
class UChaosSolverEngineBlueprintLibrary : public UBlueprintFunctionLibrary {

    static FHitResult ConvertPhysicsCollisionToHitResult(const FChaosPhysicsCollisionInfo& PhysicsCollision);
};

// Size: 0x60
class UChaosSolverSettings : public UDeveloperSettings {
    /* 0x0040 */ FSoftClassPath DefaultChaosSolverActorClass;
};

// Size: 0x18
struct FChaosVDChannelStateChangeCommandMessage {
    /* 0x0000 */ FChaosVDDataChannelState NewState;
};

// Size: 0x28
struct FChaosVDChannelStateChangeResponseMessage {
    /* 0x0000 */ FGuid InstanceId;
    /* 0x0010 */ FChaosVDDataChannelState NewState;
};

// Size: 0x18
struct FChaosVDDataChannelState {
    /* 0x0000 */ FString ChannelName;
    /* 0x0010 */ bool bIsEnabled;
    /* 0x0011 */ bool bCanChangeChannelState;
};

// Size: 0x1
struct FChaosVDFullSessionInfoRequestMessage {
};

// Size: 0x28
struct FChaosVDFullSessionInfoResponseMessage {
    /* 0x0000 */ FGuid InstanceId;
    /* 0x0010 */ TArray<FChaosVDDataChannelState> DataChannelsStates;
    /* 0x0020 */ bool bIsRecording;
};

// Size: 0x50
struct FChaosVDRecordingStatusMessage {
    /* 0x0000 */ FGuid InstanceId;
    /* 0x0010 */ bool bIsRecording;
    /* 0x0014 */ float ElapsedTime;
    /* 0x0018 */ FChaosVDTraceDetails TraceDetails;
};

// Size: 0x10
struct FChaosVDSessionPing {
    /* 0x0000 */ FGuid ControllerInstanceId;
};

// Size: 0x38
struct FChaosVDSessionPong {
    /* 0x0000 */ FGuid InstanceId;
    /* 0x0010 */ FGuid SessionId;
    /* 0x0020 */ FString SessionName;
    /* 0x0030 */ uint8_t BuildTargetType;
};

// Size: 0x18
struct FChaosVDStartRecordingCommandMessage {
    /* 0x0000 */ EChaosVDRecordingMode RecordingMode;
    /* 0x0008 */ FString Target;
};

// Size: 0x1
struct FChaosVDStopRecordingCommandMessage {
};

// Size: 0x30
struct FCrumblingEventCallbackWrapper {
};

// Size: 0x90
struct FDataflowRigidSolverProxy : public FDataflowPhysicsSolverProxy {
};

enum class EChaosVDRemoteSessionAttributes {
    None = 0,
    SupportsDataChannelChange = 1,
    CanExpire = 2,
    IsMultiSessionWrapper = 4,
    EChaosVDRemoteSessionAttributes_MAX = 5,
};

enum class EChaosVDRemoteSessionReadyState {
    Ready = 0,
    Busy = 1,
    EChaosVDRemoteSessionReadyState_MAX = 2,
};

enum class EClusterConnectionTypeEnum {
    Chaos_PointImplicit = 0,
    Chaos_DelaunayTriangulation = 1,
    Chaos_MinimalSpanningSubsetDelaunayTriangulation = 2,
    Chaos_PointImplicitAugmentedWithMinimalDelaunay = 3,
    Chaos_BoundsOverlapFilteredDelaunayTriangulation = 4,
    Chaos_None = 5,
    Chaos_EClsuterCreationParameters_Max = 6,
    Chaos_MAX = 7,
};

// Size: 0x30
struct FRemovalEventCallbackWrapper {
};

// Size: 0x28
class UChaosVDRuntimeBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void RecordDebugDrawBox(const UObject* WorldContext, const FBox& InBox, FName Tag, FLinearColor Color);
    static void RecordDebugDrawLine(const UObject* WorldContext, const FVector& InStartLocation, const FVector& InEndLocation, FName Tag, FLinearColor Color);
    static void RecordDebugDrawSphere(const UObject* WorldContext, const FVector& InCenter, float Radius, FName Tag, FLinearColor Color);
    static void RecordDebugDrawVector(const UObject* WorldContext, const FVector& InStartLocation, const FVector& InVector, FName Tag, FLinearColor Color);
};

// Size: 0x70
struct FChaosVDAABBTreeDataWrapper : public FChaosVDAccelerationStructureBase {
    /* 0x0018 */ int32_t RootNodeIndex;
    /* 0x001c */ int32_t TreeDepth;
    /* 0x0020 */ int32_t NodesNum;
    /* 0x0024 */ int32_t LeavesNum;
    /* 0x0028 */ bool bDynamicTree;
    /* 0x002c */ int32_t MaxChildrenInLeaf;
    /* 0x0030 */ int32_t MaxTreeDepth;
    /* 0x0038 */ double MaxPayloadBounds;
};

// Size: 0x58
struct FChaosVDAABBTreeLeafDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ TArray<FChaosVDAABBTreePayloadBoundsElement> Elements;
    /* 0x0020 */ FBox Bounds;
};

// Size: 0x90
struct FChaosVDAABBTreeNodeDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FBox ChildrenBounds[2];
    /* 0x0080 */ int32_t ChildrenNodes[2];
    /* 0x0088 */ int32_t ParentNode;
    /* 0x008c */ bool bLeaf;
    /* 0x008c */ bool bDirtyNode;
};

// Size: 0x88
struct FChaosVDAABBTreePayloadBoundsElement : public FChaosVDWrapperDataBase {
    /* 0x0010 */ int32_t ParticleIndex;
    /* 0x0018 */ FBox Bounds;
};

// Size: 0x18
struct FChaosVDAccelerationStructureBase : public FChaosVDWrapperDataBase {
    /* 0x0010 */ int32_t SolverId;
    /* 0x0014 */ EChaosVDAccelerationStructureType Type;
};

// Size: 0x50
struct FChaosVDAccelerationStructureContainer {
};

// Size: 0x68
struct FChaosVDBVCellElementDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FBox Bounds;
    /* 0x0048 */ int32_t ParticleIndex;
};

// Size: 0x40
struct FChaosVDBoundingVolumeDataWrapper : public FChaosVDAccelerationStructureBase {
    /* 0x0038 */ double MaxPayloadBounds;
};

// Size: 0x138
struct FChaosVDCharacterGroundConstraint : public FChaosVDConstraintDataWrapperBase {
    /* 0x0014 */ int32_t ConstraintIndex;
    /* 0x0020 */ FChaosVDCharacterGroundConstraintStateDataWrapper State;
    /* 0x0078 */ FChaosVDCharacterGroundConstraintSettingsDataWrapper Settings;
    /* 0x00e0 */ FChaosVDCharacterGroundConstraintDataDataWrapper Data;
};

// Size: 0x58
struct FChaosVDCharacterGroundConstraintDataDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector GroundNormal;
    /* 0x0028 */ FVector TargetDeltaPosition;
    /* 0x0040 */ double TargetDeltaFacing;
    /* 0x0048 */ double GroundDistance;
    /* 0x0050 */ double CosMaxWalkableSlopeAngle;
};

// Size: 0x68
struct FChaosVDCharacterGroundConstraintSettingsDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector VerticalAxis;
    /* 0x0028 */ double TargetHeight;
    /* 0x0030 */ double RadialForceLimit;
    /* 0x0038 */ double FrictionForceLimit;
    /* 0x0040 */ double TwistTorqueLimit;
    /* 0x0048 */ double SwingTorqueLimit;
    /* 0x0050 */ double CosMaxWalkableSlopeAngle;
    /* 0x0058 */ double DampingFactor;
    /* 0x0060 */ double AssumedOnGroundHeight;
};

// Size: 0x58
struct FChaosVDCharacterGroundConstraintStateDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0020 */ bool bDisabled;
    /* 0x0028 */ FVector SolverAppliedForce;
    /* 0x0040 */ FVector SolverAppliedTorque;
};

// Size: 0x18
struct FChaosVDCollisionChannelInfo {
    /* 0x0000 */ FString DisplayName;
    /* 0x0010 */ int32_t CollisionChannel;
    /* 0x0014 */ bool bIsTraceType;
};

// Size: 0x300
struct FChaosVDCollisionChannelsInfoContainer {
    /* 0x0000 */ FChaosVDCollisionChannelInfo CustomChannelsNames[32];
};

// Size: 0x10
struct FChaosVDCollisionFilterData {
    /* 0x0000 */ uint32_t Word0;
    /* 0x0004 */ uint32_t Word1;
    /* 0x0008 */ uint32_t Word2;
    /* 0x000c */ uint32_t Word3;
};

// Size: 0x30
struct FChaosVDCollisionMaterial {
    /* 0x0000 */ int32_t FaceIndex;
    /* 0x0004 */ float MaterialDynamicFriction;
    /* 0x0008 */ float MaterialStaticFriction;
    /* 0x000c */ float MaterialRestitution;
    /* 0x0010 */ float DynamicFriction;
    /* 0x0014 */ float StaticFriction;
    /* 0x0018 */ float Restitution;
    /* 0x001c */ float RestitutionThreshold;
    /* 0x0020 */ float InvMassScale0;
    /* 0x0024 */ float InvMassScale1;
    /* 0x0028 */ float InvInertiaScale0;
    /* 0x002c */ float InvInertiaScale1;
};

// Size: 0x18
struct FChaosVDCollisionObjectQueryParams : public FChaosVDWrapperDataBase {
    /* 0x0010 */ uint8_t ObjectTypesToQuery;
    /* 0x0011 */ uint8_t IgnoreMask;
};

// Size: 0x68
struct FChaosVDCollisionQueryParams : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FName TraceTag;
    /* 0x0018 */ FName OwnerTag;
    /* 0x0020 */ bool bTraceComplex;
    /* 0x0020 */ bool bFindInitialOverlaps;
    /* 0x0020 */ bool bReturnFaceIndex;
    /* 0x0020 */ bool bReturnPhysicalMaterial;
    /* 0x0020 */ bool bIgnoreBlocks;
    /* 0x0020 */ bool bIgnoreTouches;
    /* 0x0020 */ bool bSkipNarrowPhase;
    /* 0x0020 */ bool bTraceIntoSubComponents;
    /* 0x0021 */ bool bReplaceHitWithSubComponents;
    /* 0x0022 */ uint8_t IgnoreMask;
    /* 0x0048 */ TArray<FName> IgnoredActorsNames;
    /* 0x0058 */ TArray<FName> IgnoredComponentsNames;
};

// Size: 0x40
struct FChaosVDCollisionResponseParams : public FChaosVDWrapperDataBase {
};

// Size: 0x8
struct FChaosVDConnectivityEdge {
    /* 0x0000 */ int32_t SiblingParticleID;
    /* 0x0004 */ float Strain;
};

// Size: 0x280
struct FChaosVDConstraint {
    /* 0x0000 */ bool bIsCurrent;
    /* 0x0000 */ bool bDisabled;
    /* 0x0000 */ bool bUseManifold;
    /* 0x0000 */ bool bUseIncrementalManifold;
    /* 0x0000 */ bool bCanRestoreManifold;
    /* 0x0000 */ bool bWasManifoldRestored;
    /* 0x0000 */ bool bIsQuadratic0;
    /* 0x0000 */ bool bIsQuadratic1;
    /* 0x0001 */ bool bIsProbe;
    /* 0x0001 */ bool bCCDEnabled;
    /* 0x0001 */ bool bCCDSweepEnabled;
    /* 0x0001 */ bool bModifierApplied;
    /* 0x0001 */ bool bMaterialSet;
    /* 0x0004 */ FChaosVDCollisionMaterial Material;
    /* 0x0038 */ FVector AccumulatedImpulse;
    /* 0x0050 */ EChaosVDContactShapesType ShapesType;
    /* 0x0060 */ FTransform ShapeWorldTransforms[2];
    /* 0x0120 */ FTransform ImplicitTransforms[2];
    /* 0x01e0 */ float CullDistance;
    /* 0x01e8 */ TArray<float> CollisionMargins;
    /* 0x01f8 */ float CollisionTolerance;
    /* 0x01fc */ int32_t ClosestManifoldPointIndex;
    /* 0x0200 */ int32_t ExpectedNumManifoldPoints;
    /* 0x0208 */ FVector LastShapeWorldPositionDelta;
    /* 0x0220 */ FQuat LastShapeWorldRotationDelta;
    /* 0x0240 */ float Stiffness;
    /* 0x0244 */ float MinInitialPhi;
    /* 0x0248 */ float InitialOverlapDepenetrationVelocity;
    /* 0x024c */ float CCDTimeOfImpact;
    /* 0x0250 */ float CCDEnablePenetration;
    /* 0x0254 */ float CCDTargetPenetration;
    /* 0x0258 */ TArray<FChaosVDManifoldPoint> ManifoldPoints;
    /* 0x0268 */ int32_t Particle0Index;
    /* 0x026c */ int32_t Particle1Index;
    /* 0x0270 */ int32_t SolverId;
};

// Size: 0x10
struct FChaosVDConstraintDataWrapperBase : public FChaosVDWrapperDataBase {
};

// Size: 0x58
struct FChaosVDContactPoint {
    /* 0x0000 */ FVector ShapeContactPoints[2];
    /* 0x0030 */ FVector ShapeContactNormal;
    /* 0x0048 */ float Phi;
    /* 0x004c */ int32_t FaceIndex;
    /* 0x0050 */ EChaosVDContactPointType ContactType;
};

// Size: 0x60
struct FChaosVDDebugDrawBoxDataWrapper : public FChaosVDDebugDrawShapeBase {
    /* 0x0028 */ FBox Box;
};

// Size: 0x90
struct FChaosVDDebugDrawImplicitObjectDataWrapper : public FChaosVDDebugDrawShapeBase {
};

// Size: 0x60
struct FChaosVDDebugDrawLineDataWrapper : public FChaosVDDebugDrawShapeBase {
    /* 0x0028 */ FVector StartLocation;
    /* 0x0040 */ FVector EndLocation;
    /* 0x0058 */ bool bIsArrow;
};

// Size: 0x28
struct FChaosVDDebugDrawShapeBase : public FChaosVDWrapperDataBase {
    /* 0x0010 */ int32_t SolverId;
    /* 0x0014 */ FName Tag;
    /* 0x001c */ FColor Color;
    /* 0x0020 */ EChaosVDParticleContext ThreadContext;
};

// Size: 0x48
struct FChaosVDDebugDrawSphereDataWrapper : public FChaosVDDebugDrawShapeBase {
    /* 0x0028 */ FVector Origin;
    /* 0x0040 */ float Radius;
};

// Size: 0x40
struct FChaosVDDebugShapeDataContainer {
};

// Size: 0x20
struct FChaosVDFRigidParticleControlFlags : public FChaosVDWrapperDataBase {
    /* 0x0010 */ bool bGravityEnabled;
    /* 0x0011 */ bool bCCDEnabled;
    /* 0x0012 */ bool bOneWayInteractionEnabled;
    /* 0x0013 */ bool bInertiaConditioningEnabled;
    /* 0x0014 */ int32_t GravityGroupIndex;
    /* 0x0018 */ bool bMACDEnabled;
    /* 0x0019 */ bool bGyroscopicTorqueEnabled;
    /* 0x001a */ uint8_t PositionSolverIterationCount;
    /* 0x001b */ uint8_t VelocitySolverIterationCount;
    /* 0x001c */ uint8_t ProjectionSolverIterationCount;
};

// Size: 0x50
struct FChaosVDGTJointStateDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ bool bIsBreaking;
    /* 0x0010 */ bool bIsBroken;
    /* 0x0010 */ bool bDriveTargetChanged;
    /* 0x0010 */ bool bIsViolating;
    /* 0x0018 */ FVector Force;
    /* 0x0030 */ FVector Torque;
    /* 0x0048 */ float LinearViolation;
    /* 0x004c */ float AngularViolation;
};

// Size: 0x3c0
struct FChaosVDJointConstraint : public FChaosVDConstraintDataWrapperBase {
    /* 0x0014 */ int32_t ConstraintIndex;
    /* 0x0020 */ FChaosVDJointStateDataWrapper PhysicsThreadJointState;
    /* 0x0080 */ FChaosVDGTJointStateDataWrapper GameThreadJointState;
    /* 0x00d0 */ FChaosVDJointSettingsDataWrapper JointSettings;
};

// Size: 0x2f0
struct FChaosVDJointSettingsDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FTransform ConnectorTransforms[2];
    /* 0x00d0 */ double Stiffness;
    /* 0x00d8 */ double LinearProjection;
    /* 0x00e0 */ double AngularProjection;
    /* 0x00e8 */ double ShockPropagation;
    /* 0x00f0 */ double TeleportDistance;
    /* 0x00f8 */ double TeleportAngle;
    /* 0x0100 */ double ParentInvMassScale;
    /* 0x0108 */ bool bCollisionEnabled;
    /* 0x0108 */ bool bMassConditioningEnabled;
    /* 0x0108 */ bool bUseLinearSolver;
    /* 0x0108 */ bool bSoftLinearLimitsEnabled;
    /* 0x0108 */ bool bSoftTwistLimitsEnabled;
    /* 0x0108 */ bool bSoftSwingLimitsEnabled;
    /* 0x0108 */ bool bAngularSLerpPositionDriveEnabled;
    /* 0x0108 */ bool bAngularSLerpVelocityDriveEnabled;
    /* 0x0109 */ bool bAngularTwistPositionDriveEnabled;
    /* 0x0109 */ bool bAngularTwistVelocityDriveEnabled;
    /* 0x0109 */ bool bAngularSwingPositionDriveEnabled;
    /* 0x0109 */ bool bAngularSwingVelocityDriveEnabled;
    /* 0x010c */ EChaosVDJointMotionType LinearMotionTypes[3];
    /* 0x0118 */ double LinearLimit;
    /* 0x0120 */ EChaosVDJointMotionType AngularMotionTypes[3];
    /* 0x0130 */ FVector AngularLimits;
    /* 0x0148 */ EChaosVDJointForceMode LinearSoftForceMode;
    /* 0x014c */ EChaosVDJointForceMode AngularSoftForceMode;
    /* 0x0150 */ double SoftLinearStiffness;
    /* 0x0158 */ double SoftLinearDamping;
    /* 0x0160 */ double SoftTwistStiffness;
    /* 0x0168 */ double SoftTwistDamping;
    /* 0x0170 */ double SoftSwingStiffness;
    /* 0x0178 */ double SoftSwingDamping;
    /* 0x0180 */ double LinearRestitution;
    /* 0x0188 */ double TwistRestitution;
    /* 0x0190 */ double SwingRestitution;
    /* 0x0198 */ double LinearContactDistance;
    /* 0x01a0 */ double TwistContactDistance;
    /* 0x01a8 */ double SwingContactDistance;
    /* 0x01b0 */ FVector LinearDrivePositionTarget;
    /* 0x01c8 */ FVector LinearDriveVelocityTarget;
    /* 0x01e0 */ bool bLinearPositionDriveEnabled0;
    /* 0x01e0 */ bool bLinearPositionDriveEnabled1;
    /* 0x01e0 */ bool bLinearPositionDriveEnabled2;
    /* 0x01e0 */ bool bLinearVelocityDriveEnabled0;
    /* 0x01e0 */ bool bLinearVelocityDriveEnabled1;
    /* 0x01e0 */ bool bLinearVelocityDriveEnabled2;
    /* 0x01e4 */ EChaosVDJointForceMode LinearDriveForceMode;
    /* 0x01e8 */ FVector LinearDriveStiffness;
    /* 0x0200 */ FVector LinearDriveDamping;
    /* 0x0218 */ FVector LinearDriveMaxForce;
    /* 0x0230 */ FQuat AngularDrivePositionTarget;
    /* 0x0250 */ FVector AngularDriveVelocityTarget;
    /* 0x0268 */ EChaosVDJointForceMode AngularDriveForceMode;
    /* 0x0270 */ FVector AngularDriveStiffness;
    /* 0x0288 */ FVector AngularDriveDamping;
    /* 0x02a0 */ FVector AngularDriveMaxTorque;
    /* 0x02b8 */ double LinearBreakForce;
    /* 0x02c0 */ double LinearPlasticityLimit;
    /* 0x02c8 */ EChaosVDPlasticityType LinearPlasticityType;
    /* 0x02d0 */ double LinearPlasticityInitialDistanceSquared;
    /* 0x02d8 */ double AngularBreakTorque;
    /* 0x02e0 */ double AngularPlasticityLimit;
    /* 0x02e8 */ double ContactTransferScale;
};

// Size: 0xd8
struct FChaosVDJointSolverSettingsDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ double SwingTwistAngleTolerance;
    /* 0x0018 */ double PositionTolerance;
    /* 0x0020 */ double AngleTolerance;
    /* 0x0028 */ double MinParentMassRatio;
    /* 0x0030 */ double MaxInertiaRatio;
    /* 0x0038 */ double MinSolverStiffness;
    /* 0x0040 */ double MaxSolverStiffness;
    /* 0x0048 */ int32_t NumIterationsAtMaxSolverStiffness;
    /* 0x004c */ int32_t NumShockPropagationIterations;
    /* 0x0050 */ bool bUseLinearSolver;
    /* 0x0050 */ bool bSortEnabled;
    /* 0x0050 */ bool bSolvePositionLast;
    /* 0x0050 */ bool bUsePositionBasedDrives;
    /* 0x0050 */ bool bEnableTwistLimits;
    /* 0x0050 */ bool bEnableSwingLimits;
    /* 0x0050 */ bool bEnableDrives;
    /* 0x0058 */ double LinearStiffnessOverride;
    /* 0x0060 */ double TwistStiffnessOverride;
    /* 0x0068 */ double SwingStiffnessOverride;
    /* 0x0070 */ double LinearProjectionOverride;
    /* 0x0078 */ double AngularProjectionOverride;
    /* 0x0080 */ double ShockPropagationOverride;
    /* 0x0088 */ double LinearDriveStiffnessOverride;
    /* 0x0090 */ double LinearDriveDampingOverride;
    /* 0x0098 */ double AngularDriveStiffnessOverride;
    /* 0x00a0 */ double AngularDriveDampingOverride;
    /* 0x00a8 */ double SoftLinearStiffnessOverride;
    /* 0x00b0 */ double SoftLinearDampingOverride;
    /* 0x00b8 */ double SoftTwistStiffnessOverride;
    /* 0x00c0 */ double SoftTwistDampingOverride;
    /* 0x00c8 */ double SoftSwingStiffnessOverride;
    /* 0x00d0 */ double SoftSwingDampingOverride;
};

// Size: 0x60
struct FChaosVDJointStateDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0020 */ bool bDisabled;
    /* 0x0020 */ bool bBroken;
    /* 0x0020 */ bool bBreaking;
    /* 0x0020 */ bool bDriveTargetChanged;
    /* 0x0020 */ bool bEnabledDuringResim;
    /* 0x0028 */ FVector LinearImpulse;
    /* 0x0040 */ FVector AngularImpulse;
    /* 0x0058 */ EChaosVDJointReSimType ResimType;
    /* 0x005c */ EChaosVDJointSyncType SyncState;
};

// Size: 0x50
struct FChaosVDKinematicTarget : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FQuat Rotation;
    /* 0x0030 */ FVector position;
    /* 0x0048 */ EChaosVDKinematicTargetMode Mode;
};

// Size: 0x130
struct FChaosVDManifoldPoint {
    /* 0x0000 */ bool bDisabled;
    /* 0x0000 */ bool bWasRestored;
    /* 0x0000 */ bool bWasReplaced;
    /* 0x0000 */ bool bHasStaticFrictionAnchor;
    /* 0x0000 */ bool bIsValid;
    /* 0x0000 */ bool bInsideStaticFrictionCone;
    /* 0x0008 */ FVector NetPushOut;
    /* 0x0020 */ FVector NetImpulse;
    /* 0x0038 */ float TargetPhi;
    /* 0x003c */ float InitialPhi;
    /* 0x0040 */ FVector ShapeAnchorPoints[2];
    /* 0x0070 */ FVector InitialShapeContactPoints[2];
    /* 0x00a0 */ FChaosVDContactPoint ContactPoint;
    /* 0x00f8 */ FVector ShapeContactPoints[2];
};

// Size: 0x50
struct FChaosVDMultiSolverDebugShapeDataContainer {
};

// Size: 0x40
struct FChaosVDParticleBounds : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MMin;
    /* 0x0028 */ FVector MMax;
};

// Size: 0xb0
struct FChaosVDParticleCluster : public FChaosVDWrapperDataBase {
    /* 0x0010 */ int32_t ParentParticleID;
    /* 0x0014 */ int32_t NumChildren;
    /* 0x0020 */ FTransform ChildToParent;
    /* 0x0080 */ int32_t ClusterGroupIndex;
    /* 0x0084 */ bool bInternalCluster;
    /* 0x0088 */ float CollisionImpulse;
    /* 0x008c */ float ExternalStrains;
    /* 0x0090 */ float InternalStrains;
    /* 0x0094 */ float Strain;
    /* 0x0098 */ TArray<FChaosVDConnectivityEdge> ConnectivityEdges;
    /* 0x00a8 */ bool bIsAnchored;
    /* 0x00a9 */ bool bUnbreakable;
    /* 0x00aa */ bool bIsChildToParentLocked;
};

// Size: 0x3f0
struct FChaosVDParticleDataWrapper : public FChaosVDWrapperDataBase {
    /* 0x0010 */ int32_t DirtyFlagsBits;
    /* 0x0014 */ EChaosVDParticleContext ParticleContext;
    /* 0x0018 */ uint32_t GeometryHash;
    /* 0x0020 */ FString DebugName;
    /* 0x0038 */ int32_t ParticleIndex;
    /* 0x003c */ int32_t SolverId;
    /* 0x0040 */ EChaosVDParticleType Type;
    /* 0x0050 */ FChaosVDParticlePositionRotation ParticlePositionRotation;
    /* 0x00a0 */ FChaosVDParticleVelocities ParticleVelocities;
    /* 0x00e0 */ FChaosVDParticleBounds ParticleInflatedBounds;
    /* 0x0120 */ FChaosVDKinematicTarget ParticleKinematicTarget;
    /* 0x0170 */ FChaosVDVSmooth ParticleVWSmooth;
    /* 0x01b0 */ FChaosVDParticleDynamics ParticleDynamics;
    /* 0x0220 */ FChaosVDParticleDynamicMisc ParticleDynamicsMisc;
    /* 0x0290 */ FChaosVDParticleMassProps ParticleMassProps;
    /* 0x0320 */ FChaosVDParticleCluster ParticleCluster;
    /* 0x03d0 */ TArray<FChaosVDShapeCollisionData> CollisionDataPerShape;
};

// Size: 0x70
struct FChaosVDParticleDynamicMisc : public FChaosVDWrapperDataBase {
    /* 0x0010 */ double MLinearEtherDrag;
    /* 0x0018 */ double MAngularEtherDrag;
    /* 0x0020 */ double MMaxLinearSpeedSq;
    /* 0x0028 */ double MMaxAngularSpeedSq;
    /* 0x0030 */ float MInitialOverlapDepenetrationVelocity;
    /* 0x0034 */ float MSleepThresholdMultiplier;
    /* 0x0038 */ int32_t MCollisionGroup;
    /* 0x003c */ EChaosVDObjectStateType MObjectState;
    /* 0x003d */ EChaosVDSleepType MSleepType;
    /* 0x0040 */ uint32_t MCollisionConstraintFlag;
    /* 0x0048 */ FChaosVDFRigidParticleControlFlags MControlFlags;
    /* 0x0068 */ bool bDisabled;
};

// Size: 0x70
struct FChaosVDParticleDynamics : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MAcceleration;
    /* 0x0028 */ FVector MAngularAcceleration;
    /* 0x0040 */ FVector MLinearImpulseVelocity;
    /* 0x0058 */ FVector MAngularImpulseVelocity;
};

// Size: 0x90
struct FChaosVDParticleMassProps : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MCenterOfMass;
    /* 0x0030 */ FQuat MRotationOfMass;
    /* 0x0050 */ FVector MI;
    /* 0x0068 */ FVector MInvI;
    /* 0x0080 */ double MM;
    /* 0x0088 */ double MInvM;
};

// Size: 0x28
struct FChaosVDParticlePairMidPhase {
    /* 0x0000 */ int32_t SolverId;
    /* 0x0004 */ EChaosVDMidPhaseType MidPhaseType;
    /* 0x0005 */ bool bIsActive;
    /* 0x0005 */ bool bIsCCD;
    /* 0x0005 */ bool bIsCCDActive;
    /* 0x0005 */ bool bIsSleeping;
    /* 0x0005 */ bool bIsModified;
    /* 0x0008 */ int32_t LastUsedEpoch;
    /* 0x000c */ int32_t Particle0Idx;
    /* 0x0010 */ int32_t Particle1Idx;
    /* 0x0018 */ TArray<FChaosVDConstraint> Constraints;
};

// Size: 0x50
struct FChaosVDParticlePositionRotation : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MX;
    /* 0x0030 */ FQuat MR;
};

// Size: 0x40
struct FChaosVDParticleVelocities : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MV;
    /* 0x0028 */ FVector MW;
};

// Size: 0x180
struct FChaosVDQueryDataWrapper {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ int32_t ParentQueryID;
    /* 0x0008 */ int32_t WorldSolverID;
    /* 0x000c */ bool bIsRetryQuery;
    /* 0x0020 */ FQuat GeometryOrientation;
    /* 0x0040 */ EChaosVDSceneQueryType Type;
    /* 0x0044 */ EChaosVDSceneQueryMode Mode;
    /* 0x0048 */ FVector StartLocation;
    /* 0x0060 */ FVector EndLocation;
    /* 0x0078 */ int32_t CollisionChannel;
    /* 0x0080 */ FChaosVDCollisionQueryParams CollisionQueryParams;
    /* 0x00e8 */ FChaosVDCollisionResponseParams CollisionResponseParams;
    /* 0x0128 */ FChaosVDCollisionObjectQueryParams CollisionObjectQueryParams;
    /* 0x0150 */ TArray<FChaosVDQueryVisitStep> Hits;
};

// Size: 0x58
struct FChaosVDQueryFastData : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector Dir;
    /* 0x0028 */ FVector InvDir;
    /* 0x0040 */ double CurrentLength;
    /* 0x0048 */ double InvCurrentLength;
    /* 0x0050 */ bool bParallel0;
    /* 0x0050 */ bool bParallel1;
    /* 0x0050 */ bool bParallel2;
};

// Size: 0x68
struct FChaosVDQueryHitData : public FChaosVDWrapperDataBase {
    /* 0x0010 */ float Distance;
    /* 0x0014 */ int32_t FaceIdx;
    /* 0x0018 */ uint16_t Flags;
    /* 0x0020 */ FVector WorldPosition;
    /* 0x0038 */ FVector WorldNormal;
    /* 0x0050 */ FVector FaceNormal;
};

// Size: 0x150
struct FChaosVDQueryVisitStep : public FChaosVDWrapperDataBase {
    /* 0x0014 */ EChaosVDSceneQueryVisitorType Type;
    /* 0x0018 */ uint32_t ShapeIndex;
    /* 0x001c */ int32_t ParticleIndex;
    /* 0x0020 */ FTransform ParticleTransform;
    /* 0x0080 */ FChaosVDQueryFastData QueryFastData;
    /* 0x00d8 */ EChaosVDCollisionQueryHitType HitType;
    /* 0x00e0 */ FChaosVDQueryHitData HitData;
    /* 0x0148 */ EChaosVDSQVisitRejectReason RejectReason;
};

// Size: 0xa0
struct FChaosVDSceneQueriesDataContainer {
};

// Size: 0x2c
struct FChaosVDShapeCollisionData {
    /* 0x0000 */ EChaosVDCollisionTraceFlag CollisionTraceType;
    /* 0x0004 */ bool bSimCollision;
    /* 0x0004 */ bool bQueryCollision;
    /* 0x0004 */ bool bIsProbe;
    /* 0x0008 */ FChaosVDCollisionFilterData QueryData;
    /* 0x0018 */ FChaosVDCollisionFilterData SimData;
    /* 0x0028 */ bool bIsComplex;
    /* 0x0029 */ bool bIsValid;
};

// Size: 0x38
struct FChaosVDTraceDetails {
    /* 0x0000 */ FGuid TraceGuid;
    /* 0x0010 */ FGuid SessionGuid;
    /* 0x0020 */ FString TraceTarget;
    /* 0x0030 */ bool bIsConnected;
    /* 0x0031 */ EChaosVDRecordingMode Mode;
};

// Size: 0x40
struct FChaosVDVSmooth : public FChaosVDWrapperDataBase {
    /* 0x0010 */ FVector MV;
    /* 0x0028 */ FVector MW;
};

// Size: 0x10
struct FChaosVDWrapperDataBase {
    /* 0x0008 */ bool bHasValidData;
};

enum class EChaosVDAABBTreeNodeFlags {
    None = 0,
    IsLeaf = 1,
    IsDirty = 2,
    EChaosVDAABBTreeNodeFlags_MAX = 3,
};

enum class EChaosVDAccelerationStructureType {
    BoundingVolume = 0,
    AABBTree = 1,
    AABBTreeBV = 2,
    Collection = 3,
    Unknown = 4,
    EChaosVDAccelerationStructureType_MAX = 5,
};

enum class EChaosVDCollisionQueryHitType {
    None = 0,
    Touch = 1,
    Block = 2,
    EChaosVDCollisionQueryHitType_MAX = 3,
};

enum class EChaosVDCollisionQueryParamsFlags {
    None = 0,
    TraceComplex = 1,
    FindInitialOverlaps = 2,
    ReturnFaceIndex = 4,
    ReturnPhysicalMaterial = 8,
    IgnoreBlocks = 16,
    IgnoreTouches = 32,
    SkipNarrowPhase = 64,
    TraceIntoSubComponents = 128,
    ReplaceHitWithSubComponents = 256,
    EChaosVDCollisionQueryParamsFlags_MAX = 257,
};

enum class EChaosVDCollisionShapeDataFlags {
    None = 0,
    SimCollision = 1,
    QueryCollision = 2,
    IsProbe = 4,
    EChaosVDCollisionShapeDataFlags_MAX = 5,
};

enum class EChaosVDCollisionTraceFlag {
    UseDefault = 0,
    UseSimpleAndComplex = 1,
    UseSimpleAsComplex = 2,
    UseComplexAsSimple = 3,
    MAX = 4,
};

enum class EChaosVDConstraintFlags {
    None = 0,
    IsCurrent = 1,
    Disabled = 2,
    UseManifold = 4,
    UseIncrementalManifold = 8,
    CanRestoreManifold = 16,
    WasManifoldRestored = 32,
    IsQuadratic0 = 64,
    IsQuadratic1 = 128,
    IsProbe = 256,
    CCDEnabled = 512,
    CCDSweepEnabled = 1024,
    ModifierApplied = 2048,
    MaterialSet = 4096,
    EChaosVDConstraintFlags_MAX = 4097,
};

enum class EChaosVDContactPointType {
    Unknown = 0,
    VertexPlane = 1,
    EdgeEdge = 2,
    PlaneVertex = 3,
    VertexVertex = 4,
    EChaosVDContactPointType_MAX = 5,
};

enum class EChaosVDContactShapesType {
    Unknown = 0,
    SphereSphere = 1,
    SphereCapsule = 2,
    SphereBox = 3,
    SphereConvex = 4,
    SphereTriMesh = 5,
    SphereHeightField = 6,
    SpherePlane = 7,
    CapsuleCapsule = 8,
    CapsuleBox = 9,
    CapsuleConvex = 10,
    CapsuleTriMesh = 11,
    CapsuleHeightField = 12,
    BoxBox = 13,
    BoxConvex = 14,
    BoxTriMesh = 15,
    BoxHeightField = 16,
    BoxPlane = 17,
    ConvexConvex = 18,
    ConvexTriMesh = 19,
    ConvexHeightField = 20,
    GenericConvexConvex = 21,
    LevelSetLevelSet = 22,
    NumShapesTypes = 23,
    EChaosVDContactShapesType_MAX = 24,
};

enum class EChaosVDGTJointStateFlags {
    None = 0,
    IsBreaking = 1,
    IsBroken = 2,
    DriveTargetChanged = 4,
    IsViolating = 8,
    EChaosVDGTJointStateFlags_MAX = 9,
};

enum class EChaosVDJointForceMode {
    Acceleration = 0,
    Force = 1,
    EChaosVDJointForceMode_MAX = 2,
};

enum class EChaosVDJointMotionType {
    Free = 0,
    Limited = 1,
    Locked = 2,
    EChaosVDJointMotionType_MAX = 3,
};

enum class EChaosVDJointReSimType {
    FullResim = 0,
    ResimAsFollower = 1,
    EChaosVDJointReSimType_MAX = 2,
};

enum class EChaosVDJointSettingsFlags {
    None = 0,
    CollisionEnabled = 1,
    MassConditioningEnabled = 2,
    AngularSLerpPositionDriveEnabled = 4,
    AngularSLerpVelocityDriveEnabled = 8,
    AngularTwistPositionDriveEnabled = 16,
    AngularTwistVelocityDriveEnabled = 32,
    AngularSwingPositionDriveEnabled = 64,
    AngularSwingVelocityDriveEnabled = 128,
    SoftLinearLimitsEnabled = 256,
    SoftTwistLimitsEnabled = 512,
    SoftSwingLimitsEnabled = 1024,
    LinearPositionDriveEnabled0 = 2048,
    LinearPositionDriveEnable1 = 4096,
    LinearPositionDriveEnable2 = 8192,
    LinearVelocityDriveEnabled0 = 16384,
    LinearVelocityDriveEnabled1 = 32768,
    LinearVelocityDriveEnabled2 = 65536,
    UseLinearSolver = 131072,
    EChaosVDJointSettingsFlags_MAX = 131073,
};

enum class EChaosVDJointSolverSettingsFlags {
    None = 0,
    UseLinearSolver = 1,
    SortEnabled = 2,
    SolvePositionLast = 4,
    UsePositionBasedDrives = 8,
    EnableTwistLimits = 16,
    EnableSwingLimits = 32,
    EnableDrives = 64,
    EChaosVDJointSolverSettingsFlags_MAX = 65,
};

enum class EChaosVDJointStateFlags {
    None = 0,
    Disabled = 1,
    Broken = 2,
    Breaking = 4,
    DriveTargetChanged = 8,
    EnabledDuringResim = 16,
    EChaosVDJointStateFlags_MAX = 17,
};

enum class EChaosVDJointSyncType {
    InSync = 0,
    HardDesync = 1,
    EChaosVDJointSyncType_MAX = 2,
};

enum class EChaosVDKinematicTargetMode {
    None = 0,
    Reset = 1,
    Position = 2,
    Velocity = 3,
    EChaosVDKinematicTargetMode_MAX = 4,
};

enum class EChaosVDManifoldPointFlags {
    None = 0,
    Disabled = 1,
    WasRestored = 2,
    WasReplaced = 4,
    HasStaticFrictionAnchor = 8,
    IsValid = 16,
    InsideStaticFrictionCone = 32,
    EChaosVDManifoldPointFlags_MAX = 33,
};

enum class EChaosVDMidPhaseFlags {
    None = 0,
    IsActive = 1,
    IsCCD = 2,
    IsCCDActive = 4,
    IsSleeping = 8,
    IsModified = 16,
    EChaosVDMidPhaseFlags_MAX = 17,
};

enum class EChaosVDMidPhaseType {
    Generic = 0,
    ShapePair = 1,
    SphereApproximation = 2,
    Unknown = 3,
    EChaosVDMidPhaseType_MAX = 4,
};

enum class EChaosVDObjectStateType {
    Uninitialized = 0,
    Sleeping = 1,
    Kinematic = 2,
    Static = 3,
    Dynamic = 4,
    Count = 5,
    EChaosVDObjectStateType_MAX = 6,
};

enum class EChaosVDParticleContext {
    Invalid = 0,
    GameThread = 1,
    PhysicsThread = 2,
    EChaosVDParticleContext_MAX = 3,
};

enum class EChaosVDParticleType {
    Static = 0,
    Kinematic = 1,
    Rigid = 2,
    Clustered = 3,
    StaticMesh = 4,
    SkeletalMesh = 5,
    GeometryCollection = 6,
    Unknown = 7,
    EChaosVDParticleType_MAX = 8,
};

enum class EChaosVDPlasticityType {
    Free = 0,
    Shrink = 1,
    Grow = 2,
    EChaosVDPlasticityType_MAX = 3,
};

enum class EChaosVDQueryFastDataParallelFlags {
    None = 0,
    Parallel0 = 1,
    Parallel1 = 2,
    Parallel2 = 4,
    EChaosVDQueryFastDataParallelFlags_MAX = 5,
};

enum class EChaosVDRecordingMode {
    Invalid = 0,
    Live = 1,
    File = 2,
    EChaosVDRecordingMode_MAX = 3,
};

enum class EChaosVDSQHitFlags {
    None = 0,
    Position = 1,
    Normal = 2,
    Distance = 4,
    UV = 8,
    MTD = 512,
    FaceIndex = 1024,
    EChaosVDSQHitFlags_MAX = 1025,
};

enum class EChaosVDSQVisitRejectReason {
    None = 0,
    NoHit = 1,
    PreFilter = 2,
    PostFilter = 3,
    ColocatedHitHasWorseNormal = 4,
    FailedFastBoundTest = 5,
    EChaosVDSQVisitRejectReason_MAX = 6,
};

enum class EChaosVDSceneQueryMode {
    Single = 0,
    Multi = 1,
    Test = 2,
    Invalid = 3,
    EChaosVDSceneQueryMode_MAX = 4,
};

enum class EChaosVDSceneQueryType {
    Invalid = 0,
    Sweep = 1,
    Overlap = 2,
    RayCast = 3,
    EChaosVDSceneQueryType_MAX = 4,
};

enum class EChaosVDSceneQueryVisitorType {
    Invalid = 0,
    BroadPhase = 1,
    NarrowPhase = 2,
    EChaosVDSceneQueryVisitorType_MAX = 3,
};

enum class EChaosVDSleepType {
    MaterialSleep = 0,
    NeverSleep = 1,
    EChaosVDSleepType_MAX = 2,
};

// Size: 0x14
struct FCameraFilmbackSettings {
    /* 0x0000 */ float SensorWidth;
    /* 0x0004 */ float SensorHeight;
    /* 0x0008 */ float SensorHorizontalOffset;
    /* 0x000c */ float SensorVerticalOffset;
    /* 0x0010 */ float SensorAspectRatio;
};

// Size: 0x60
struct FCameraFocusSettings {
    /* 0x0000 */ ECameraFocusMethod FocusMethod;
    /* 0x0004 */ float ManualFocusDistance;
    /* 0x0008 */ FCameraTrackingFocusSettings TrackingFocusSettings;
    /* 0x0050 */ bool bSmoothFocusChanges;
    /* 0x0054 */ float FocusSmoothingInterpSpeed;
    /* 0x0058 */ float FocusOffset;
};

// Size: 0x1c
struct FCameraLensSettings {
    /* 0x0000 */ float MinFocalLength;
    /* 0x0004 */ float MaxFocalLength;
    /* 0x0008 */ float MinFStop;
    /* 0x000c */ float MaxFStop;
    /* 0x0010 */ float MinimumFocusDistance;
    /* 0x0014 */ float SqueezeFactor;
    /* 0x0018 */ int32_t DiaphragmBladeCount;
};

// Size: 0x68
struct FCameraLookatTrackingSettings {
    /* 0x0000 */ bool bEnableLookAtTracking;
    /* 0x0000 */ bool bDrawDebugLookAtTrackingPosition;
    /* 0x0004 */ float LookAtTrackingInterpSpeed;
    /* 0x0020 */ TSoftObjectPtr<AActor> ActorToTrack;
    /* 0x0048 */ FVector RelativeOffset;
    /* 0x0060 */ bool bAllowRoll;
};

// Size: 0x2d8
class ACameraRig_Crane : public AActor {
    /* 0x02a8 */ float CranePitch;
    /* 0x02ac */ float CraneYaw;
    /* 0x02b0 */ float CraneArmLength;
    /* 0x02b4 */ bool bLockMountPitch;
    /* 0x02b5 */ bool bLockMountYaw;
    /* 0x02b8 */ USceneComponent* TransformComponent;
    /* 0x02c0 */ USceneComponent* CraneYawControl;
    /* 0x02c8 */ USceneComponent* CranePitchControl;
    /* 0x02d0 */ USceneComponent* CraneCameraMount;
};

// Size: 0x2c8
class ACameraRig_Rail : public AActor {
    /* 0x02a8 */ float CurrentPositionOnRail;
    /* 0x02ac */ bool bLockOrientationToRail;
    /* 0x02b0 */ USceneComponent* TransformComponent;
    /* 0x02b8 */ USplineComponent* RailSplineComponent;
    /* 0x02c0 */ USceneComponent* RailCameraMount;

    USplineComponent* GetRailSplineComponent();
};

// Size: 0x48
struct FCameraTrackingFocusSettings {
    /* 0x0000 */ TSoftObjectPtr<AActor> ActorToTrack;
    /* 0x0028 */ FVector RelativeOffset;
    /* 0x0040 */ bool bDrawDebugTrackingFocusPoint;
};

// Size: 0xab0
class ACineCameraActor : public ACameraActor {
    /* 0x0a30 */ FCameraLookatTrackingSettings LookatTrackingSettings;

    UCineCameraComponent* GetCineCameraComponent() const;
};

// Size: 0xba0
class UCineCameraComponent : public UCameraComponent {
    /* 0x0a80 */ FCameraFilmbackSettings FilmbackSettings;
    /* 0x0a94 */ FCameraFilmbackSettings Filmback;
    /* 0x0aa8 */ FCameraLensSettings LensSettings;
    /* 0x0ac8 */ FCameraFocusSettings FocusSettings;
    /* 0x0b28 */ FPlateCropSettings CropSettings;
    /* 0x0b2c */ float CurrentFocalLength;
    /* 0x0b30 */ float CurrentAperture;
    /* 0x0b34 */ float CurrentFocusDistance;
    /* 0x0b38 */ bool bOverride_CustomNearClippingPlane;
    /* 0x0b3c */ float CustomNearClippingPlane;
    /* 0x0b48 */ TArray<FNamedFilmbackPreset> FilmbackPresets;
    /* 0x0b58 */ TArray<FNamedLensPreset> LensPresets;
    /* 0x0b68 */ FString DefaultFilmbackPresetName;
    /* 0x0b78 */ FString DefaultFilmbackPreset;
    /* 0x0b88 */ FString DefaultLensPresetName;
    /* 0x0b98 */ float DefaultLensFocalLength;
    /* 0x0b9c */ float DefaultLensFStop;

    FString GetCropPresetName() const;
    FString GetDefaultFilmbackPresetName() const;
    FString GetFilmbackPresetName() const;
    static TArray<FNamedFilmbackPreset> GetFilmbackPresetsCopy();
    float GetHorizontalFieldOfView() const;
    float GetHorizontalProjectionOffset() const;
    FString GetLensPresetName() const;
    static TArray<FNamedLensPreset> GetLensPresetsCopy();
    float GetVerticalFieldOfView() const;
    float GetVerticalProjectionOffset() const;
    void SetCropPresetByName(FString InPresetName);
    void SetCropSettings(const FPlateCropSettings& NewCropSettings);
    void SetCurrentAperture(const float NewCurrentAperture);
    void SetCurrentFocalLength(float InFocalLength);
    void SetCustomNearClippingPlane(const float NewCustomNearClippingPlane);
    void SetFilmback(const FCameraFilmbackSettings& NewFilmback);
    void SetFilmbackPresetByName(FString InPresetName);
    void SetFocusSettings(const FCameraFocusSettings& NewFocusSettings);
    void SetLensPresetByName(FString InPresetName);
    void SetLensSettings(const FCameraLensSettings& NewLensSettings);
};

// Size: 0xb0
class UCineCameraSettings : public UDeveloperSettings {
    /* 0x0038 */ FString DefaultLensPresetName;
    /* 0x0048 */ float DefaultLensFocalLength;
    /* 0x004c */ float DefaultLensFStop;
    /* 0x0050 */ TArray<FNamedLensPreset> LensPresets;
    /* 0x0060 */ FString DefaultFilmbackPreset;
    /* 0x0070 */ TArray<FNamedFilmbackPreset> FilmbackPresets;
    /* 0x0080 */ FString DefaultCropPresetName;
    /* 0x0090 */ TArray<FNamedPlateCropPreset> CropPresets;

    static UCineCameraSettings* GetCineCameraSettings();
    bool GetCropPresetByName(const FString PresetName, FPlateCropSettings& CropSettings);
    TArray<FString> GetCropPresetNames() const;
    bool GetFilmbackPresetByName(const FString PresetName, FCameraFilmbackSettings& FilmbackSettings);
    TArray<FString> GetFilmbackPresetNames() const;
    bool GetLensPresetByName(const FString PresetName, FCameraLensSettings& LensSettings);
    TArray<FString> GetLensPresetNames() const;
    void SetCropPresets(const TArray<FNamedPlateCropPreset>& InCropPresets);
    void SetDefaultCropPresetName(const FString InDefaultCropPresetName);
    void SetDefaultFilmbackPreset(const FString InDefaultFilmbackPreset);
    void SetDefaultLensFStop(const float InDefaultLensFStop);
    void SetDefaultLensFocalLength(const float InDefaultLensFocalLength);
    void SetDefaultLensPresetName(const FString InDefaultLensPresetName);
    void SetFilmbackPresets(const TArray<FNamedFilmbackPreset>& InFilmbackPresets);
    void SetLensPresets(const TArray<FNamedLensPreset>& InLensPresets);
};

enum class ECameraFocusMethod {
    DoNotOverride = 0,
    Manual = 1,
    Tracking = 2,
    Disable = 3,
    MAX = 4,
};

// Size: 0x38
struct FNamedFilmbackPreset {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FText DisplayName;
    /* 0x0020 */ FCameraFilmbackSettings FilmbackSettings;
};

// Size: 0x30
struct FNamedLensPreset {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FCameraLensSettings LensSettings;
};

// Size: 0x18
struct FNamedPlateCropPreset {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FPlateCropSettings CropSettings;
};

// Size: 0x4
struct FPlateCropSettings {
    /* 0x0000 */ float AspectRatio;
};

// Size: 0x28
class UClothConfigCommon : public UClothConfigBase {
};

// Size: 0x130
struct FClothConfig_Legacy {
    /* 0x0000 */ EClothingWindMethod_Legacy WindMethod;
    /* 0x0004 */ FClothConstraintSetup_Legacy VerticalConstraintConfig;
    /* 0x0014 */ FClothConstraintSetup_Legacy HorizontalConstraintConfig;
    /* 0x0024 */ FClothConstraintSetup_Legacy BendConstraintConfig;
    /* 0x0034 */ FClothConstraintSetup_Legacy ShearConstraintConfig;
    /* 0x0044 */ float SelfCollisionRadius;
    /* 0x0048 */ float SelfCollisionStiffness;
    /* 0x004c */ float SelfCollisionCullScale;
    /* 0x0050 */ FVector Damping;
    /* 0x0068 */ float Friction;
    /* 0x006c */ float WindDragCoefficient;
    /* 0x0070 */ float WindLiftCoefficient;
    /* 0x0078 */ FVector LinearDrag;
    /* 0x0090 */ FVector AngularDrag;
    /* 0x00a8 */ FVector LinearInertiaScale;
    /* 0x00c0 */ FVector AngularInertiaScale;
    /* 0x00d8 */ FVector CentrifugalInertiaScale;
    /* 0x00f0 */ float SolverFrequency;
    /* 0x00f4 */ float StiffnessFrequency;
    /* 0x00f8 */ float GravityScale;
    /* 0x0100 */ FVector GravityOverride;
    /* 0x0118 */ bool bUseGravityOverride;
    /* 0x011c */ float TetherStiffness;
    /* 0x0120 */ float TetherLimit;
    /* 0x0124 */ float CollisionThickness;
    /* 0x0128 */ float AnimDriveSpringStiffness;
    /* 0x012c */ float AnimDriveDamperStiffness;
};

// Size: 0x10
struct FClothConstraintSetup_Legacy {
    /* 0x0000 */ float Stiffness;
    /* 0x0004 */ float StiffnessMultiplier;
    /* 0x0008 */ float StretchLimit;
    /* 0x000c */ float CompressionLimit;
};

// Size: 0x158
struct FClothLODDataCommon {
    /* 0x0000 */ FClothPhysicalMeshData PhysicalMeshData;
    /* 0x0128 */ bool bUseMultipleInfluences;
    /* 0x012c */ float SkinningKernelRadius;
    /* 0x0130 */ bool bSmoothTransition;
};

// Size: 0x1b8
class UClothLODDataCommon_Legacy : public UObject {
    /* 0x0028 */ UClothPhysicalMeshDataBase_Legacy* PhysicalMeshData;
    /* 0x0030 */ FClothPhysicalMeshData ClothPhysicalMeshData;
    /* 0x0158 */ FClothCollisionData CollisionData;
};

// Size: 0x30
struct FClothParameterMask_Legacy {
    /* 0x0000 */ FName MaskName;
    /* 0x0008 */ EWeightMapTargetCommon CurrentTarget;
    /* 0x000c */ float MaxValue;
    /* 0x0010 */ float MinValue;
    /* 0x0018 */ TArray<float> Values;
    /* 0x0028 */ bool bEnabled;
};

// Size: 0x128
struct FClothPhysicalMeshData {
    /* 0x0000 */ TArray<FVector3f> Vertices;
    /* 0x0010 */ TArray<FVector3f> Normals;
    /* 0x0020 */ TArray<uint32_t> Indices;
    /* 0x0030 */ TMap<uint32_t, FPointWeightMap> WeightMaps;
    /* 0x0080 */ TArray<float> InverseMasses;
    /* 0x0090 */ TArray<FClothVertBoneData> BoneData;
    /* 0x00a0 */ TSet<int32_t> SelfCollisionVertexSet;
    /* 0x00f0 */ FClothTetherData EuclideanTethers;
    /* 0x0100 */ FClothTetherData GeodesicTethers;
    /* 0x0110 */ int32_t MaxBoneWeights;
    /* 0x0114 */ int32_t NumFixedVerts;
    /* 0x0118 */ TArray<uint32_t> SelfCollisionIndices;
};

// Size: 0x28
class UClothSharedConfigCommon : public UClothConfigCommon {
};

// Size: 0x10
struct FClothTetherData {
};

// Size: 0xd8
class UClothingAssetCommon : public UClothingAssetBase {
    /* 0x0038 */ UPhysicsAsset* PhysicsAsset;
    /* 0x0040 */ TMap<FName, UClothConfigBase*> ClothConfigs;
    /* 0x0090 */ TArray<FClothLODDataCommon> LODData;
    /* 0x00a0 */ TArray<int32_t> LodMap;
    /* 0x00b0 */ TArray<FName> UsedBoneNames;
    /* 0x00c0 */ TArray<int32_t> UsedBoneIndices;
    /* 0x00d0 */ int32_t ReferenceBoneIndex;
};

// Size: 0x28
class UClothingAssetCustomData : public UObject {
};

enum class EClothMassMode {
    UniformMass = 0,
    TotalMass = 1,
    Density = 2,
    MaxClothMassMode = 3,
    EClothMassMode_MAX = 4,
};

enum class EClothingWindMethod_Legacy {
    Legacy = 0,
    Accurate = 1,
    EClothingWindMethod_MAX = 2,
};

enum class EWeightMapTargetCommon {
    None = 0,
    MaxDistance = 1,
    BackstopDistance = 2,
    BackstopRadius = 3,
    AnimDriveStiffness = 4,
    AnimDriveDamping_DEPRECATED = 5,
    FirstUserTarget = 6,
    LastUserTarget = 200,
    TetherEndsMask = 201,
    EWeightMapTargetCommon_MAX = 202,
};

// Size: 0x10
struct FPointWeightMap {
    /* 0x0000 */ TArray<float> Values;
};

// Size: 0x40
struct FClothCollisionData {
    /* 0x0000 */ TArray<FClothCollisionPrim_Sphere> Spheres;
    /* 0x0010 */ TArray<FClothCollisionPrim_SphereConnection> SphereConnections;
    /* 0x0020 */ TArray<FClothCollisionPrim_Convex> Convexes;
    /* 0x0030 */ TArray<FClothCollisionPrim_Box> Boxes;
};

// Size: 0x60
struct FClothCollisionPrim_Box {
    /* 0x0000 */ FVector LocalPosition;
    /* 0x0020 */ FQuat LocalRotation;
    /* 0x0040 */ FVector HalfExtents;
    /* 0x0058 */ int32_t BoneIndex;
};

// Size: 0x28
struct FClothCollisionPrim_Convex {
    /* 0x0000 */ TArray<FClothCollisionPrim_ConvexFace> Faces;
    /* 0x0010 */ TArray<FVector> SurfacePoints;
    /* 0x0020 */ int32_t BoneIndex;
};

// Size: 0x30
struct FClothCollisionPrim_ConvexFace {
    /* 0x0000 */ FPlane Plane;
    /* 0x0020 */ TArray<int32_t> Indices;
};

// Size: 0x20
struct FClothCollisionPrim_Sphere {
    /* 0x0000 */ int32_t BoneIndex;
    /* 0x0004 */ float Radius;
    /* 0x0008 */ FVector LocalPosition;
};

// Size: 0x20
struct FClothCollisionPrim_SphereConnection {
    /* 0x0000 */ int32_t SphereIndices[2];
    /* 0x0008 */ FVector OneSidedPlaneNormal;
};

// Size: 0x28
class UClothConfigBase : public UObject {
};

// Size: 0xe0
class UClothPhysicalMeshDataBase_Legacy : public UObject {
    /* 0x0028 */ TArray<FVector3f> Vertices;
    /* 0x0038 */ TArray<FVector3f> Normals;
    /* 0x0048 */ TArray<uint32_t> Indices;
    /* 0x0058 */ TArray<float> InverseMasses;
    /* 0x0068 */ TArray<FClothVertBoneData> BoneData;
    /* 0x0078 */ int32_t NumFixedVerts;
    /* 0x007c */ int32_t MaxBoneWeights;
    /* 0x0080 */ TArray<uint32_t> SelfCollisionIndices;
};

// Size: 0x28
class UClothSharedSimConfigBase : public UObject {
};

// Size: 0x4c
struct FClothVertBoneData {
    /* 0x0000 */ int32_t NumInfluences;
    /* 0x0004 */ uint16_t BoneIndices[12];
    /* 0x001c */ float BoneWeights[12];
};

// Size: 0x38
class UClothingAssetBase : public UObject {
    /* 0x0028 */ FGuid AssetGuid;
};

// Size: 0x30
class UClothingInteractor : public UObject {
};

// Size: 0x28
class UClothingSimulationFactory : public UObject {
};

// Size: 0x90
class UClothingSimulationInteractor : public UObject {
    /* 0x0028 */ TMap<FName, UClothingInteractor*> ClothingInteractors;

    void ClothConfigUpdated();
    void DisableGravityOverride();
    void EnableGravityOverride(const FVector& InVector);
    UClothingInteractor* GetClothingInteractor(FString ClothingAssetName) const;
    int32_t GetNumCloths() const;
    int32_t GetNumDynamicParticles() const;
    int32_t GetNumIterations() const;
    int32_t GetNumKinematicParticles() const;
    int32_t GetNumSubsteps() const;
    float GetSimulationTime() const;
    void PhysicsAssetUpdated();
    void SetAnimDriveSpringStiffness(float InStiffness);
    void SetMaxNumIterations(int32_t MaxNumIterations);
    void SetNumIterations(int32_t NumIterations);
    void SetNumSubsteps(int32_t NumSubSteps);
};

enum class EClothingTeleportMode {
    None = 0,
    Teleport = 1,
    TeleportAndReset = 2,
    HardReset = 3,
    EClothingTeleportMode_MAX = 4,
};

// Size: 0x1a0
class UClothConfigNv : public UClothConfigCommon {
    /* 0x0028 */ EClothingWindMethodNv ClothingWindMethod;
    /* 0x002c */ FClothConstraintSetupNv VerticalConstraint;
    /* 0x003c */ FClothConstraintSetupNv HorizontalConstraint;
    /* 0x004c */ FClothConstraintSetupNv BendConstraint;
    /* 0x005c */ FClothConstraintSetupNv ShearConstraint;
    /* 0x006c */ float SelfCollisionRadius;
    /* 0x0070 */ float SelfCollisionStiffness;
    /* 0x0074 */ float SelfCollisionCullScale;
    /* 0x0078 */ FVector Damping;
    /* 0x0090 */ float Friction;
    /* 0x0094 */ float WindDragCoefficient;
    /* 0x0098 */ float WindLiftCoefficient;
    /* 0x00a0 */ FVector LinearDrag;
    /* 0x00b8 */ FVector AngularDrag;
    /* 0x00d0 */ FVector LinearInertiaScale;
    /* 0x00e8 */ FVector AngularInertiaScale;
    /* 0x0100 */ FVector CentrifugalInertiaScale;
    /* 0x0118 */ float SolverFrequency;
    /* 0x011c */ float StiffnessFrequency;
    /* 0x0120 */ float GravityScale;
    /* 0x0128 */ FVector GravityOverride;
    /* 0x0140 */ bool bUseGravityOverride;
    /* 0x0144 */ float TetherStiffness;
    /* 0x0148 */ float TetherLimit;
    /* 0x014c */ float CollisionThickness;
    /* 0x0150 */ float AnimDriveSpringStiffness;
    /* 0x0154 */ float AnimDriveDamperStiffness;
    /* 0x0158 */ EClothingWindMethod_Legacy WindMethod;
    /* 0x015c */ FClothConstraintSetup_Legacy VerticalConstraintConfig;
    /* 0x016c */ FClothConstraintSetup_Legacy HorizontalConstraintConfig;
    /* 0x017c */ FClothConstraintSetup_Legacy BendConstraintConfig;
    /* 0x018c */ FClothConstraintSetup_Legacy ShearConstraintConfig;
};

// Size: 0x10
struct FClothConstraintSetupNv {
    /* 0x0000 */ float Stiffness;
    /* 0x0004 */ float StiffnessMultiplier;
    /* 0x0008 */ float StretchLimit;
    /* 0x000c */ float CompressionLimit;
};

// Size: 0x120
class UClothPhysicalMeshDataNv_Legacy : public UClothPhysicalMeshDataBase_Legacy {
    /* 0x00e0 */ TArray<float> MaxDistances;
    /* 0x00f0 */ TArray<float> BackstopDistances;
    /* 0x0100 */ TArray<float> BackstopRadiuses;
    /* 0x0110 */ TArray<float> AnimDriveMultipliers;
};

// Size: 0x28
class UClothingSimulationFactoryNv : public UClothingSimulationFactory {
};

// Size: 0x90
class UClothingSimulationInteractorNv : public UClothingSimulationInteractor {

    void SetAnimDriveDamperStiffness(float InStiffness);
};

enum class EClothingWindMethodNv {
    Legacy = 0,
    Accurate = 1,
    EClothingWindMethodNv_MAX = 2,
};

// Size: 0xc0
class UCompositeCorePluginSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bApplyPreExposure;
    /* 0x0038 */ bool bApplyFXAA;
    /* 0x0040 */ TArray<FSoftClassPath> DisabledPrimitiveClasses;
    /* 0x0050 */ TArray<FSoftClassPath> AllowedComponentClasses;
    /* 0x0060 */ int32_t SceneViewExtensionPriority;
};

// Size: 0x50
class UCompositeCoreSubsystem : public UTickableWorldSubsystem {

    void RegisterPrimitive(UPrimitiveComponent* InPrimitiveComponent);
    void UnregisterPrimitive(UPrimitiveComponent* InPrimitiveComponent);
};

enum class ECompositeCoreMergeOp {
    None = 0,
    Over = 1,
    Add = 2,
    Multiply = 3,
    Divide = 4,
    ECompositeCoreMergeOp_MAX = 5,
};

// Size: 0x250
class UHoldoutCompositeComponent : public USceneComponent {
    /* 0x0240 */ bool bIsEnabled;

    bool IsEnabled() const;
    void SetEnabled(bool bInEnabled);
};

// Size: 0x10
struct FArrayShaderValue {
    /* 0x0000 */ TArray<uint8_t> ArrayOfValues;
};

// Size: 0x28
class UComputeDataInterface : public UObject {
};

// Size: 0x28
class UComputeDataProvider : public UObject {
};

// Size: 0xe0
class UComputeGraph : public UObject {
    /* 0x0028 */ TArray<UComputeKernel*> KernelInvocations;
    /* 0x0038 */ TArray<UComputeDataInterface*> DataInterfaces;
    /* 0x0048 */ TArray<FComputeGraphEdge> GraphEdges;
    /* 0x0058 */ TArray<UClass*> Bindings;
    /* 0x0068 */ TArray<int32_t> DataInterfaceToBinding;
};

// Size: 0xd8
class UComputeGraphComponent : public UActorComponent {
    /* 0x00b8 */ UComputeGraph* ComputeGraph;
    /* 0x00c0 */ FComputeGraphInstance ComputeGraphInstance;

    void CreateDataProviders(int32_t InBindingIndex, UObject* InBindingObject);
    void DestroyDataProviders();
    void QueueExecute();
};

// Size: 0x38
struct FComputeGraphEdge {
    /* 0x0000 */ int32_t KernelIndex;
    /* 0x0004 */ int32_t KernelBindingIndex;
    /* 0x0008 */ int32_t DataInterfaceIndex;
    /* 0x000c */ int32_t DataInterfaceBindingIndex;
    /* 0x0010 */ bool bKernelInput;
    /* 0x0018 */ FString BindingFunctionNameOverride;
    /* 0x0028 */ FString BindingFunctionNamespace;
};

// Size: 0x18
struct FComputeGraphInstance {
    /* 0x0000 */ TArray<UComputeDataProvider*> DataProviders;
};

// Size: 0x38
class UComputeKernel : public UObject {
    /* 0x0028 */ UComputeKernelSource* KernelSource;
    /* 0x0030 */ int32_t KernelFlags;
};

// Size: 0x20
struct FComputeKernelDefinition {
    /* 0x0000 */ FString Symbol;
    /* 0x0010 */ FString Define;
};

// Size: 0x10
struct FComputeKernelDefinitionSet {
    /* 0x0000 */ TArray<FComputeKernelDefinition> Defines;
};

// Size: 0xa8
class UComputeKernelFromText : public UComputeKernelSource {
    /* 0x0098 */ FFilePath SourceFile;
};

// Size: 0x18
struct FComputeKernelPermutationBool {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ bool Value;
};

// Size: 0x10
struct FComputeKernelPermutationSet {
    /* 0x0000 */ TArray<FComputeKernelPermutationBool> BooleanOptions;
};

// Size: 0x58
struct FComputeKernelPermutationVector {
    /* 0x0000 */ TMap<FString, uint32_t> Permutations;
    /* 0x0050 */ uint32_t BitCount;
};

// Size: 0x98
class UComputeKernelSource : public UObject {
    /* 0x0028 */ FString EntryPoint;
    /* 0x0038 */ FIntVector GroupSize;
    /* 0x0048 */ FComputeKernelPermutationSet PermutationSet;
    /* 0x0058 */ FComputeKernelDefinitionSet DefinitionsSet;
    /* 0x0068 */ TArray<UComputeSource*> AdditionalSources;
    /* 0x0078 */ TArray<FShaderFunctionDefinition> ExternalInputs;
    /* 0x0088 */ TArray<FShaderFunctionDefinition> ExternalOutputs;
};

// Size: 0x38
class UComputeSource : public UObject {
    /* 0x0028 */ TArray<UComputeSource*> AdditionalSources;
};

// Size: 0x48
class UComputeSourceFromText : public UComputeSource {
    /* 0x0038 */ FFilePath SourceFile;
};

enum class EComputeKernelFlags {
    IsDefaultKernel = 1,
    IsolatedMemoryWrites = 2,
    EComputeKernelFlags_MAX = 3,
};

enum class EShaderFundamentalDimensionType {
    Scalar = 0,
    Vector = 1,
    Matrix = 2,
    EShaderFundamentalDimensionType_MAX = 3,
};

enum class EShaderFundamentalType {
    Bool = 0,
    Int = 1,
    Uint = 2,
    Float = 3,
    Struct = 4,
    None = 255,
    EShaderFundamentalType_MAX = 256,
};

enum class EShaderParamBindingType {
    None = 0,
    ConstantParameter = 1,
    ReadOnlyResource = 2,
    ReadWriteResource = 3,
    EShaderParamBindingType_MAX = 4,
};

enum class EShaderParamModifier {
    None = 0,
    In = 1,
    Out = 2,
    InOut = 3,
    EShaderParamModifier_MAX = 4,
};

enum class EShaderResourceType {
    None = 0,
    Texture1D = 1,
    Texture2D = 2,
    Texture3D = 3,
    TextureCube = 4,
    Buffer = 5,
    StructuredBuffer = 6,
    ByteAddressBuffer = 7,
    EShaderResourceType_MAX = 8,
};

// Size: 0x28
struct FShaderFunctionDefinition {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ TArray<FShaderParamTypeDefinition> ParamTypes;
    /* 0x0020 */ bool bHasReturnType;
};

// Size: 0x30
struct FShaderParamTypeDefinition {
    /* 0x0000 */ FString TypeDeclaration;
    /* 0x0010 */ FString Name;
    /* 0x0020 */ FShaderValueTypeHandle ValueType;
    /* 0x0028 */ uint16_t ArrayElementCount;
    /* 0x002a */ EShaderParamBindingType BindingType;
    /* 0x002b */ EShaderResourceType ResourceType;
    /* 0x002c */ EShaderParamModifier modifier;
};

// Size: 0x20
struct FShaderValueContainer {
    /* 0x0000 */ TArray<uint8_t> ShaderValue;
    /* 0x0010 */ TArray<FArrayShaderValue> ArrayList;
};

// Size: 0x20
struct FShaderValueType {
    /* 0x0000 */ EShaderFundamentalType Type;
    /* 0x0001 */ EShaderFundamentalDimensionType DimensionType;
    /* 0x0004 */ FName Name;
    /* 0x000c */ bool bIsDynamicArray;
};

// Size: 0x8
struct FShaderValueTypeHandle {
};

// Size: 0x110
struct FConstraintAndActiveChannel {
    /* 0x0000 */ FMovieSceneConstraintChannel ActiveChannel;
    /* 0x0108 */ UTickableConstraint* ConstraintCopyToSpawn;
};

// Size: 0x50
class UConstraintSubsystem : public UEngineSubsystem {
    /* 0x0030 */ FMulticastSparseDelegate OnConstraintAddedToSystem_BP;
    /* 0x0031 */ FMulticastSparseDelegate OnConstraintRemovedFromSystem_BP;
    /* 0x0038 */ TArray<FConstraintsInWorld> ConstraintsInWorld;

    void OnConstraintAddedToSystem__DelegateSignature(UConstraintSubsystem* Mananger, UTickableConstraint* Constraint);
    void OnConstraintRemovedFromSystem__DelegateSignature(UConstraintSubsystem* Mananger, UTickableConstraint* Constraint, bool bDoNotCompensate);
};

// Size: 0x40
struct FConstraintTickFunction : public FTickFunction {
};

// Size: 0x2b0
class AConstraintsActor : public AActor {
    /* 0x02a8 */ UConstraintsManager* ConstraintsManager;
};

// Size: 0x28
struct FConstraintsInWorld {
    /* 0x0000 */ TWeakObjectPtr<UWorld> World;
    /* 0x0008 */ TArray<TWeakObjectPtr<UTickableConstraint>> Constraints;
};

// Size: 0x48
class UConstraintsManager : public UObject {
    /* 0x0028 */ FMulticastSparseDelegate OnConstraintAdded_BP;
    /* 0x0029 */ FMulticastSparseDelegate OnConstraintRemoved_BP;
    /* 0x0038 */ TArray<UTickableConstraint*> Constraints;

    void OnConstraintAdded__DelegateSignature(UConstraintsManager* Mananger, UTickableConstraint* Constraint);
    void OnConstraintRemoved__DelegateSignature(UConstraintsManager* Mananger, UTickableConstraint* Constraint, bool bDoNotCompensate);
};

// Size: 0x28
class UConstraintsScriptingLibrary : public UBlueprintFunctionLibrary {

    static bool AddConstraint(UWorld* InWorld, UTransformableHandle* InParentHandle, UTransformableHandle* InChildHandle, UTickableTransformConstraint* InConstraint, const bool bMaintainOffset);
    static UTickableTransformConstraint* CreateFromType(UWorld* InWorld, const ETransformConstraintType InType);
    static UTransformableComponentHandle* CreateTransformableComponentHandle(UWorld* InWorld, USceneComponent* InSceneComponent, const FName& InSocketName);
    static UTransformableHandle* CreateTransformableHandle(UWorld* InWorld, UObject* InObject, const FName& InAttachmentName);
    static TArray<UTickableConstraint*> GetConstraintsArray(UWorld* InWorld);
    static bool RemoveConstraint(UWorld* InWorld, int32_t InIndex);
    static bool RemoveThisConstraint(UWorld* InWorld, UTickableConstraint* InTickableConstraint);
};

enum class EHandleEvent {
    LocalTransformUpdated = 0,
    GlobalTransformUpdated = 1,
    ComponentUpdated = 2,
    UpperDependencyUpdated = 3,
    Max = 4,
};

// Size: 0x108
struct FMovieSceneConstraintChannel : public FMovieSceneBoolChannel {
};

// Size: 0x90
class UTickableConstraint : public UObject {
    /* 0x0028 */ bool Active;
    /* 0x0029 */ bool bValid;
};

// Size: 0xc8
class UTickableLookAtConstraint : public UTickableTransformConstraint {
    /* 0x00b0 */ FVector Axis;
};

// Size: 0x130
class UTickableParentConstraint : public UTickableTransformConstraint {
    /* 0x00c0 */ FTransform OffsetTransform;
    /* 0x0120 */ bool bScaling;
    /* 0x0121 */ FTransformFilter TransformFilter;
};

// Size: 0xf0
class UTickableRotationConstraint : public UTickableTransformConstraint {
    /* 0x00c0 */ FQuat OffsetRotation;
    /* 0x00e0 */ FFilterOptionPerAxis AxisFilter;
};

// Size: 0xd8
class UTickableScaleConstraint : public UTickableTransformConstraint {
    /* 0x00b8 */ FVector OffsetScale;
    /* 0x00d0 */ FFilterOptionPerAxis AxisFilter;
};

// Size: 0xb0
class UTickableTransformConstraint : public UTickableConstraint {
    /* 0x0090 */ UTransformableHandle* ParentTRSHandle;
    /* 0x0098 */ UTransformableHandle* ChildTRSHandle;
    /* 0x00a0 */ bool bMaintainOffset;
    /* 0x00a4 */ float Weight;
    /* 0x00a8 */ bool bDynamicOffset;
    /* 0x00a9 */ ETransformConstraintType Type;
};

// Size: 0xd8
class UTickableTranslationConstraint : public UTickableTransformConstraint {
    /* 0x00b8 */ FVector OffsetTranslation;
    /* 0x00d0 */ FFilterOptionPerAxis AxisFilter;
};

// Size: 0x70
class UTransformableComponentHandle : public UTransformableHandle {
    /* 0x0060 */ TWeakObjectPtr<USceneComponent> Component;
    /* 0x0068 */ FName SocketName;
};

// Size: 0x60
class UTransformableHandle : public UObject {
    /* 0x002c */ FMovieSceneObjectBindingID ConstraintBindingID;
};

// Size: 0xb80
class UAdditiveControlRig : public UControlRig {
};

// Size: 0x90
struct FAimTarget {
    /* 0x0000 */ float Weight;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FVector AlignVector;
};

// Size: 0x28
class UAnimNodeControlRigLibrary : public UBlueprintFunctionLibrary {

    static FControlRigReference ConvertToControlRig(const FAnimNodeReference& Node, EAnimNodeReferenceConversionResult& Result);
    static void ConvertToControlRigPure(const FAnimNodeReference& Node, FControlRigReference& ControlRig, bool& Result);
    static FControlRigReference SetControlRigClass(const FControlRigReference& Node, UClass* ControlRigClass);
};

// Size: 0x4b8
struct FAnimNode_ControlRig : public FAnimNode_ControlRigBase {
    /* 0x0228 */ UClass* ControlRigClass;
    /* 0x0230 */ UClass* DefaultControlRigClass;
    /* 0x0238 */ UControlRig* ControlRig;
    /* 0x0240 */ TMap<UClass*, UControlRig*> ControlRigPerClass;
    /* 0x0290 */ float Alpha;
    /* 0x0294 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0295 */ bool bAlphaBoolEnabled;
    /* 0x0295 */ bool bSetRefPoseFromSkeleton;
    /* 0x0298 */ FInputScaleBias AlphaScaleBias;
    /* 0x02a0 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x02e8 */ FName AlphaCurveName;
    /* 0x02f0 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x0320 */ TMap<FName, FName> InputMapping;
    /* 0x0370 */ TMap<FName, FName> OutputMapping;
    /* 0x03c0 */ int32_t LODThreshold;
};

// Size: 0x228
struct FAnimNode_ControlRigBase : public FAnimNode_CustomProperty {
    /* 0x0058 */ FPoseLink Source;
    /* 0x0068 */ bool bResetInputPoseToInitial;
    /* 0x0069 */ bool bTransferInputPose;
    /* 0x006a */ bool bTransferInputCurves;
    /* 0x006b */ bool bTransferPoseInGlobalSpace;
    /* 0x0070 */ TArray<FBoneReference> InputBonesToTransfer;
    /* 0x0080 */ TArray<FBoneReference> OutputBonesToTransfer;
    /* 0x0090 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x00a0 */ TWeakObjectPtr<UNodeMappingContainer> NodeMappingContainer;
    /* 0x00a8 */ FControlRigIOSettings InputSettings;
    /* 0x00aa */ FControlRigIOSettings OutputSettings;
    /* 0x00ac */ bool bExecute;
    /* 0x00b8 */ TArray<FControlRigAnimNodeEventName> EventQueue;
};

// Size: 0x30
struct FAnimNode_ControlRigInputPose : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink InputPose;
};

// Size: 0x230
struct FAnimNode_ControlRig_ExternalSource : public FAnimNode_ControlRigBase {
    /* 0x0228 */ TWeakObjectPtr<UControlRig> ControlRig;
};

// Size: 0x88
struct FAnimationHierarchy : public FNodeHierarchyWithUserData {
    /* 0x0078 */ TArray<FConstraintNodeData> UserData;
};

// Size: 0x70
struct FBlendTarget {
    /* 0x0000 */ FTransform Transform;
    /* 0x0060 */ float Weight;
};

// Size: 0x18
struct FCRSimContainer {
    /* 0x0008 */ float TimeStep;
    /* 0x000c */ float AccumulatedTime;
    /* 0x0010 */ float TimeLeftForStep;
};

// Size: 0x10
struct FCRSimLinearSpring {
    /* 0x0000 */ int32_t SubjectA;
    /* 0x0004 */ int32_t SubjectB;
    /* 0x0008 */ float Coefficient;
    /* 0x000c */ float Equilibrium;
};

// Size: 0x40
struct FCRSimPointConstraint {
    /* 0x0000 */ ECRSimConstraintType Type;
    /* 0x0004 */ int32_t SubjectA;
    /* 0x0008 */ int32_t SubjectB;
    /* 0x0010 */ FVector DataA;
    /* 0x0028 */ FVector DataB;
};

// Size: 0x78
struct FCRSimPointContainer : public FCRSimContainer {
    /* 0x0018 */ TArray<FRigVMSimPoint> points;
    /* 0x0028 */ TArray<FCRSimLinearSpring> Springs;
    /* 0x0038 */ TArray<FCRSimPointForce> Forces;
    /* 0x0048 */ TArray<FCRSimSoftCollision> CollisionVolumes;
    /* 0x0058 */ TArray<FCRSimPointConstraint> Constraints;
    /* 0x0068 */ TArray<FRigVMSimPoint> PreviousStep;
};

// Size: 0x28
struct FCRSimPointForce {
    /* 0x0000 */ ECRSimPointForceType ForceType;
    /* 0x0008 */ FVector Vector;
    /* 0x0020 */ float Coefficient;
    /* 0x0024 */ bool bNormalize;
};

// Size: 0x80
struct FCRSimSoftCollision {
    /* 0x0000 */ FTransform Transform;
    /* 0x0060 */ ECRSimSoftCollisionType ShapeType;
    /* 0x0064 */ float MinimumDistance;
    /* 0x0068 */ float MaximumDistance;
    /* 0x006c */ ERigVMAnimEasingType FalloffType;
    /* 0x0070 */ float Coefficient;
    /* 0x0074 */ bool bInverted;
};

// Size: 0x38
struct FCachedRigComponent {
    /* 0x0000 */ FCachedRigElement CachedElement;
    /* 0x0020 */ FName Name;
    /* 0x0028 */ uint16_t Index;
};

// Size: 0x20
struct FCachedRigElement {
    /* 0x0000 */ FRigElementKey Key;
    /* 0x000c */ uint16_t Index;
    /* 0x0010 */ int32_t ContainerVersion;
};

// Size: 0x40
struct FChannelMapInfo {
    /* 0x0000 */ int32_t ControlIndex;
    /* 0x0004 */ int32_t TotalChannelIndex;
    /* 0x0008 */ int32_t ChannelIndex;
    /* 0x000c */ int32_t ParentControlIndex;
    /* 0x0010 */ FName ChannelTypeName;
    /* 0x0018 */ bool bDoesHaveSpace;
    /* 0x001c */ int32_t SpaceChannelIndex;
    /* 0x0020 */ int32_t MaskIndex;
    /* 0x0024 */ int32_t CategoryIndex;
    /* 0x0030 */ TArray<uint32_t> ConstraintsIndex;
};

// Size: 0x140
struct FConstraintNodeData {
    /* 0x0000 */ FTransform RelativeParent;
    /* 0x0060 */ FConstraintOffset ConstraintOffset;
    /* 0x0120 */ FName LinkedNode;
    /* 0x0128 */ TArray<FTransformConstraint> Constraints;
};

// Size: 0x10
struct FConstraintParent {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x000c */ float Weight;
};

// Size: 0x70
struct FConstraintTarget {
    /* 0x0000 */ FTransform Transform;
    /* 0x0060 */ float Weight;
    /* 0x0064 */ bool bMaintainOffset;
    /* 0x0065 */ FTransformFilter Filter;
};

// Size: 0xb70
class UControlRig : public URigVMHost {
    /* 0x02a8 */ TArray<UControlRigOverrideAsset*> OverrideAssets;
    /* 0x02b9 */ ERigExecutionType ExecutionType;
    /* 0x02bc */ FRigHierarchySettings HierarchySettings;
    /* 0x02c8 */ TMap<FRigElementKey, FRigControlElementCustomization> ControlCustomizations;
    /* 0x0318 */ URigHierarchy* DynamicHierarchy;
    /* 0x0320 */ TArray<TSoftObjectPtr<UControlRigShapeLibrary>> ShapeLibraries;
    /* 0x0330 */ TMap<FString, FString> ShapeLibraryNameMap;
    /* 0x0390 */ FRigVMExtendedExecuteContext RigVMExtendedExecuteContext;
    /* 0x05d8 */ UAnimationDataSourceRegistry* DataSourceRegistry;
    /* 0x0688 */ FRigInfluenceMapPerEvent Influences;
    /* 0x07a0 */ TMap<FName, UDataAssetLink*> ExternalVariableDataAssetLinks;
    /* 0x08c0 */ FMulticastSparseDelegate OnControlSelected_BP;
    /* 0x08f0 */ bool bIsAdditive;
    /* 0x0ad0 */ FRigModuleSettings RigModuleSettings;
    /* 0x0b50 */ FString RigModulePrefix;

    bool ClearControlSelection(bool bSetupUndo);
    UTransformableControlHandle* CreateTransformableControlHandle(const FName& ControlName) const;
    TArray<FName> CurrentControlSelection() const;
    static TArray<UControlRig*> FindControlRigs(UObject* Outer, UClass* OptionalClass);
    URigHierarchy* GetHierarchy();
    AActor* GetHostingActor() const;
    UControlRig* GetInteractionRig() const;
    UClass* GetInteractionRigClass() const;
    bool IsControlSelected(const FName& InControlName) const;
    void OnControlSelectedBP__DelegateSignature(UControlRig* Rig, const FRigControlElement& Control, bool bSelected);
    void RequestConstruction();
    void SelectControl(const FName& InControlName, bool bSelect, bool bSetupUndo);
    void SetInteractionRig(UControlRig* InInteractionRig);
    void SetInteractionRigClass(UClass* InInteractionRigClass);
    bool SupportsBackwardsSolve() const;
};

// Size: 0x3e0
class UControlRigAnimInstance : public UAnimInstance {
};

// Size: 0x880
struct FControlRigAnimInstanceProxy : public FAnimInstanceProxy {
};

// Size: 0x8
struct FControlRigAnimNodeEventName {
    /* 0x0000 */ FName EventName;
};

// Size: 0x388
class UControlRigBlueprintGeneratedClass : public URigVMBlueprintGeneratedClass {
};

// Size: 0x6c0
class UControlRigComponent : public UPrimitiveComponent {
    /* 0x0520 */ UClass* ControlRigClass;
    /* 0x0528 */ FMulticastInlineDelegate OnPreInitializeDelegate;
    /* 0x0538 */ FMulticastInlineDelegate OnPostInitializeDelegate;
    /* 0x0548 */ FMulticastInlineDelegate OnPreConstructionDelegate;
    /* 0x0558 */ FMulticastInlineDelegate OnPostConstructionDelegate;
    /* 0x0568 */ FMulticastInlineDelegate OnPreForwardsSolveDelegate;
    /* 0x0578 */ FMulticastInlineDelegate OnPostForwardsSolveDelegate;
    /* 0x0588 */ TArray<FControlRigComponentMappedElement> UserDefinedElements;
    /* 0x0598 */ TArray<FControlRigComponentMappedElement> MappedElements;
    /* 0x05a8 */ bool bEnableLazyEvaluation;
    /* 0x05ac */ float LazyEvaluationPositionThreshold;
    /* 0x05b0 */ float LazyEvaluationRotationThreshold;
    /* 0x05b4 */ float LazyEvaluationScaleThreshold;
    /* 0x05b8 */ bool bResetTransformBeforeTick;
    /* 0x05b9 */ bool bResetInitialsBeforeConstruction;
    /* 0x05ba */ bool bUpdateRigOnTick;
    /* 0x05bb */ bool bUpdateInEditor;
    /* 0x05bc */ bool bDrawBones;
    /* 0x05bd */ bool bShowDebugDrawing;
    /* 0x05c0 */ UControlRig* ControlRig;

    void AddMappedCompleteSkeletalMesh(USkeletalMeshComponent* SkeletalMeshComponent, const EControlRigComponentMapDirection InDirection);
    void AddMappedComponents(TArray<FControlRigComponentMappedComponent> Components);
    void AddMappedElements(TArray<FControlRigComponentMappedElement> NewMappedElements);
    void AddMappedSkeletalMesh(USkeletalMeshComponent* SkeletalMeshComponent, TArray<FControlRigComponentMappedBone> Bones, TArray<FControlRigComponentMappedCurve> Curves, const EControlRigComponentMapDirection InDirection);
    bool CanExecute();
    void ClearMappedElements();
    bool DoesElementExist(FName Name, ERigElementType ElementType);
    float GetAbsoluteTime() const;
    FTransform GetBoneTransform(FName BoneName, EControlRigComponentSpace Space);
    bool GetControlBool(FName ControlName);
    float GetControlFloat(FName ControlName);
    int32_t GetControlInt(FName ControlName);
    FTransform GetControlOffset(FName ControlName, EControlRigComponentSpace Space);
    FVector GetControlPosition(FName ControlName, EControlRigComponentSpace Space);
    UControlRig* GetControlRig();
    FRotator GetControlRotator(FName ControlName, EControlRigComponentSpace Space);
    FVector GetControlScale(FName ControlName, EControlRigComponentSpace Space);
    FTransform GetControlTransform(FName ControlName, EControlRigComponentSpace Space);
    FVector2D GetControlVector2D(FName ControlName);
    TArray<FName> GetElementNames(ERigElementType ElementType);
    FTransform GetInitialBoneTransform(FName BoneName, EControlRigComponentSpace Space);
    FTransform GetInitialSpaceTransform(FName SpaceName, EControlRigComponentSpace Space);
    FTransform GetSpaceTransform(FName SpaceName, EControlRigComponentSpace Space);
    void Initialize();
    void OnPostConstruction(UControlRigComponent* Component);
    void OnPostForwardsSolve(UControlRigComponent* Component);
    void OnPostInitialize(UControlRigComponent* Component);
    void OnPreConstruction(UControlRigComponent* Component);
    void OnPreForwardsSolve(UControlRigComponent* Component);
    void OnPreInitialize(UControlRigComponent* Component);
    void SetBoneInitialTransformsFromSkeletalMesh(USkeletalMesh* InSkeletalMesh);
    void SetBoneTransform(FName BoneName, FTransform Transform, EControlRigComponentSpace Space, float Weight, bool bPropagateToChildren);
    void SetControlBool(FName ControlName, bool Value);
    void SetControlFloat(FName ControlName, float Value);
    void SetControlInt(FName ControlName, int32_t Value);
    void SetControlOffset(FName ControlName, FTransform OffsetTransform, EControlRigComponentSpace Space);
    void SetControlPosition(FName ControlName, FVector Value, EControlRigComponentSpace Space);
    void SetControlRigClass(UClass* InControlRigClass);
    void SetControlRotator(FName ControlName, FRotator Value, EControlRigComponentSpace Space);
    void SetControlScale(FName ControlName, FVector Value, EControlRigComponentSpace Space);
    void SetControlTransform(FName ControlName, FTransform Value, EControlRigComponentSpace Space);
    void SetControlVector2D(FName ControlName, FVector2D Value);
    void SetInitialBoneTransform(FName BoneName, FTransform InitialTransform, EControlRigComponentSpace Space, bool bPropagateToChildren);
    void SetInitialSpaceTransform(FName SpaceName, FTransform InitialTransform, EControlRigComponentSpace Space);
    void SetMappedElements(TArray<FControlRigComponentMappedElement> NewMappedElements);
    void SetObjectBinding(UObject* InObjectToBind);
    void Update(float deltaTime);
};

// Size: 0x10
struct FControlRigComponentMappedBone {
    /* 0x0000 */ FName Source;
    /* 0x0008 */ FName Target;
};

// Size: 0x18
struct FControlRigComponentMappedComponent {
    /* 0x0000 */ USceneComponent* Component;
    /* 0x0008 */ FName ElementName;
    /* 0x0010 */ ERigElementType ElementType;
    /* 0x0011 */ EControlRigComponentMapDirection Direction;
};

// Size: 0x10
struct FControlRigComponentMappedCurve {
    /* 0x0000 */ FName Source;
    /* 0x0008 */ FName Target;
};

// Size: 0xf0
struct FControlRigComponentMappedElement {
    /* 0x0000 */ FSoftComponentReference ComponentReference;
    /* 0x0048 */ int32_t TransformIndex;
    /* 0x004c */ FName TransformName;
    /* 0x0054 */ ERigElementType ElementType;
    /* 0x0058 */ FName ElementName;
    /* 0x0060 */ EControlRigComponentMapDirection Direction;
    /* 0x0070 */ FTransform Offset;
    /* 0x00d0 */ float Weight;
    /* 0x00d4 */ EControlRigComponentSpace Space;
    /* 0x00d8 */ USceneComponent* SceneComponent;
    /* 0x00e0 */ int32_t ElementIndex;
    /* 0x00e4 */ int32_t SubIndex;
};

// Size: 0x358
class AControlRigControlActor : public AActor {
    /* 0x02a8 */ AActor* ActorToTrack;
    /* 0x02b0 */ UClass* ControlRigClass;
    /* 0x02b8 */ bool bRefreshOnTick;
    /* 0x02b9 */ bool bIsSelectable;
    /* 0x02c0 */ UMaterialInterface* MaterialOverride;
    /* 0x02c8 */ FString ColorParameter;
    /* 0x02d8 */ bool bCastShadows;
    /* 0x02e0 */ USceneComponent* ActorRootComponent;
    /* 0x02e8 */ TSoftObjectPtr<UControlRig> ControlRig;
    /* 0x0310 */ TArray<FName> ControlNames;
    /* 0x0320 */ TArray<FTransform> ShapeTransforms;
    /* 0x0330 */ TArray<UStaticMeshComponent*> Components;
    /* 0x0340 */ TArray<UMaterialInstanceDynamic*> Materials;
    /* 0x0350 */ FName ColorParameterName;

    void Clear();
    void Refresh();
    void ResetControlActor();
};

// Size: 0x60
struct FControlRigControlPose {
    /* 0x0000 */ TArray<FRigControlCopy> CopyOfControls;
};

// Size: 0x38
class UControlRigEditorSettings : public URigVMEditorSettings {
};

// Size: 0x210
struct FControlRigExecuteContext : public FRigVMExecuteContext {
};

// Size: 0x2
struct FControlRigIOSettings {
    /* 0x0000 */ bool bUpdatePose;
    /* 0x0001 */ bool bUpdateCurves;
};

// Size: 0x3e0
class UControlRigLayerInstance : public UAnimInstance {
};

// Size: 0x840
struct FControlRigLayerInstanceProxy : public FAnimInstanceProxy {
};

// Size: 0xc0
class UControlRigNumericalValidationPass : public UControlRigValidationPass {
    /* 0x0028 */ bool bCheckControls;
    /* 0x0029 */ bool bCheckBones;
    /* 0x002a */ bool bCheckCurves;
    /* 0x002c */ float TranslationPrecision;
    /* 0x0030 */ float RotationPrecision;
    /* 0x0034 */ float ScalePrecision;
    /* 0x0038 */ float CurvePrecision;
    /* 0x003c */ FName EventNameA;
    /* 0x0044 */ FName EventNameB;
    /* 0x0050 */ FRigPose Pose;
};

// Size: 0x198
class UControlRigOverrideAsset : public UObject {
    /* 0x0028 */ FControlRigOverrideContainer Overrides;
};

// Size: 0x158
struct FControlRigOverrideContainer {
};

// Size: 0x50
struct FControlRigOverrideValue {
};

// Size: 0x88
class UControlRigPoseAsset : public UObject {
    /* 0x0028 */ FControlRigControlPose Pose;

    bool DoesMirrorMatch(UControlRig* ControlRig, const FName& ControlName) const;
    TArray<FName> GetControlNames() const;
    void GetCurrentPose(UControlRig* InControlRig, FControlRigControlPose& OutPose);
    void PastePose(UControlRig* InControlRig, bool bDoKey, bool bDoMirror, bool bDoAdditive);
    void ReplaceControlName(const FName& CurrentName, const FName& NewName);
    void SavePose(UControlRig* InControlRig, bool bUseAll);
    void SelectControls(UControlRig* InControlRig, bool bDoMirror, bool bClearSelection);
};

// Size: 0x50
class UControlRigPoseMirrorSettings : public UObject {
    /* 0x0028 */ FString RightSide;
    /* 0x0038 */ FString LeftSide;
    /* 0x0048 */ uint8_t MirrorAxis;
    /* 0x0049 */ uint8_t AxisToFlip;
};

// Size: 0x38
class UControlRigPoseProjectSettings : public UObject {
    /* 0x0028 */ TArray<FDirectoryPath> RootSaveDirs;
};

// Size: 0x10
struct FControlRigReference : public FAnimNodeReference {
};

// Size: 0x3e8
class UControlRigReplay : public UObject {
    /* 0x0028 */ FText Description;
    /* 0x0038 */ FSoftObjectPath ControlRigObjectPath;
    /* 0x0058 */ FSoftObjectPath PreviewSkeletalMeshObjectPath;
    /* 0x0078 */ FControlRigReplayTracks InputTracks;
    /* 0x01f0 */ FControlRigReplayTracks OutputTracks;
    /* 0x0368 */ double Tolerance;
    /* 0x0370 */ bool bValidateHierarchyTopology;
    /* 0x0371 */ bool bValidatePose;
    /* 0x0372 */ bool bValidateMetadata;
    /* 0x0373 */ bool bValidateVariables;
    /* 0x0378 */ TArray<int32_t> FramesToSkip;
    /* 0x0388 */ bool EnableTest;

    static UControlRigReplay* CreateNewAsset(FString InDesiredPackagePath, FString InBlueprintPathName, UClass* InAssetClass);
    EControlRigReplayPlaybackMode GetPlaybackMode() const;
    FVector2D GetTimeRange() const;
    bool IsPaused() const;
    bool IsRecording() const;
    bool IsReplaying() const;
    bool PauseReplay();
    void SetPlaybackMode(EControlRigReplayPlaybackMode InMode);
    bool StartRecording(UControlRig* InControlRig);
    bool StartReplay(UControlRig* InControlRig, EControlRigReplayPlaybackMode InMode);
    bool StopRecording();
    bool StopReplay();
};

// Size: 0x178
struct FControlRigReplayTracks : public FSampleTrackHost {
};

// Size: 0x20
struct FControlRigReplayVariable {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName CPPType;
    /* 0x0010 */ FString Value;
};

// Size: 0x8
struct FControlRigSequenceObjectReference {
    /* 0x0000 */ UClass* ControlRigClass;
};

// Size: 0x20
struct FControlRigSequenceObjectReferenceMap {
    /* 0x0000 */ TArray<FGuid> BindingIds;
    /* 0x0010 */ TArray<FControlRigSequenceObjectReferences> References;
};

// Size: 0x10
struct FControlRigSequenceObjectReferences {
    /* 0x0000 */ TArray<FControlRigSequenceObjectReference> Array;
};

// Size: 0x38
class UControlRigSettings : public UDeveloperSettings {
};

// Size: 0x50
struct FControlRigSettingsPerPinBool {
    /* 0x0000 */ TMap<FString, bool> Values;
};

// Size: 0x3a0
class AControlRigShapeActor : public AActor {
    /* 0x02b0 */ USceneComponent* ActorRootComponent;
    /* 0x02b8 */ UStaticMeshComponent* StaticMeshComponent;
    /* 0x02c0 */ uint32_t ControlRigIndex;
    /* 0x02c4 */ TWeakObjectPtr<UControlRig> ControlRig;
    /* 0x02cc */ FName ControlName;
    /* 0x02d4 */ FName ShapeName;
    /* 0x02dc */ FName ColorParameterName;
    /* 0x0360 */ FCachedRigElement CachedIndex;
    /* 0x0380 */ bool bSelected;
    /* 0x0380 */ bool bHovered;

    FTransform GetGlobalTransform() const;
    bool IsEnabled() const;
    bool IsHovered() const;
    bool IsSelectedInEditor() const;
    void OnEnabledChanged(bool bIsEnabled);
    void OnHoveredChanged(bool bIsSelected);
    void OnManipulatingChanged(bool bIsManipulating);
    void OnSelectionChanged(bool bIsSelected);
    void OnTransformChanged(const FTransform& NewTransform);
    void SetEnabled(bool bInEnabled);
    void SetGlobalTransform(const FTransform& InTransform);
    void SetHovered(bool bInHovered);
    void SetSelectable(bool bInSelectable);
    void SetSelected(bool bInSelected);
};

// Size: 0xa0
struct FControlRigShapeDefinition {
    /* 0x0000 */ FName ShapeName;
    /* 0x0008 */ TSoftObjectPtr<UStaticMesh> StaticMesh;
    /* 0x0030 */ FTransform Transform;
};

// Size: 0x150
class UControlRigShapeLibrary : public UObject {
    /* 0x0030 */ FControlRigShapeDefinition DefaultShape;
    /* 0x00d0 */ TSoftObjectPtr<UMaterial> DefaultMaterial;
    /* 0x00f8 */ TSoftObjectPtr<UMaterial> XRayMaterial;
    /* 0x0120 */ FName MaterialColorParameter;
    /* 0x0128 */ TArray<FControlRigShapeDefinition> Shapes;
};

// Size: 0x140
class UControlRigShapeLibraryLink : public UNameSpacedUserData {
    /* 0x0100 */ TSoftObjectPtr<UControlRigShapeLibrary> ShapeLibrary;
    /* 0x0128 */ TArray<FName> ShapeNames;
    /* 0x0138 */ UControlRigShapeLibrary* ShapeLibraryCached;

    TSoftObjectPtr<UControlRigShapeLibrary> GetShapeLibrary() const;
    void SetShapeLibrary(TSoftObjectPtr<UControlRigShapeLibrary> InShapeLibrary);
};

// Size: 0x528
class UControlRigTestData : public UControlRigReplay {
    /* 0x03e8 */ FControlRigTestDataFrame Initial;
    /* 0x04f0 */ TArray<FControlRigTestDataFrame> InputFrames;
    /* 0x0500 */ TArray<FControlRigTestDataFrame> OutputFrames;
    /* 0x0510 */ TArray<FName> EventQueue;

    int32_t GetFrameIndexForTime(double InSeconds, bool bInput) const;
};

// Size: 0x108
struct FControlRigTestDataFrame {
    /* 0x0000 */ double AbsoluteTime;
    /* 0x0008 */ double deltaTime;
    /* 0x0010 */ TArray<FControlRigReplayVariable> Variables;
    /* 0x0020 */ FRigPose Pose;
    /* 0x0090 */ TArray<uint8_t> MetaData;
};

// Size: 0xb8
class UControlRigTransformWorkflowOptions : public UControlRigWorkflowOptions {
    /* 0x00b0 */ uint8_t TransformType;

    TArray<FRigVMUserWorkflow> ProvideWorkflows(const UObject* InSubject);
};

// Size: 0x28
struct FControlRigValidationContext {
};

// Size: 0x28
class UControlRigValidationPass : public UObject {
};

// Size: 0x68
class UControlRigValidator : public UObject {
    /* 0x0028 */ TArray<UControlRigValidationPass*> Passes;
};

// Size: 0xb0
class UControlRigWorkflowOptions : public URigVMUserWorkflowOptions {
    /* 0x0098 */ URigHierarchy* Hierarchy;
    /* 0x00a0 */ TArray<FRigElementKey> Selection;

    bool EnsureAtLeastOneRigElementSelected() const;
};

// Size: 0x2
struct FControlRotationOrder {
    /* 0x0000 */ EEulerRotationOrder RotationOrder;
    /* 0x0001 */ bool bOverrideSetting;
};

// Size: 0x1c0
struct FControlShapeActorCreationParam {
};

enum class EAimMode {
    AimAtTarget = 0,
    OrientToTarget = 1,
    MAX = 2,
};

enum class EApplyTransformMode {
    Override = 0,
    Additive = 1,
    Max = 2,
};

enum class ECRSimConstraintType {
    Distance = 0,
    DistanceFromA = 1,
    DistanceFromB = 2,
    Plane = 3,
    ECRSimConstraintType_MAX = 4,
};

enum class ECRSimPointForceType {
    Direction = 0,
    ECRSimPointForceType_MAX = 1,
};

enum class ECRSimSoftCollisionType {
    Plane = 0,
    Sphere = 1,
    Cone = 2,
    ECRSimSoftCollisionType_MAX = 3,
};

enum class EConnectorType {
    Primary = 0,
    Secondary = 1,
    EConnectorType_MAX = 2,
};

enum class EConstraintInterpType {
    Average = 0,
    Shortest = 1,
    Max = 2,
};

enum class EControlRigComponentMapDirection {
    Input = 0,
    Output = 1,
    EControlRigComponentMapDirection_MAX = 2,
};

enum class EControlRigComponentSpace {
    WorldSpace = 0,
    ActorSpace = 1,
    ComponentSpace = 2,
    RigSpace = 3,
    LocalSpace = 4,
    Max = 5,
};

enum class EControlRigCurveAlignment {
    Front = 0,
    Stretched = 1,
    EControlRigCurveAlignment_MAX = 2,
};

enum class EControlRigDrawHierarchyMode {
    Axes = 0,
    Max = 1,
};

enum class EControlRigFKRigExecuteMode {
    Replace = 0,
    Additive = 1,
    Direct = 2,
    Max = 3,
};

enum class EControlRigInteractionType {
    None = 0,
    Translate = 1,
    Rotate = 2,
    Scale = 4,
    All = 7,
    EControlRigInteractionType_MAX = 8,
};

enum class EControlRigModifyBoneMode {
    OverrideLocal = 0,
    OverrideGlobal = 1,
    AdditiveLocal = 2,
    AdditiveGlobal = 3,
    Max = 4,
};

enum class EControlRigReplayPlaybackMode {
    Live = 0,
    ReplayInputs = 1,
    GroundTruth = 2,
    Max = 3,
};

enum class EControlRigSetKey {
    DoNotCare = 0,
    Always = 1,
    Never = 2,
    EControlRigSetKey_MAX = 3,
};

enum class EControlRigVectorKind {
    Direction = 0,
    Location = 1,
    EControlRigVectorKind_MAX = 2,
};

enum class EElementNameDisplayMode {
    AssetDefault = 0,
    Auto = 1,
    ForceShort = 2,
    ForceLong = 3,
    EElementNameDisplayMode_MAX = 4,
};

enum class EModularRigNotification {
    ModuleAdded = 0,
    ModuleRenamed = 1,
    ModuleRemoved = 2,
    ModuleReparented = 3,
    ConnectionChanged = 4,
    ModuleConfigValueChanged = 5,
    ModuleShortNameChanged = 6,
    InteractionBracketOpened = 7,
    InteractionBracketClosed = 8,
    InteractionBracketCanceled = 9,
    ModuleClassChanged = 10,
    ModuleSelected = 11,
    ModuleDeselected = 12,
    Max = 13,
};

enum class EModularRigResolveState {
    Success = 0,
    Error = 1,
    Max = 2,
};

enum class EMovieSceneControlRigSpaceType {
    Parent = 0,
    World = 1,
    ControlRig = 2,
    EMovieSceneControlRigSpaceType_MAX = 3,
};

enum class ERigBoneType {
    Imported = 0,
    User = 1,
    ERigBoneType_MAX = 2,
};

enum class ERigControlAnimationType {
    AnimationControl = 0,
    AnimationChannel = 1,
    ProxyControl = 2,
    VisualCue = 3,
    ERigControlAnimationType_MAX = 4,
};

enum class ERigControlAxis {
    X = 0,
    Y = 1,
    Z = 2,
    ERigControlAxis_MAX = 3,
};

enum class ERigControlTransformChannel {
    TranslationX = 0,
    TranslationY = 1,
    TranslationZ = 2,
    Pitch = 3,
    Yaw = 4,
    Roll = 5,
    ScaleX = 6,
    ScaleY = 7,
    ScaleZ = 8,
    ERigControlTransformChannel_MAX = 9,
};

enum class ERigControlType {
    Bool = 0,
    Float = 1,
    Integer = 2,
    Vector2D = 3,
    Position = 4,
    Scale = 5,
    Rotator = 6,
    Transform = 7,
    TransformNoScale = 8,
    EulerTransform = 9,
    ScaleFloat = 10,
    ERigControlType_MAX = 11,
};

enum class ERigControlValueType {
    Initial = 0,
    Current = 1,
    Minimum = 2,
    Maximum = 3,
    ERigControlValueType_MAX = 4,
};

enum class ERigControlVisibility {
    UserDefined = 0,
    BasedOnSelection = 1,
    ERigControlVisibility_MAX = 2,
};

enum class ERigElementResolveState {
    Unknown = 0,
    InvalidTarget = 1,
    PossibleTarget = 2,
    DefaultTarget = 3,
    Max = 4,
};

enum class ERigElementType {
    None = 0,
    Bone = 1,
    Null = 2,
    Space = 2,
    Control = 4,
    Curve = 8,
    Physics = 16,
    Reference = 32,
    Connector = 64,
    Socket = 128,
    First = 1,
    Last = 128,
    All = 239,
    ToResetAfterConstructionEvent = 141,
    ERigElementType_MAX = 240,
};

enum class ERigEvent {
    None = 0,
    RequestAutoKey = 1,
    OpenUndoBracket = 2,
    CloseUndoBracket = 3,
    Max = 4,
};

enum class ERigExecutionType {
    Runtime = 0,
    Editing = 1,
    Max = 2,
};

enum class ERigHierarchyNotification {
    ElementAdded = 0,
    ElementRemoved = 1,
    ElementRenamed = 2,
    ElementSelected = 3,
    ElementDeselected = 4,
    ParentChanged = 5,
    HierarchyReset = 6,
    ControlSettingChanged = 7,
    ControlVisibilityChanged = 8,
    ControlDrivenListChanged = 9,
    ControlShapeTransformChanged = 10,
    ParentWeightsChanged = 11,
    InteractionBracketOpened = 12,
    InteractionBracketClosed = 13,
    ElementReordered = 14,
    ConnectorSettingChanged = 15,
    SocketColorChanged = 16,
    SocketDescriptionChanged = 17,
    SocketDesiredParentChanged = 18,
    HierarchyCopied = 19,
    ComponentAdded = 20,
    ComponentRemoved = 21,
    ComponentContentChanged = 22,
    ComponentSelected = 23,
    ComponentDeselected = 24,
    ComponentRenamed = 25,
    ComponentReparented = 26,
    ShortNameChanged = 27,
    Max = 28,
};

enum class ERigMetaDataNameSpace {
    None = 0,
    Self = 1,
    Parent = 2,
    Root = 3,
    Last = 4,
    ERigMetaDataNameSpace_MAX = 5,
};

enum class ERigMetadataType {
    Bool = 0,
    BoolArray = 1,
    Float = 2,
    FloatArray = 3,
    Int32 = 4,
    Int32Array = 5,
    Name = 6,
    NameArray = 7,
    Vector = 8,
    VectorArray = 9,
    Rotator = 10,
    RotatorArray = 11,
    Quat = 12,
    QuatArray = 13,
    Transform = 14,
    TransformArray = 15,
    LinearColor = 16,
    LinearColorArray = 17,
    RigElementKey = 18,
    RigElementKeyArray = 19,
    Invalid = 20,
    ERigMetadataType_MAX = 21,
};

enum class ERigSpaceType {
    Global = 0,
    Bone = 1,
    Control = 2,
    Space = 3,
    ERigSpaceType_MAX = 4,
};

enum class ERigSwitchParentMode {
    World = 0,
    DefaultParent = 1,
    ParentItem = 2,
    ERigSwitchParentMode_MAX = 3,
};

enum class ERigTransformStackEntryType {
    TransformPose = 0,
    ControlOffset = 1,
    ControlShape = 2,
    CurveValue = 3,
    ERigTransformStackEntryType_MAX = 4,
};

enum class ERigTransformStorageType {
    Pose = 0,
    Offset = 1,
    Shape = 2,
    NumStorageTypes = 3,
    ERigTransformStorageType_MAX = 4,
};

enum class ERigTransformType {
    InitialLocal = 0,
    CurrentLocal = 1,
    InitialGlobal = 2,
    CurrentGlobal = 3,
    NumTransformTypes = 4,
    ERigTransformType_MAX = 5,
};

enum class ETransformGetterType {
    Initial = 0,
    Current = 1,
    Max = 2,
};

enum class ETransformSpaceMode {
    LocalSpace = 0,
    GlobalSpace = 1,
    BaseSpace = 2,
    BaseJoint = 3,
    Max = 4,
};

// Size: 0x118
struct FEnumParameterNameAndCurve : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneByteChannel ParameterCurve;
};

// Size: 0xbb0
class UFKControlRig : public UControlRig {
    /* 0x0b70 */ TArray<bool> IsControlActive;
    /* 0x0b80 */ EControlRigFKRigExecuteMode ApplyMode;
};

// Size: 0x110
struct FIntegerParameterNameAndCurve : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneIntegerChannel ParameterCurve;
};

// Size: 0xd10
class UModularRig : public UControlRig {
    /* 0x0b70 */ TArray<FRigModuleInstance> Modules;
    /* 0x0ba0 */ FModularRigSettings ModularRigSettings;
    /* 0x0ba8 */ FModularRigModel ModularRigModel;
    /* 0x0ca8 */ TArray<FRigModuleExecutionElement> ExecutionQueue;

    TArray<FName> ExecuteEventOnAllModules(FName InEvent);
    bool ExecuteEventOnModuleByNameForBP(FName InEvent, FName InModuleName);
    bool ExecuteEventOnModuleForBP(FName InEvent, FString InModulePath);
    TArray<FName> GetEventsForAllModules() const;
    TArray<FName> GetEventsForModule(FString InModulePath) const;
    TArray<FName> GetEventsForModuleByName(FName InModuleName) const;
    TArray<FName> GetModuleNames() const;
    TArray<FString> GetModulePaths() const;
    UControlRig* GetModuleRig(FString InModulePath);
    UControlRig* GetModuleRigByName(FName InModuleName);
    FName GetParentModuleNameForBP(FName InModuleName) const;
    FString GetParentPathForBP(FString InModulePath) const;
};

// Size: 0x60
struct FModularRigConnections {
    /* 0x0000 */ TArray<FModularRigSingleConnection> ConnectionList;
};

// Size: 0x50
class UModularRigController : public UObject {

    FName AddModule(const FName& InModuleName, UClass* InClass, const FName& InParentModuleName, bool bSetupUndo);
    bool AddTargetToArrayConnector(const FRigElementKey& InConnectorKey, const FRigElementKey& InTargetKey, bool bSetupUndo, bool bAutoResolveOtherConnectors, bool bCheckValidConnection);
    bool AutoConnectModules(const TArray<FName>& InModuleNames, bool bReplaceExistingConnections, bool bSetupUndo);
    bool AutoConnectSecondaryConnectors(const TArray<FRigElementKey>& InConnectorKeys, bool bReplaceExistingConnections, bool bSetupUndo);
    bool BindModuleVariable(const FName& InModuleName, const FName& InVariableName, FString InSourcePath, bool bSetupUndo);
    bool CanConnectConnectorToElement(const FRigElementKey& InConnectorKey, const FRigElementKey& InTargetKey, FText& OutErrorMessage);
    bool CanConnectConnectorToElements(const FRigElementKey& InConnectorKey, const TArray<FRigElementKey>& InTargetKeys, FText& OutErrorMessage);
    bool ConnectConnectorToElement(const FRigElementKey& InConnectorKey, const FRigElementKey& InTargetKey, bool bSetupUndo, bool bAutoResolveOtherConnectors, bool bCheckValidConnection);
    bool ConnectConnectorToElements(const FRigElementKey& InConnectorKey, const TArray<FRigElementKey>& InTargetKeys, bool bSetupUndo, bool bAutoResolveOtherConnectors, bool bCheckValidConnection);
    bool DeleteModule(const FName& InModuleName, bool bSetupUndo);
    bool DeselectModule(const FName& InModuleName);
    bool DisconnectConnector(const FRigElementKey& InConnectorKey, bool bDisconnectSubModules, bool bSetupUndo);
    TArray<FRigElementKey> DisconnectCyclicConnectors(bool bSetupUndo);
    FString ExportModuleSettingsToString(TArray<FName> InModuleNames) const;
    TArray<FName> GetAllModules() const;
    TArray<FRigElementKey> GetConnectorsForModule(FName InModuleName) const;
    FRigModuleReference GetModuleReference(FName InModuleName) const;
    TArray<FName> GetSelectedModules() const;
    bool ImportModuleSettingsFromString(FString InContent, TArray<FName> InOptionalModuleNames, bool bSetupUndo);
    FName MirrorModule(const FName& InModuleName, const FRigVMMirrorSettings& InSettings, bool bSetupUndo);
    FName RenameModule(const FName& InModuleName, const FName& InNewName, bool bSetupUndo);
    bool ReparentModule(const FName& InModuleName, const FName& InNewParentModuleName, bool bSetupUndo);
    bool ResetConfigValueInModule(const FName& InModuleName, FString InPath, bool bClearOverride, bool bSetupUndo);
    bool SelectModule(const FName& InModuleName, const bool InSelected);
    bool SetConfigValueInModule(const FName& InModuleName, const FName& InVariableName, FString InValue, bool bSetupUndo);
    bool SetModuleSelection(const TArray<FName>& InModuleNames);
    bool SwapModuleClass(const FName& InModuleName, UClass* InNewClass, bool bSetupUndo);
    bool SwapModulesOfClass(UClass* InOldClass, UClass* InNewClass, bool bSetupUndo);
    bool UnBindModuleVariable(const FName& InModuleName, const FName& InVariableName, bool bSetupUndo);
};

// Size: 0x100
struct FModularRigModel {
    /* 0x0000 */ TArray<FRigModuleReference> Modules;
    /* 0x0030 */ FModularRigConnections Connections;
    /* 0x0090 */ UObject* Controller;
    /* 0x0098 */ TMap<FRigHierarchyModulePath, FName> PreviousModulePaths;
};

// Size: 0x110
struct FModularRigModuleSettingsForClipboard {
    /* 0x0000 */ FSoftObjectPath ModuleClass;
    /* 0x0020 */ TMap<FString, FString> Defaults;
    /* 0x0070 */ TMap<FString, FString> Overrides;
    /* 0x00c0 */ TMap<FName, FString> Bindings;
};

// Size: 0x50
struct FModularRigModuleSettingsSetForClipboard {
    /* 0x0000 */ TMap<FName, FModularRigModuleSettingsForClipboard> Settings;
};

// Size: 0x48
struct FModularRigResolveResult {
    /* 0x0000 */ FRigElementKey Connector;
    /* 0x0010 */ TArray<FRigElementResolveResult> Matches;
    /* 0x0020 */ TArray<FRigElementResolveResult> Excluded;
    /* 0x0030 */ EModularRigResolveState State;
    /* 0x0038 */ FText Message;
};

// Size: 0x30
class UModularRigRuleManager : public UObject {
};

// Size: 0x1
struct FModularRigSettings {
    /* 0x0000 */ bool bAutoResolve;
};

// Size: 0x28
struct FModularRigSingleConnection {
    /* 0x0000 */ FRigElementKey Connector;
    /* 0x000c */ FRigElementKey Target;
    /* 0x0018 */ TArray<FRigElementKey> Targets;
};

// Size: 0x148
struct FMovieSceneControlRigInstanceData : public FMovieSceneSequenceInstanceData {
    /* 0x0008 */ bool bAdditive;
    /* 0x0009 */ bool bApplyBoneFilter;
    /* 0x0010 */ FInputBlendPose BoneFilter;
    /* 0x0020 */ FMovieSceneFloatChannel Weight;
    /* 0x0130 */ FMovieSceneEvaluationOperand Operand;
};

// Size: 0x248
class UMovieSceneControlRigParameterEvaluatorSystem : public UMovieSceneEntitySystem {
    /* 0x0240 */ UMovieScenePiecewiseDoubleBlenderSystem* DoubleBlenderSystem;
};

// Size: 0x440
class UMovieSceneControlRigParameterSection : public UMovieSceneParameterSection {
    /* 0x01b8 */ UControlRig* ControlRig;
    /* 0x01c0 */ UClass* ControlRigClass;
    /* 0x01c8 */ TArray<bool> ControlsMask;
    /* 0x01d8 */ TSet<FName> ControlNameMask;
    /* 0x0228 */ FMovieSceneTransformMask TransformMask;
    /* 0x0230 */ FMovieSceneFloatChannel Weight;
    /* 0x0340 */ TMap<FName, FChannelMapInfo> ControlChannelMap;
    /* 0x0390 */ TArray<FEnumParameterNameAndCurve> EnumParameterNamesAndCurves;
    /* 0x03a0 */ TArray<FIntegerParameterNameAndCurve> IntegerParameterNamesAndCurves;
    /* 0x03b0 */ TArray<FSpaceControlNameAndChannel> SpaceChannels;
    /* 0x03c0 */ TArray<FConstraintAndActiveChannel> ConstraintsChannels;
};

// Size: 0xc0
struct FMovieSceneControlRigParameterTemplate : public FMovieSceneParameterSectionTemplate {
    /* 0x0080 */ TArray<FEnumParameterNameAndCurve> Enums;
    /* 0x0090 */ TArray<FIntegerParameterNameAndCurve> Integers;
    /* 0x00a0 */ TArray<FSpaceControlNameAndChannel> Spaces;
    /* 0x00b0 */ TArray<FConstraintAndActiveChannel> Constraints;
};

// Size: 0x290
class UMovieSceneControlRigParameterTrack : public UMovieSceneNameableTrack {
    /* 0x0128 */ TMap<FName, TWeakObjectPtr<UMovieSceneSection>> SectionToKeyPerControl;
    /* 0x01b0 */ UControlRig* ControlRig;
    /* 0x01b8 */ UMovieSceneSection* SectionToKey;
    /* 0x01c0 */ TArray<UMovieSceneSection*> Sections;
    /* 0x01d0 */ FName TrackName;
    /* 0x01d8 */ TMap<FName, FControlRotationOrder> ControlsRotationOrder;
    /* 0x0228 */ int32_t PriorityOrder;
    /* 0x0230 */ FInstancedPropertyBag ControlRigSettingsOverrides;
    /* 0x0240 */ TMap<TWeakObjectPtr<UWorld>, UControlRig*> GameWorldControlRigs;
};

// Size: 0x10
struct FMovieSceneControlRigSpaceBaseKey {
    /* 0x0000 */ EMovieSceneControlRigSpaceType SpaceType;
    /* 0x0004 */ FRigElementKey ControlRigElement;
};

// Size: 0x110
struct FMovieSceneControlRigSpaceChannel : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> KeyTimes;
    /* 0x0060 */ TArray<FMovieSceneControlRigSpaceBaseKey> KeyValues;
    /* 0x0070 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x10
struct FRegionScaleFactors {
    /* 0x0000 */ float PositiveWidth;
    /* 0x0004 */ float NegativeWidth;
    /* 0x0008 */ float PositiveHeight;
    /* 0x000c */ float NegativeHeight;
};

// Size: 0x18
struct FRigAndConnectionRule : public FRigConnectionRule {
    /* 0x0008 */ TArray<FRigConnectionRuleStash> ChildRules;
};

// Size: 0x48
struct FRigBaseComponent {
};

// Size: 0x58
struct FRigBaseElement {
    /* 0x0010 */ FRigElementKey Key;
    /* 0x001c */ int32_t Index;
    /* 0x0020 */ int32_t SubIndex;
    /* 0x0024 */ int32_t CreatedAtInstructionIndex;
    /* 0x0028 */ bool bSelected;
};

// Size: 0x20
struct FRigBaseMetadata {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ ERigMetadataType Type;
};

// Size: 0x170
struct FRigBone : public FRigElement {
    /* 0x0018 */ FName ParentName;
    /* 0x0020 */ int32_t ParentIndex;
    /* 0x0030 */ FTransform InitialTransform;
    /* 0x0090 */ FTransform GlobalTransform;
    /* 0x00f0 */ FTransform LocalTransform;
    /* 0x0150 */ TArray<int32_t> Dependents;
    /* 0x0160 */ ERigBoneType Type;
};

// Size: 0x128
struct FRigBoneElement : public FRigSingleParentElement {
    /* 0x0120 */ ERigBoneType BoneType;
};

// Size: 0x10
struct FRigBoneHierarchy {
    /* 0x0000 */ TArray<FRigBone> Bones;
};

// Size: 0x30
struct FRigBoolArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<bool> Value;
};

// Size: 0x28
struct FRigBoolMetadata : public FRigBaseMetadata {
    /* 0x0020 */ bool Value;
};

// Size: 0x8
struct FRigChildOfPrimaryConnectionRule : public FRigConnectionRule {
};

// Size: 0x14
struct FRigComponentKey {
    /* 0x0000 */ FRigElementKey ElementKey;
    /* 0x000c */ FName Name;
};

// Size: 0x10
struct FRigComputedTransform {
};

// Size: 0x8
struct FRigConnectionRule {
};

// Size: 0x20
struct FRigConnectionRuleStash {
    /* 0x0000 */ FString ScriptStructPath;
    /* 0x0010 */ FString ExportedText;
};

// Size: 0x80
struct FRigConnectorElement : public FRigBaseElement {
    /* 0x0058 */ FRigConnectorSettings Settings;
};

// Size: 0x28
struct FRigConnectorSettings {
    /* 0x0000 */ FString Description;
    /* 0x0010 */ EConnectorType Type;
    /* 0x0011 */ bool bOptional;
    /* 0x0012 */ bool bIsArray;
    /* 0x0018 */ TArray<FRigConnectionRuleStash> Rules;
};

// Size: 0x40
struct FRigConnectorState {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FRigElementKey ResolvedTarget;
    /* 0x0018 */ FRigConnectorSettings Settings;
};

// Size: 0x360
struct FRigControl : public FRigElement {
    /* 0x0018 */ ERigControlType ControlType;
    /* 0x001c */ FName DisplayName;
    /* 0x0024 */ FName ParentName;
    /* 0x002c */ int32_t ParentIndex;
    /* 0x0030 */ FName SpaceName;
    /* 0x0038 */ int32_t SpaceIndex;
    /* 0x0040 */ FTransform OffsetTransform;
    /* 0x00a0 */ FRigControlValue InitialValue;
    /* 0x0124 */ FRigControlValue Value;
    /* 0x01a8 */ ERigControlAxis PrimaryAxis;
    /* 0x01a9 */ bool bIsCurve;
    /* 0x01aa */ bool bAnimatable;
    /* 0x01ab */ bool bLimitTranslation;
    /* 0x01ac */ bool bLimitRotation;
    /* 0x01ad */ bool bLimitScale;
    /* 0x01ae */ bool bDrawLimits;
    /* 0x01b0 */ FRigControlValue MinimumValue;
    /* 0x0234 */ FRigControlValue MaximumValue;
    /* 0x02b8 */ bool bGizmoEnabled;
    /* 0x02b9 */ bool bGizmoVisible;
    /* 0x02bc */ FName GizmoName;
    /* 0x02d0 */ FTransform GizmoTransform;
    /* 0x0330 */ FLinearColor GizmoColor;
    /* 0x0340 */ TArray<int32_t> Dependents;
    /* 0x0350 */ bool bIsTransientControl;
    /* 0x0358 */ UEnum* ControlEnum;
};

// Size: 0x220
struct FRigControlCopy {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ ERigControlType ControlType;
    /* 0x000c */ FRigElementKey ParentKey;
    /* 0x0018 */ FRigControlValue Value;
    /* 0x00a0 */ FTransform OffsetTransform;
    /* 0x0100 */ FTransform ParentTransform;
    /* 0x0160 */ FTransform LocalTransform;
    /* 0x01c0 */ FTransform GlobalTransform;
};

// Size: 0x590
struct FRigControlElement : public FRigMultiParentElement {
    /* 0x0230 */ FRigControlSettings Settings;
    /* 0x0450 */ FRigPreferredEulerAngles PreferredEulerAngles;
};

// Size: 0x20
struct FRigControlElementCustomization {
    /* 0x0000 */ TArray<FRigElementKeyWithLabel> AvailableSpaces;
    /* 0x0010 */ TArray<FRigElementKey> RemovedSpaces;
};

// Size: 0x10
struct FRigControlHierarchy {
    /* 0x0000 */ TArray<FRigControl> Controls;
};

// Size: 0x2
struct FRigControlLimitEnabled {
    /* 0x0000 */ bool bMinimum;
    /* 0x0001 */ bool bMaximum;
};

// Size: 0x18
struct FRigControlModifiedContext {
};

// Size: 0x220
struct FRigControlSettings {
    /* 0x0000 */ ERigControlAnimationType AnimationType;
    /* 0x0001 */ ERigControlType ControlType;
    /* 0x0004 */ FName DisplayName;
    /* 0x000c */ ERigControlAxis PrimaryAxis;
    /* 0x000d */ bool bIsCurve;
    /* 0x0010 */ TArray<FRigControlLimitEnabled> LimitEnabled;
    /* 0x0020 */ bool bDrawLimits;
    /* 0x0024 */ FRigControlValue MinimumValue;
    /* 0x00a8 */ FRigControlValue MaximumValue;
    /* 0x012c */ bool bShapeVisible;
    /* 0x012d */ ERigControlVisibility ShapeVisibility;
    /* 0x0130 */ FName ShapeName;
    /* 0x0138 */ FLinearColor ShapeColor;
    /* 0x0148 */ bool bIsTransientControl;
    /* 0x0150 */ UEnum* ControlEnum;
    /* 0x0158 */ FRigControlElementCustomization Customization;
    /* 0x0178 */ TArray<FRigElementKey> DrivenControls;
    /* 0x0198 */ bool bGroupWithParentControl;
    /* 0x0199 */ bool bRestrictSpaceSwitching;
    /* 0x01a0 */ TArray<ERigControlTransformChannel> FilteredChannels;
    /* 0x01b0 */ EEulerRotationOrder PreferredRotationOrder;
    /* 0x01b1 */ bool bUsePreferredRotationOrder;
    /* 0x01c0 */ FTransform ShapeTransform;
};

// Size: 0x84
struct FRigControlValue {
    /* 0x0000 */ FRigControlValueStorage FloatStorage;
};

// Size: 0x84
struct FRigControlValueStorage {
    /* 0x0000 */ float Float00;
    /* 0x0004 */ float Float01;
    /* 0x0008 */ float Float02;
    /* 0x000c */ float Float03;
    /* 0x0010 */ float Float10;
    /* 0x0014 */ float Float11;
    /* 0x0018 */ float Float12;
    /* 0x001c */ float Float13;
    /* 0x0020 */ float Float20;
    /* 0x0024 */ float Float21;
    /* 0x0028 */ float Float22;
    /* 0x002c */ float Float23;
    /* 0x0030 */ float Float30;
    /* 0x0034 */ float Float31;
    /* 0x0038 */ float Float32;
    /* 0x003c */ float Float33;
    /* 0x0040 */ float Float00_2;
    /* 0x0044 */ float Float01_2;
    /* 0x0048 */ float Float02_2;
    /* 0x004c */ float Float03_2;
    /* 0x0050 */ float Float10_2;
    /* 0x0054 */ float Float11_2;
    /* 0x0058 */ float Float12_2;
    /* 0x005c */ float Float13_2;
    /* 0x0060 */ float Float20_2;
    /* 0x0064 */ float Float21_2;
    /* 0x0068 */ float Float22_2;
    /* 0x006c */ float Float23_2;
    /* 0x0070 */ float Float30_2;
    /* 0x0074 */ float Float31_2;
    /* 0x0078 */ float Float32_2;
    /* 0x007c */ float Float33_2;
    /* 0x0080 */ bool bValid;
};

// Size: 0x40
struct FRigCurrentAndInitialDirtyState {
    /* 0x0000 */ FRigLocalAndGlobalDirtyState Current;
    /* 0x0020 */ FRigLocalAndGlobalDirtyState Initial;
};

// Size: 0x40
struct FRigCurrentAndInitialTransform {
    /* 0x0000 */ FRigLocalAndGlobalTransform Current;
    /* 0x0020 */ FRigLocalAndGlobalTransform Initial;
};

// Size: 0x20
struct FRigCurve : public FRigElement {
    /* 0x0018 */ float Value;
};

// Size: 0x10
struct FRigCurveContainer {
    /* 0x0000 */ TArray<FRigCurve> Curves;
};

// Size: 0x68
struct FRigCurveElement : public FRigBaseElement {
};

// Size: 0x70
struct FRigDispatchFactory : public FRigVMDispatchFactory {
};

// Size: 0xa0
struct FRigDispatch_AnimAttributeBase : public FRigDispatchFactory {
};

// Size: 0xa8
struct FRigDispatch_ComponentBase : public FRigDispatchFactory {
};

// Size: 0xa0
struct FRigDispatch_GetAnimAttribute : public FRigDispatch_AnimAttributeBase {
};

// Size: 0xa8
struct FRigDispatch_GetComponentContent : public FRigDispatch_ComponentBase {
};

// Size: 0xa0
struct FRigDispatch_GetMetadata : public FRigDispatch_MetadataBase {
};

// Size: 0xa0
struct FRigDispatch_GetModuleMetadata : public FRigDispatch_GetMetadata {
};

// Size: 0xa8
struct FRigDispatch_GetTopLevelComponentContent : public FRigDispatch_ComponentBase {
};

// Size: 0x70
struct FRigDispatch_GetUserData : public FRigDispatchFactory {
};

// Size: 0xa0
struct FRigDispatch_MetadataBase : public FRigDispatchFactory {
};

// Size: 0xa0
struct FRigDispatch_SetAnimAttribute : public FRigDispatch_AnimAttributeBase {
};

// Size: 0xa8
struct FRigDispatch_SetComponentContent : public FRigDispatch_ComponentBase {
};

// Size: 0xa0
struct FRigDispatch_SetMetadata : public FRigDispatch_MetadataBase {
};

// Size: 0xa0
struct FRigDispatch_SetModuleMetadata : public FRigDispatch_SetMetadata {
};

// Size: 0xa8
struct FRigDispatch_SetTopLevelComponentContent : public FRigDispatch_ComponentBase {
};

// Size: 0xa8
struct FRigDispatch_SpawnComponent : public FRigDispatch_ComponentBase {
};

// Size: 0xa8
struct FRigDispatch_SpawnTopLevelComponent : public FRigDispatch_ComponentBase {
};

// Size: 0x18
struct FRigElement {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ int32_t Index;
};

// Size: 0xc
struct FRigElementKey {
    /* 0x0000 */ ERigElementType Type;
    /* 0x0004 */ FName Name;
};

// Size: 0x30
struct FRigElementKeyArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FRigElementKey> Value;
};

// Size: 0x10
struct FRigElementKeyCollection {
    /* 0x0000 */ TArray<FRigElementKey> Keys;
};

// Size: 0x30
struct FRigElementKeyMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FRigElementKey Value;
};

// Size: 0x14
struct FRigElementKeyWithLabel {
    /* 0x0000 */ FRigElementKey Key;
    /* 0x000c */ FName Label;
};

// Size: 0xa0
struct FRigElementParentConstraint {
};

// Size: 0x20
struct FRigElementResolveResult {
    /* 0x0000 */ FRigElementKey Key;
    /* 0x000c */ ERigElementResolveState State;
    /* 0x0010 */ FText Message;
};

// Size: 0xc
struct FRigElementWeight {
    /* 0x0000 */ float Location;
    /* 0x0004 */ float Rotation;
    /* 0x0008 */ float Scale;
};

// Size: 0x28
struct FRigEventContext {
};

// Size: 0x30
struct FRigFloatArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<float> Value;
};

// Size: 0x28
struct FRigFloatMetadata : public FRigBaseMetadata {
    /* 0x0020 */ float Value;
};

// Size: 0x5f0
class URigHierarchy : public UObject {
    /* 0x0040 */ FMulticastInlineDelegate ModifiedEventDynamic;
    /* 0x00a8 */ uint32_t TopologyVersion;
    /* 0x00ac */ uint32_t MetadataVersion;
    /* 0x00b0 */ uint16_t MetadataTagVersion;
    /* 0x00b2 */ bool bEnableDirtyPropagation;
    /* 0x02ac */ int32_t TransformStackIndex;
    /* 0x0328 */ URigHierarchyController* HierarchyController;
    /* 0x0338 */ UModularRigRuleManager* RuleManager;
    /* 0x04d0 */ URigHierarchy* HierarchyForCacheValidation;

    bool Contains_ForBlueprint(FRigElementKey InKey) const;
    void CopyHierarchy(URigHierarchy* InHierarchy);
    void CopyPose(URigHierarchy* InHierarchy, bool bCurrent, bool bInitial, bool bWeights, bool bMatchPoseInGlobalIfNeeded);
    FRigBoneElement FindBone_ForBlueprintOnly(const FRigElementKey& InKey) const;
    FRigControlElement FindControl_ForBlueprintOnly(const FRigElementKey& InKey) const;
    FRigNullElement FindNull_ForBlueprintOnly(const FRigElementKey& InKey) const;
    TArray<FRigComponentKey> GetAllComponentKeys() const;
    TArray<FRigElementKey> GetAllKeys_ForBlueprint(bool bTraverse) const;
    TArray<FRigElementKey> GetBoneKeys(bool bTraverse) const;
    TArray<bool> GetBoolArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    bool GetBoolMetadata(FRigElementKey InItem, FName InMetadataName, bool DefaultValue) const;
    TArray<FRigElementKey> GetChildren(FRigElementKey InKey, bool bRecursive) const;
    FString GetComponentContent(FRigElementKey InElement, int32_t InComponentIndex) const;
    FRigComponentKey GetComponentKey(FRigElementKey InElement, int32_t InComponentIndex) const;
    TArray<FRigComponentKey> GetComponentKeys(FRigElementKey InElement) const;
    FName GetComponentName(FRigElementKey InElement, int32_t InComponentIndex) const;
    UScriptStruct* GetComponentType(FRigElementKey InElement, int32_t InComponentIndex) const;
    TArray<FRigElementKey> GetConnectorKeys(bool bTraverse) const;
    TArray<FRigConnectorState> GetConnectorStates() const;
    TArray<FRigElementKey> GetControlKeys(bool bTraverse) const;
    FVector GetControlPreferredEulerAngles(FRigElementKey InKey, EEulerRotationOrder InRotationOrder, bool bInitial) const;
    FVector GetControlPreferredEulerAnglesByIndex(int32_t InElementIndex, EEulerRotationOrder InRotationOrder, bool bInitial) const;
    EEulerRotationOrder GetControlPreferredEulerRotationOrder(FRigElementKey InKey, bool bFromSettings) const;
    EEulerRotationOrder GetControlPreferredEulerRotationOrderByIndex(int32_t InElementIndex, bool bFromSettings) const;
    FRotator GetControlPreferredRotator(FRigElementKey InKey, bool bInitial) const;
    FRotator GetControlPreferredRotatorByIndex(int32_t InElementIndex, bool bInitial) const;
    FRigControlValue GetControlValue(FRigElementKey InKey, ERigControlValueType InValueType) const;
    FRigControlValue GetControlValueByIndex(int32_t InElementIndex, ERigControlValueType InValueType) const;
    URigHierarchyController* GetController(bool bCreateIfNeeded);
    TArray<FRigElementKey> GetCurveKeys() const;
    float GetCurveValue(FRigElementKey InKey) const;
    float GetCurveValueByIndex(int32_t InElementIndex) const;
    FRigElementKey GetDefaultParent(FRigElementKey InKey) const;
    static FEulerTransform GetEulerTransformFromControlValue(FRigControlValue InValue);
    FRigElementKey GetFirstParent(FRigElementKey InKey) const;
    TArray<float> GetFloatArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    static float GetFloatFromControlValue(FRigControlValue InValue);
    float GetFloatMetadata(FRigElementKey InItem, FName InMetadataName, float DefaultValue) const;
    FTransform GetGlobalControlOffsetTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetGlobalControlOffsetTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    FTransform GetGlobalControlShapeTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetGlobalControlShapeTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    FTransform GetGlobalTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetGlobalTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    int32_t GetIndex_ForBlueprint(FRigElementKey InKey) const;
    TArray<int32_t> GetInt32ArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    int32_t GetInt32Metadata(FRigElementKey InItem, FName InMetadataName, int32_t DefaultValue) const;
    static int32_t GetIntFromControlValue(FRigControlValue InValue);
    FRigElementKey GetKey(int32_t InElementIndex) const;
    TArray<FRigElementKey> GetKeys(const TArray<int32_t> InElementIndices) const;
    TArray<FLinearColor> GetLinearColorArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    FLinearColor GetLinearColorMetadata(FRigElementKey InItem, FName InMetadataName, FLinearColor DefaultValue) const;
    FTransform GetLocalControlShapeTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetLocalControlShapeTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    int32_t GetLocalIndex_ForBlueprint(FRigElementKey InKey) const;
    FTransform GetLocalTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetLocalTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    TArray<FName> GetMetadataNames(FRigElementKey InItem) const;
    ERigMetadataType GetMetadataType(FRigElementKey InItem, FName InMetadataName) const;
    FName GetModuleFName(FRigElementKey InItem) const;
    FString GetModuleName(FRigElementKey InItem) const;
    FString GetModulePath(FRigElementKey InItem) const;
    FName GetModulePathFName(FRigElementKey InItem) const;
    FString GetModulePrefix(FRigElementKey InItem) const;
    TArray<FName> GetNameArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    FName GetNameMetadata(FRigElementKey InItem, FName InMetadataName, FName DefaultValue) const;
    FString GetNameSpace(FRigElementKey InItem) const;
    FName GetNameSpaceFName(FRigElementKey InItem) const;
    TArray<FRigElementKey> GetNullKeys(bool bTraverse) const;
    int32_t GetNumberOfParents(FRigElementKey InKey) const;
    FTransform GetParentTransform(FRigElementKey InKey, bool bInitial) const;
    FTransform GetParentTransformByIndex(int32_t InElementIndex, bool bInitial) const;
    FRigElementWeight GetParentWeight(FRigElementKey InChild, FRigElementKey InParent, bool bInitial) const;
    TArray<FRigElementWeight> GetParentWeightArray(FRigElementKey InChild, bool bInitial) const;
    TArray<FRigElementKey> GetParents(FRigElementKey InKey, bool bRecursive) const;
    FRigPose GetPose(bool bInitial, bool bIncludeTransientControls) const;
    FName GetPreviousHierarchyName(const FRigHierarchyKey& InKey) const;
    FRigHierarchyKey GetPreviousHierarchyParent(const FRigHierarchyKey& InKey) const;
    FName GetPreviousName(const FRigElementKey& InKey) const;
    FRigElementKey GetPreviousParent(const FRigElementKey& InKey) const;
    TArray<FQuat> GetQuatArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    FQuat GetQuatMetadata(FRigElementKey InItem, FName InMetadataName, FQuat DefaultValue) const;
    TArray<FRigElementKey> GetReferenceKeys(bool bTraverse) const;
    TArray<FRigElementKey> GetRigElementKeyArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    FRigElementKey GetRigElementKeyMetadata(FRigElementKey InItem, FName InMetadataName, FRigElementKey DefaultValue) const;
    TArray<FRigElementKey> GetRootElementKeys() const;
    TArray<FRotator> GetRotatorArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    static FRotator GetRotatorFromControlValue(FRigControlValue InValue);
    FRotator GetRotatorMetadata(FRigElementKey InItem, FName InMetadataName, FRotator DefaultValue) const;
    UModularRigRuleManager* GetRuleManager(bool bCreateIfNeeded);
    TArray<FRigHierarchyKey> GetSelectedHierarchyKeys_ForBlueprint() const;
    TArray<FRigElementKey> GetSelectedKeys(ERigElementType InTypeFilter) const;
    TArray<FRigElementKey> GetSocketKeys(bool bTraverse) const;
    TArray<FRigSocketState> GetSocketStates() const;
    TArray<FName> GetTags(FRigElementKey InItem) const;
    FString GetTopLevelComponentContent(int32_t InTopLevelComponentIndex) const;
    FRigComponentKey GetTopLevelComponentKey(int32_t InTopLevelComponentIndex) const;
    TArray<FRigComponentKey> GetTopLevelComponentKeys() const;
    FName GetTopLevelComponentName(int32_t InTopLevelComponentIndex) const;
    UScriptStruct* GetTopLevelComponentType(int32_t InTopLevelComponentIndex) const;
    TArray<FTransform> GetTransformArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    static FTransform GetTransformFromControlValue(FRigControlValue InValue);
    FTransform GetTransformMetadata(FRigElementKey InItem, FName InMetadataName, FTransform DefaultValue) const;
    static FTransformNoScale GetTransformNoScaleFromControlValue(FRigControlValue InValue);
    static FVector2D GetVector2DFromControlValue(FRigControlValue InValue);
    TArray<FVector> GetVectorArrayMetadata(FRigElementKey InItem, FName InMetadataName) const;
    static FVector GetVectorFromControlValue(FRigControlValue InValue);
    FVector GetVectorMetadata(FRigElementKey InItem, FName InMetadataName, FVector DefaultValue) const;
    bool HasTag(FRigElementKey InItem, FName InTag) const;
    bool IsComponentSelected(FRigComponentKey InKey) const;
    bool IsControllerAvailable() const;
    bool IsCurveValueSet(FRigElementKey InKey) const;
    bool IsCurveValueSetByIndex(int32_t InElementIndex) const;
    bool IsParentedTo(FRigElementKey InChild, FRigElementKey InParent) const;
    bool IsProcedural(const FRigElementKey& InKey) const;
    bool IsSelected(FRigElementKey InKey) const;
    bool IsSelectedByIndex(int32_t InIndex) const;
    bool IsValidIndex(int32_t InElementIndex) const;
    static FRigControlValue MakeControlValueFromBool(bool InValue);
    static FRigControlValue MakeControlValueFromEulerTransform(FEulerTransform InValue);
    static FRigControlValue MakeControlValueFromFloat(float InValue);
    static FRigControlValue MakeControlValueFromInt(int32_t InValue);
    static FRigControlValue MakeControlValueFromRotator(FRotator InValue);
    static FRigControlValue MakeControlValueFromTransform(FTransform InValue);
    static FRigControlValue MakeControlValueFromTransformNoScale(FTransformNoScale InValue);
    static FRigControlValue MakeControlValueFromVector(FVector InValue);
    static FRigControlValue MakeControlValueFromVector2D(FVector2D InValue);
    int32_t Num() const;
    int32_t NumComponents(FRigElementKey InElement) const;
    int32_t NumTopLevelComponents() const;
    bool RemoveAllMetadata(FRigElementKey InItem);
    bool RemoveMetadata(FRigElementKey InItem, FName InMetadataName);
    void Reset();
    void ResetCurveValues();
    void ResetPoseToInitial(ERigElementType InTypeFilter);
    void ResetToDefault();
    TArray<FRigElementKey> RestoreConnectorsFromStates(TArray<FRigConnectorState> InStates, bool bSetupUndoRedo);
    TArray<FRigElementKey> RestoreSocketsFromStates(TArray<FRigSocketState> InStates, bool bSetupUndoRedo);
    void SendAutoKeyEvent(FRigElementKey InElement, float InOffsetInSeconds, bool bAsynchronous);
    bool SetBoolArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<bool> InValue);
    bool SetBoolMetadata(FRigElementKey InItem, FName InMetadataName, bool InValue);
    void SetConnectorSettings(FRigElementKey InKey, FRigConnectorSettings InSettings, bool bSetupUndo, bool bForce, bool bPrintPythonCommands);
    void SetConnectorSettingsByIndex(int32_t InElementIndex, FRigConnectorSettings InSettings, bool bSetupUndo, bool bForce, bool bPrintPythonCommands);
    void SetControlOffsetTransform(FRigElementKey InKey, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommands);
    void SetControlOffsetTransformByIndex(int32_t InElementIndex, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommands);
    void SetControlPreferredEulerAngles(FRigElementKey InKey, const FVector& InEulerAngles, EEulerRotationOrder InRotationOrder, bool bInitial, bool bFixEulerFlips);
    void SetControlPreferredEulerAnglesByIndex(int32_t InElementIndex, const FVector& InEulerAngles, EEulerRotationOrder InRotationOrder, bool bInitial, bool bFixEulerFlips);
    void SetControlPreferredRotationOrder(FRigElementKey InKey, EEulerRotationOrder InRotationOrder);
    void SetControlPreferredRotationOrderByIndex(int32_t InElementIndex, EEulerRotationOrder InRotationOrder);
    void SetControlPreferredRotator(FRigElementKey InKey, const FRotator& InRotator, bool bInitial, bool bFixEulerFlips);
    void SetControlPreferredRotatorByIndex(int32_t InElementIndex, const FRotator& InRotator, bool bInitial, bool bFixEulerFlips);
    void SetControlSettings(FRigElementKey InKey, FRigControlSettings InSettings, bool bSetupUndo, bool bForce, bool bPrintPythonCommands);
    void SetControlSettingsByIndex(int32_t InElementIndex, FRigControlSettings InSettings, bool bSetupUndo, bool bForce, bool bPrintPythonCommands);
    void SetControlShapeTransform(FRigElementKey InKey, FTransform InTransform, bool bInitial, bool bSetupUndo);
    void SetControlShapeTransformByIndex(int32_t InElementIndex, FTransform InTransform, bool bInitial, bool bSetupUndo);
    void SetControlValue(FRigElementKey InKey, FRigControlValue InValue, ERigControlValueType InValueType, bool bSetupUndo, bool bPrintPythonCommands);
    void SetControlValueByIndex(int32_t InElementIndex, FRigControlValue InValue, ERigControlValueType InValueType, bool bSetupUndo, bool bPrintPythonCommands);
    void SetControlVisibility(FRigElementKey InKey, bool bVisibility);
    void SetControlVisibilityByIndex(int32_t InElementIndex, bool bVisibility);
    void SetCurveValue(FRigElementKey InKey, float InValue, bool bSetupUndo);
    void SetCurveValueByIndex(int32_t InElementIndex, float InValue, bool bSetupUndo);
    bool SetFloatArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<float> InValue);
    bool SetFloatMetadata(FRigElementKey InItem, FName InMetadataName, float InValue);
    void SetGlobalTransform(FRigElementKey InKey, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommand);
    void SetGlobalTransformByIndex(int32_t InElementIndex, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommand);
    bool SetInt32ArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<int32_t> InValue);
    bool SetInt32Metadata(FRigElementKey InItem, FName InMetadataName, int32_t InValue);
    bool SetLinearColorArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FLinearColor> InValue);
    bool SetLinearColorMetadata(FRigElementKey InItem, FName InMetadataName, FLinearColor InValue);
    void SetLocalTransform(FRigElementKey InKey, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommands);
    void SetLocalTransformByIndex(int32_t InElementIndex, FTransform InTransform, bool bInitial, bool bAffectChildren, bool bSetupUndo, bool bPrintPythonCommands);
    bool SetNameArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FName> InValue);
    bool SetNameMetadata(FRigElementKey InItem, FName InMetadataName, FName InValue);
    bool SetParentWeight(FRigElementKey InChild, FRigElementKey InParent, FRigElementWeight InWeight, bool bInitial, bool bAffectChildren);
    bool SetParentWeightArray(FRigElementKey InChild, TArray<FRigElementWeight> InWeights, bool bInitial, bool bAffectChildren);
    void SetPose_ForBlueprint(FRigPose InPose);
    bool SetQuatArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FQuat> InValue);
    bool SetQuatMetadata(FRigElementKey InItem, FName InMetadataName, FQuat InValue);
    bool SetRigElementKeyArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FRigElementKey> InValue);
    bool SetRigElementKeyMetadata(FRigElementKey InItem, FName InMetadataName, FRigElementKey InValue);
    bool SetRotatorArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FRotator> InValue);
    bool SetRotatorMetadata(FRigElementKey InItem, FName InMetadataName, FRotator InValue);
    bool SetTag(FRigElementKey InItem, FName InTag);
    bool SetTransformArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FTransform> InValue);
    bool SetTransformMetadata(FRigElementKey InItem, FName InMetadataName, FTransform InValue);
    bool SetVectorArrayMetadata(FRigElementKey InItem, FName InMetadataName, TArray<FVector> InValue);
    bool SetVectorMetadata(FRigElementKey InItem, FName InMetadataName, FVector InValue);
    TArray<FRigElementKey> SortKeys(const TArray<FRigElementKey>& InKeys) const;
    bool SwitchToDefaultParent(FRigElementKey InChild, bool bInitial, bool bAffectChildren);
    bool SwitchToParent(FRigElementKey InChild, FRigElementKey InParent, bool bInitial, bool bAffectChildren);
    bool SwitchToWorldSpace(FRigElementKey InChild, bool bInitial, bool bAffectChildren);
    void UnsetCurveValue(FRigElementKey InKey, bool bSetupUndo);
    void UnsetCurveValueByIndex(int32_t InElementIndex, bool bSetupUndo);
};

// Size: 0x40
struct FRigHierarchyContainer {
    /* 0x0000 */ FRigBoneHierarchy BoneHierarchy;
    /* 0x0010 */ FRigSpaceHierarchy SpaceHierarchy;
    /* 0x0020 */ FRigControlHierarchy ControlHierarchy;
    /* 0x0030 */ FRigCurveContainer CurveContainer;
};

// Size: 0x80
class URigHierarchyController : public UObject {
    /* 0x0028 */ bool bReportWarningsAndErrors;

    FRigElementKey AddAnimationChannel_ForBlueprint(FName InName, FRigElementKey InParentControl, FRigControlSettings InSettings, bool bSetupUndo, bool bPrintPythonCommand);
    bool AddAvailableSpace(FRigElementKey InControl, FRigElementKey InSpace, FName InDisplayLabel, bool bSetupUndo, bool bPrintPythonCommand);
    FRigElementKey AddBone(FName InName, FRigElementKey InParent, FTransform InTransform, bool bTransformInGlobal, ERigBoneType InBoneType, bool bSetupUndo, bool bPrintPythonCommand);
    bool AddChannelHost(FRigElementKey InChannel, FRigElementKey InHost, bool bSetupUndo, bool bPrintPythonCommand);
    FRigComponentKey AddComponent(UScriptStruct* InComponentStruct, FName InName, FRigElementKey InElement, FString InContent, bool bSetupUndo, bool bPrintPythonCommand);
    FRigElementKey AddConnector(FName InName, FRigConnectorSettings InSettings, bool bSetupUndo, bool bPrintPythonCommand);
    FRigElementKey AddControl_ForBlueprint(FName InName, FRigElementKey InParent, FRigControlSettings InSettings, FRigControlValue InValue, bool bSetupUndo, bool bPrintPythonCommand);
    FRigElementKey AddCurve(FName InName, float InValue, bool bSetupUndo, bool bPrintPythonCommand);
    FRigElementKey AddNull(FName InName, FRigElementKey InParent, FTransform InTransform, bool bTransformInGlobal, bool bSetupUndo, bool bPrintPythonCommand);
    bool AddParent(FRigElementKey InChild, FRigElementKey InParent, float InWeight, bool bMaintainGlobalTransform, FName InDisplayLabel, bool bSetupUndo);
    FRigElementKey AddSocket(FName InName, FRigElementKey InParent, FTransform InTransform, bool bTransformInGlobal, const FLinearColor& InColor, FString InDescription, bool bSetupUndo, bool bPrintPythonCommand);
    FRigComponentKey AddTopLevelComponent(UScriptStruct* InComponentStruct, FName InName, FString InContent, bool bSetupUndo, bool bPrintPythonCommand);
    bool ClearSelection(bool bSetupUndo);
    bool DeselectComponent(FRigComponentKey InKey);
    bool DeselectElement(FRigElementKey InKey);
    bool DeselectHierarchyKey(FRigHierarchyKey InKey, bool bSetupUndo);
    TArray<FRigElementKey> DuplicateElements(TArray<FRigElementKey> InKeys, bool bSelectNewElements, bool bSetupUndo, bool bPrintPythonCommands);
    FString ExportSelectionToText() const;
    FString ExportToText(TArray<FRigElementKey> InKeys) const;
    FRigControlSettings GetControlSettings(FRigElementKey InKey) const;
    URigHierarchy* GetHierarchy() const;
    TArray<FRigElementKey> ImportBones(USkeleton* InSkeleton, FName InNameSpace, bool bReplaceExistingBones, bool bRemoveObsoleteBones, bool bSelectBones, bool bSetupUndo, bool bPrintPythonCommand);
    TArray<FRigElementKey> ImportBonesFromSkeletalMesh(USkeletalMesh* InSkeletalMesh, const FName& InNameSpace, bool bReplaceExistingBones, bool bRemoveObsoleteBones, bool bSelectBones, bool bSetupUndo, bool bPrintPythonCommand);
    TArray<FRigElementKey> ImportCurves(USkeleton* InSkeleton, FName InNameSpace, bool bSelectCurves, bool bSetupUndo, bool bPrintPythonCommand);
    TArray<FRigElementKey> ImportCurvesFromSkeletalMesh(USkeletalMesh* InSkeletalMesh, FName InNameSpace, bool bSelectCurves, bool bSetupUndo, bool bPrintPythonCommand);
    TArray<FRigElementKey> ImportFromText(FString InContent, bool bReplaceExistingElements, bool bSelectNewElements, bool bSetupUndo, bool bPrintPythonCommands);
    TArray<FRigElementKey> ImportPreviewSkeletalMesh(USkeletalMesh* InSkeletalMesh, bool bReplaceExistingBones, bool bRemoveObsoleteBones, bool bSelectBones, bool bSetupUndo);
    TArray<FRigElementKey> ImportSocketsFromSkeletalMesh(USkeletalMesh* InSkeletalMesh, const FName& InNameSpace, bool bReplaceExistingSockets, bool bRemoveObsoleteSockets, bool bSelectSockets, bool bSetupUndo, bool bPrintPythonCommand);
    TArray<FRigElementKey> MirrorElements(TArray<FRigElementKey> InKeys, FRigVMMirrorSettings InSettings, bool bSelectNewElements, bool bSetupUndo, bool bPrintPythonCommands);
    bool RemoveAllParents(FRigElementKey InChild, bool bMaintainGlobalTransform, bool bSetupUndo, bool bPrintPythonCommand);
    bool RemoveAvailableSpace(FRigElementKey InControl, FRigElementKey InSpace, bool bSetupUndo, bool bPrintPythonCommand);
    bool RemoveChannelHost(FRigElementKey InChannel, FRigElementKey InHost, bool bSetupUndo, bool bPrintPythonCommand);
    bool RemoveComponent(FRigComponentKey InComponent, bool bSetupUndo, bool bPrintPythonCommand);
    bool RemoveElement(FRigElementKey InElement, bool bSetupUndo, bool bPrintPythonCommand);
    bool RemoveParent(FRigElementKey InChild, FRigElementKey InParent, bool bMaintainGlobalTransform, bool bSetupUndo, bool bPrintPythonCommand);
    FRigComponentKey RenameComponent(FRigComponentKey InComponent, FName InName, bool bSetupUndo, bool bPrintPythonCommand, bool bClearSelection);
    FRigElementKey RenameElement(FRigElementKey InElement, FName InName, bool bSetupUndo, bool bPrintPythonCommand, bool bClearSelection);
    bool ReorderElement(FRigElementKey InElement, int32_t InIndex, bool bSetupUndo, bool bPrintPythonCommand);
    FRigComponentKey ReparentComponent(FRigComponentKey InComponentKey, FRigElementKey InParentElementKey, bool bSetupUndo, bool bPrintPythonCommand, bool bClearSelection);
    bool SelectComponent(FRigComponentKey InKey, bool bSelect, bool bClearSelection, bool bSetupUndo);
    bool SelectElement(FRigElementKey InKey, bool bSelect, bool bClearSelection, bool bSetupUndo);
    bool SelectHierarchyKey(FRigHierarchyKey InKey, bool bSelect, bool bClearSelection, bool bSetupUndo);
    bool SetAvailableSpaceIndex(FRigElementKey InControl, FRigElementKey InSpace, int32_t InIndex, bool bSetupUndo, bool bPrintPythonCommand);
    bool SetAvailableSpaceLabel(FRigElementKey InControl, FRigElementKey InSpace, FName InDisplayLabel, bool bSetupUndo, bool bPrintPythonCommand);
    bool SetComponentContent(FRigComponentKey InComponent, FString InContent, bool bSetupUndo, bool bPrintPythonCommand);
    bool SetComponentSelection(const TArray<FRigComponentKey>& InKeys, bool bPrintPythonCommand);
    bool SetControlSettings(FRigElementKey InKey, FRigControlSettings InSettings, bool bSetupUndo) const;
    FName SetDisplayName(FRigElementKey InControl, FName InDisplayName, bool bRenameElement, bool bSetupUndo, bool bPrintPythonCommand);
    void SetHierarchy(URigHierarchy* InHierarchy);
    bool SetHierarchySelection(const TArray<FRigHierarchyKey>& InKeys, bool bPrintPythonCommand, bool bSetupUndo);
    bool SetParent(FRigElementKey InChild, FRigElementKey InParent, bool bMaintainGlobalTransform, bool bSetupUndo, bool bPrintPythonCommand);
    bool SetSelection(const TArray<FRigElementKey>& InKeys, bool bPrintPythonCommand, bool bSetupUndo);
};

// Size: 0x50
struct FRigHierarchyCopyPasteContent {
    /* 0x0000 */ TArray<FRigHierarchyCopyPasteContentPerElement> Elements;
    /* 0x0010 */ TArray<ERigElementType> Types;
    /* 0x0020 */ TArray<FString> contents;
    /* 0x0030 */ TArray<FTransform> LocalTransforms;
    /* 0x0040 */ TArray<FTransform> GlobalTransforms;
};

// Size: 0x60
struct FRigHierarchyCopyPasteContentPerElement {
    /* 0x0000 */ FRigElementKey Key;
    /* 0x0010 */ FString Content;
    /* 0x0020 */ TArray<FRigElementKeyWithLabel> Parents;
    /* 0x0030 */ TArray<FRigElementWeight> ParentWeights;
    /* 0x0040 */ TArray<FTransform> Poses;
    /* 0x0050 */ TArray<bool> DirtyStates;
};

// Size: 0x28
struct FRigHierarchyKey {
};

// Size: 0x40
struct FRigHierarchyModulePath {
    /* 0x0000 */ FString ModulePath;
};

// Size: 0x28
class IRigHierarchyProvider : public UInterface {
};

// Size: 0x1
struct FRigHierarchyRef {
};

// Size: 0x8
struct FRigHierarchySettings {
    /* 0x0000 */ EElementNameDisplayMode ElementNameDisplayMode;
    /* 0x0004 */ int32_t ProceduralElementLimit;
};

// Size: 0x20
struct FRigInfluenceEntry {
    /* 0x0000 */ FRigElementKey Source;
    /* 0x0010 */ TArray<FRigElementKey> AffectedList;
};

// Size: 0x10
struct FRigInfluenceEntryModifier {
    /* 0x0000 */ TArray<FRigElementKey> AffectedList;
};

// Size: 0x68
struct FRigInfluenceMap {
    /* 0x0000 */ FName EventName;
    /* 0x0008 */ TArray<FRigInfluenceEntry> Entries;
    /* 0x0018 */ TMap<FRigElementKey, int32_t> KeyToIndex;
};

// Size: 0x60
struct FRigInfluenceMapPerEvent {
    /* 0x0000 */ TArray<FRigInfluenceMap> Maps;
    /* 0x0010 */ TMap<FName, int32_t> EventToIndex;
};

// Size: 0x30
struct FRigInt32ArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<int32_t> Value;
};

// Size: 0x28
struct FRigInt32Metadata : public FRigBaseMetadata {
    /* 0x0020 */ int32_t Value;
};

// Size: 0x30
struct FRigLinearColorArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FLinearColor> Value;
};

// Size: 0x30
struct FRigLinearColorMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FLinearColor Value;
};

// Size: 0x20
struct FRigLocalAndGlobalDirtyState {
    /* 0x0000 */ FRigTransformDirtyState Global;
    /* 0x0010 */ FRigTransformDirtyState Local;
};

// Size: 0x20
struct FRigLocalAndGlobalTransform {
    /* 0x0000 */ FRigComputedTransform Local;
    /* 0x0010 */ FRigComputedTransform Global;
};

// Size: 0x38
struct FRigModuleConnector {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FRigConnectorSettings Settings;
};

// Size: 0xa0
struct FRigModuleDescription {
    /* 0x0000 */ FSoftObjectPath Path;
    /* 0x0020 */ FRigModuleSettings Settings;
};

// Size: 0x20
struct FRigModuleExecutionElement {
    /* 0x0000 */ FName ModuleName;
    /* 0x0010 */ FName EventName;
    /* 0x0018 */ bool bExecuted;
};

// Size: 0x20
struct FRigModuleIdentifier {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Type;
};

// Size: 0xb0
struct FRigModuleInstance {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UControlRig* RigPtr;
    /* 0x0010 */ FString ParentPath;
    /* 0x0020 */ FName ParentModuleName;
    /* 0x0028 */ TMap<FName, FRigVMExternalVariable> VariableBindings;
};

// Size: 0x2d0
struct FRigModuleReference {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FString ShortName;
    /* 0x0018 */ bool bShortNameBasedOnPath;
    /* 0x0020 */ FString ParentPath;
    /* 0x0030 */ FName ParentModuleName;
    /* 0x0038 */ TSoftClassPtr<UControlRig> Class;
    /* 0x0060 */ TMap<FRigElementKey, FRigElementKey> Connections;
    /* 0x00b0 */ TMap<FName, FString> ConfigValues;
    /* 0x0100 */ FControlRigOverrideContainer ConfigOverrides;
    /* 0x0258 */ TMap<FName, FString> Bindings;
    /* 0x02a8 */ FName PreviousName;
    /* 0x02b0 */ FName PreviousParentName;
};

// Size: 0x80
struct FRigModuleSettings {
    /* 0x0000 */ FRigModuleIdentifier Identifier;
    /* 0x0020 */ FSoftObjectPath Icon;
    /* 0x0040 */ FString Category;
    /* 0x0050 */ FString Keywords;
    /* 0x0060 */ FString Description;
    /* 0x0070 */ TArray<FRigModuleConnector> ExposedConnectors;
};

// Size: 0x230
struct FRigMultiParentElement : public FRigTransformElement {
};

// Size: 0x30
struct FRigNameArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FName> Value;
};

// Size: 0x28
struct FRigNameMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FName Value;
};

// Size: 0x230
struct FRigNullElement : public FRigMultiParentElement {
};

// Size: 0x18
struct FRigOrConnectionRule : public FRigConnectionRule {
    /* 0x0008 */ TArray<FRigConnectionRuleStash> ChildRules;
};

// Size: 0x28
struct FRigPhysicsSimulationBase {
};

// Size: 0x18
struct FRigPhysicsSolverDescription {
    /* 0x0000 */ FRigPhysicsSolverID ID;
    /* 0x0010 */ FName Name;
};

// Size: 0x10
struct FRigPhysicsSolverID {
    /* 0x0000 */ FGuid Guid;
};

// Size: 0x70
struct FRigPose {
    /* 0x0000 */ TArray<FRigPoseElement> Elements;
    /* 0x0010 */ int32_t HierarchyTopologyVersion;
    /* 0x0014 */ int32_t PoseHash;
};

// Size: 0x110
struct FRigPoseElement {
    /* 0x0000 */ FCachedRigElement Index;
    /* 0x0020 */ FTransform GlobalTransform;
    /* 0x0080 */ FTransform LocalTransform;
    /* 0x00e0 */ FVector PreferredEulerAngle;
    /* 0x00f8 */ FRigElementKey ActiveParent;
    /* 0x0104 */ float CurveValue;
};

// Size: 0x38
struct FRigPreferredEulerAngles {
    /* 0x0000 */ EEulerRotationOrder RotationOrder;
    /* 0x0008 */ FVector Current;
    /* 0x0020 */ FVector Initial;
};

// Size: 0x30
struct FRigQuatArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FQuat> Value;
};

// Size: 0x40
struct FRigQuatMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FQuat Value;
};

// Size: 0x130
struct FRigReferenceElement : public FRigSingleParentElement {
};

// Size: 0x30
struct FRigRotatorArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FRotator> Value;
};

// Size: 0x38
struct FRigRotatorMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FRotator Value;
};

// Size: 0x120
struct FRigSingleParentElement : public FRigTransformElement {
};

// Size: 0x120
struct FRigSocketElement : public FRigSingleParentElement {
};

// Size: 0xa0
struct FRigSocketState {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FRigElementKey Parent;
    /* 0x0020 */ FTransform InitialLocalTransform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ FString Description;
};

// Size: 0xf0
struct FRigSpace : public FRigElement {
    /* 0x0018 */ ERigSpaceType SpaceType;
    /* 0x001c */ FName ParentName;
    /* 0x0024 */ int32_t ParentIndex;
    /* 0x0030 */ FTransform InitialTransform;
    /* 0x0090 */ FTransform LocalTransform;
};

// Size: 0x10
struct FRigSpaceHierarchy {
    /* 0x0000 */ TArray<FRigSpace> Spaces;
};

// Size: 0x10
struct FRigTagConnectionRule : public FRigConnectionRule {
    /* 0x0008 */ FName Tag;
};

// Size: 0x30
struct FRigTransformArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FTransform> Value;
};

// Size: 0x10
struct FRigTransformDirtyState {
};

// Size: 0x118
struct FRigTransformElement : public FRigBaseElement {
};

// Size: 0x80
struct FRigTransformMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FTransform Value;
};

// Size: 0xf0
struct FRigTransformStackEntry {
    /* 0x0000 */ FRigElementKey Key;
    /* 0x000c */ uint8_t EntryType;
    /* 0x000d */ uint8_t TransformType;
    /* 0x0010 */ FTransform OldTransform;
    /* 0x0070 */ FTransform NewTransform;
    /* 0x00d0 */ bool bAffectChildren;
    /* 0x00d8 */ TArray<FString> Callstack;
};

// Size: 0x10
struct FRigTypeConnectionRule : public FRigConnectionRule {
    /* 0x0008 */ ERigElementType ElementType;
};

// Size: 0x8
struct FRigUnit : public FRigVMStruct {
};

// Size: 0x10
struct FRigUnitMutable : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x30
struct FRigUnit_AddAvailableSpaces : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Control;
    /* 0x0020 */ TArray<FRigElementKeyWithLabel> Spaces;
};

// Size: 0xb0
struct FRigUnit_AddBoneTransform : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ float Weight;
    /* 0x0084 */ bool bPostMultiply;
    /* 0x0085 */ bool bPropagateToChildren;
    /* 0x0088 */ FCachedRigElement CachedBone;
};

// Size: 0x30
struct FRigUnit_AddParent : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ FRigElementKey Parent;
    /* 0x0028 */ FName DisplayLabel;
};

// Size: 0x18
struct FRigUnit_Add_FloatFloat : public FRigUnit_BinaryFloatOp {
};

// Size: 0x50
struct FRigUnit_Add_VectorVector : public FRigUnit_BinaryVectorOp {
};

// Size: 0x190
struct FRigUnit_AimBone : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName bone;
    /* 0x0018 */ FRigUnit_AimBone_Target Primary;
    /* 0x0060 */ FRigUnit_AimBone_Target Secondary;
    /* 0x00a8 */ float Weight;
    /* 0x00ac */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_AimBone_DebugSettings DebugSettings;
    /* 0x0120 */ FCachedRigElement CachedBoneIndex;
    /* 0x0140 */ FCachedRigElement PrimaryCachedSpace;
    /* 0x0160 */ FCachedRigElement SecondaryCachedSpace;
    /* 0x0180 */ bool bIsInitialized;
};

// Size: 0x230
struct FRigUnit_AimBoneMath : public FRigUnit_HighlevelBase {
    /* 0x0010 */ FTransform InputTransform;
    /* 0x0070 */ FRigUnit_AimItem_Target Primary;
    /* 0x00b8 */ FRigUnit_AimItem_Target Secondary;
    /* 0x0100 */ float Weight;
    /* 0x0110 */ FTransform Result;
    /* 0x0170 */ FRigUnit_AimBone_DebugSettings DebugSettings;
    /* 0x01e0 */ FCachedRigElement PrimaryCachedSpace;
    /* 0x0200 */ FCachedRigElement SecondaryCachedSpace;
    /* 0x0220 */ bool bIsInitialized;
};

// Size: 0x70
struct FRigUnit_AimBone_DebugSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Scale;
    /* 0x0010 */ FTransform worldOffset;
};

// Size: 0x48
struct FRigUnit_AimBone_Target {
    /* 0x0000 */ float Weight;
    /* 0x0008 */ FVector Axis;
    /* 0x0020 */ FVector Target;
    /* 0x0038 */ EControlRigVectorKind Kind;
    /* 0x003c */ FName Space;
};

// Size: 0x80
struct FRigUnit_AimConstraint : public FRigUnitMutable {
    /* 0x0010 */ FName Joint;
    /* 0x0018 */ EAimMode AimMode;
    /* 0x0019 */ EAimMode UpMode;
    /* 0x0020 */ FVector AimVector;
    /* 0x0038 */ FVector UpVector;
    /* 0x0050 */ TArray<FAimTarget> AimTargets;
    /* 0x0060 */ TArray<FAimTarget> UpTargets;
    /* 0x0070 */ FRigUnit_AimConstraint_WorkData WorkData;
};

// Size: 0x170
struct FRigUnit_AimConstraintLocalSpaceOffset : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ FVector AimAxis;
    /* 0x0038 */ FVector UpAxis;
    /* 0x0050 */ FRigUnit_AimConstraint_WorldUp WorldUp;
    /* 0x0078 */ TArray<FConstraintParent> Parents;
    /* 0x0090 */ FRigUnit_AimConstraint_AdvancedSettings AdvancedSettings;
    /* 0x0110 */ float Weight;
    /* 0x0118 */ FCachedRigElement WorldUpSpaceCache;
    /* 0x0138 */ FCachedRigElement ChildCache;
    /* 0x0158 */ TArray<FCachedRigElement> ParentCaches;
    /* 0x0168 */ bool bIsInitialized;
};

// Size: 0x80
struct FRigUnit_AimConstraint_AdvancedSettings {
    /* 0x0000 */ FRigUnit_AimBone_DebugSettings DebugSettings;
    /* 0x0070 */ EEulerRotationOrder RotationOrderForFilter;
};

// Size: 0x10
struct FRigUnit_AimConstraint_WorkData {
    /* 0x0000 */ TArray<FConstraintData> ConstraintData;
};

// Size: 0x28
struct FRigUnit_AimConstraint_WorldUp {
    /* 0x0000 */ FVector Target;
    /* 0x0018 */ EControlRigVectorKind Kind;
    /* 0x001c */ FRigElementKey Space;
};

// Size: 0x1a0
struct FRigUnit_AimItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x0020 */ FRigUnit_AimItem_Target Primary;
    /* 0x0068 */ FRigUnit_AimItem_Target Secondary;
    /* 0x00b0 */ float Weight;
    /* 0x00c0 */ FRigUnit_AimBone_DebugSettings DebugSettings;
    /* 0x0130 */ FCachedRigElement CachedItem;
    /* 0x0150 */ FCachedRigElement PrimaryCachedSpace;
    /* 0x0170 */ FCachedRigElement SecondaryCachedSpace;
    /* 0x0190 */ bool bIsInitialized;
};

// Size: 0x48
struct FRigUnit_AimItem_Target {
    /* 0x0000 */ float Weight;
    /* 0x0008 */ FVector Axis;
    /* 0x0020 */ FVector Target;
    /* 0x0038 */ EControlRigVectorKind Kind;
    /* 0x003c */ FRigElementKey Space;
};

// Size: 0x100
struct FRigUnit_ApplyFK : public FRigUnitMutable {
    /* 0x0010 */ FName Joint;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FTransformFilter Filter;
    /* 0x0089 */ EApplyTransformMode ApplyTransformMode;
    /* 0x008a */ ETransformSpaceMode ApplyTransformSpace;
    /* 0x0090 */ FTransform BaseTransform;
    /* 0x00f0 */ FName BaseJoint;
};

// Size: 0x10
struct FRigUnit_BeginExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x18
struct FRigUnit_BinaryFloatOp : public FRigUnit {
    /* 0x0008 */ float Argument0;
    /* 0x000c */ float Argument1;
    /* 0x0010 */ float Result;
};

// Size: 0x70
struct FRigUnit_BinaryQuaternionOp : public FRigUnit {
    /* 0x0010 */ FQuat Argument0;
    /* 0x0030 */ FQuat Argument1;
    /* 0x0050 */ FQuat Result;
};

// Size: 0x130
struct FRigUnit_BinaryTransformOp : public FRigUnit {
    /* 0x0010 */ FTransform Argument0;
    /* 0x0070 */ FTransform Argument1;
    /* 0x00d0 */ FTransform Result;
};

// Size: 0x50
struct FRigUnit_BinaryVectorOp : public FRigUnit {
    /* 0x0008 */ FVector Argument0;
    /* 0x0020 */ FVector Argument1;
    /* 0x0038 */ FVector Result;
};

// Size: 0xe0
struct FRigUnit_BlendTransform : public FRigUnit {
    /* 0x0010 */ FTransform Source;
    /* 0x0070 */ TArray<FBlendTarget> Targets;
    /* 0x0080 */ FTransform Result;
};

// Size: 0xd0
struct FRigUnit_BoneHarmonics : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigUnit_BoneHarmonics_BoneTarget> Bones;
    /* 0x0020 */ FVector WaveSpeed;
    /* 0x0038 */ FVector WaveFrequency;
    /* 0x0050 */ FVector WaveAmplitude;
    /* 0x0068 */ FVector WaveOffset;
    /* 0x0080 */ FVector WaveNoise;
    /* 0x0098 */ ERigVMAnimEasingType WaveEase;
    /* 0x009c */ float WaveMinimum;
    /* 0x00a0 */ float WaveMaximum;
    /* 0x00a4 */ EEulerRotationOrder RotationOrder;
    /* 0x00a5 */ bool bPropagateToChildren;
    /* 0x00a8 */ FRigUnit_BoneHarmonics_WorkData WorkData;
};

// Size: 0xc
struct FRigUnit_BoneHarmonics_BoneTarget {
    /* 0x0000 */ FName bone;
    /* 0x0008 */ float Ratio;
};

// Size: 0x28
struct FRigUnit_BoneHarmonics_WorkData {
    /* 0x0000 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0010 */ FVector WaveTime;
};

// Size: 0x10
struct FRigUnit_BoneName : public FRigUnit {
    /* 0x0008 */ FName bone;
};

// Size: 0x110
struct FRigUnit_CCDIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EffectorBone;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ int32_t MaxIterations;
    /* 0x008c */ bool bStartFromTail;
    /* 0x0090 */ float BaseRotationLimit;
    /* 0x0098 */ TArray<FRigUnit_CCDIK_RotationLimit> RotationLimits;
    /* 0x00a8 */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_CCDIK_WorkData WorkData;
};

// Size: 0x110
struct FRigUnit_CCDIKItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ int32_t MaxIterations;
    /* 0x008c */ bool bStartFromTail;
    /* 0x0090 */ float BaseRotationLimit;
    /* 0x0098 */ TArray<FRigUnit_CCDIK_RotationLimitPerItem> RotationLimits;
    /* 0x00a8 */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_CCDIK_WorkData WorkData;
};

// Size: 0x110
struct FRigUnit_CCDIKPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ int32_t MaxIterations;
    /* 0x008c */ bool bStartFromTail;
    /* 0x0090 */ float BaseRotationLimit;
    /* 0x0098 */ TArray<FRigUnit_CCDIK_RotationLimitPerItem> RotationLimits;
    /* 0x00a8 */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_CCDIK_WorkData WorkData;
};

// Size: 0xc
struct FRigUnit_CCDIK_RotationLimit {
    /* 0x0000 */ FName bone;
    /* 0x0008 */ float Limit;
};

// Size: 0x10
struct FRigUnit_CCDIK_RotationLimitPerItem {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x000c */ float Limit;
};

// Size: 0x60
struct FRigUnit_CCDIK_WorkData {
    /* 0x0000 */ TArray<FCCDIKChainLink> Chain;
    /* 0x0010 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0020 */ TArray<int32_t> RotationLimitIndex;
    /* 0x0030 */ TArray<float> RotationLimitsPerItem;
    /* 0x0040 */ FCachedRigElement CachedEffector;
};

// Size: 0x2e0
struct FRigUnit_ChainHarmonics : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName ChainRoot;
    /* 0x0018 */ FVector Speed;
    /* 0x0030 */ FRigUnit_ChainHarmonics_Reach Reach;
    /* 0x0078 */ FRigUnit_ChainHarmonics_Wave Wave;
    /* 0x00f0 */ FRuntimeFloatCurve WaveCurve;
    /* 0x0178 */ FRigUnit_ChainHarmonics_Pendulum Pendulum;
    /* 0x01d0 */ bool bDrawDebug;
    /* 0x01e0 */ FTransform DrawWorldOffset;
    /* 0x0240 */ FRigUnit_ChainHarmonics_WorkData WorkData;
};

// Size: 0x2e0
struct FRigUnit_ChainHarmonicsPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey ChainRoot;
    /* 0x0020 */ FVector Speed;
    /* 0x0038 */ FRigUnit_ChainHarmonics_Reach Reach;
    /* 0x0080 */ FRigUnit_ChainHarmonics_Wave Wave;
    /* 0x00f8 */ FRuntimeFloatCurve WaveCurve;
    /* 0x0180 */ FRigUnit_ChainHarmonics_Pendulum Pendulum;
    /* 0x01d8 */ bool bDrawDebug;
    /* 0x01e0 */ FTransform DrawWorldOffset;
    /* 0x0240 */ FRigUnit_ChainHarmonics_WorkData WorkData;
};

// Size: 0x58
struct FRigUnit_ChainHarmonics_Pendulum {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float PendulumStiffness;
    /* 0x0008 */ FVector PendulumGravity;
    /* 0x0020 */ float PendulumBlend;
    /* 0x0024 */ float PendulumDrag;
    /* 0x0028 */ float PendulumMinimum;
    /* 0x002c */ float PendulumMaximum;
    /* 0x0030 */ ERigVMAnimEasingType PendulumEase;
    /* 0x0038 */ FVector UnwindAxis;
    /* 0x0050 */ float UnwindMinimum;
    /* 0x0054 */ float UnwindMaximum;
};

// Size: 0x48
struct FRigUnit_ChainHarmonics_Reach {
    /* 0x0000 */ bool bEnabled;
    /* 0x0008 */ FVector ReachTarget;
    /* 0x0020 */ FVector ReachAxis;
    /* 0x0038 */ float ReachMinimum;
    /* 0x003c */ float ReachMaximum;
    /* 0x0040 */ ERigVMAnimEasingType ReachEase;
};

// Size: 0x78
struct FRigUnit_ChainHarmonics_Wave {
    /* 0x0000 */ bool bEnabled;
    /* 0x0008 */ FVector WaveFrequency;
    /* 0x0020 */ FVector WaveAmplitude;
    /* 0x0038 */ FVector WaveOffset;
    /* 0x0050 */ FVector WaveNoise;
    /* 0x0068 */ float WaveMinimum;
    /* 0x006c */ float WaveMaximum;
    /* 0x0070 */ ERigVMAnimEasingType WaveEase;
};

// Size: 0x98
struct FRigUnit_ChainHarmonics_WorkData {
    /* 0x0000 */ FVector Time;
    /* 0x0018 */ TArray<FCachedRigElement> Items;
    /* 0x0028 */ TArray<float> Ratio;
    /* 0x0038 */ TArray<FVector> LocalTip;
    /* 0x0048 */ TArray<FVector> PendulumTip;
    /* 0x0058 */ TArray<FVector> PendulumPosition;
    /* 0x0068 */ TArray<FVector> PendulumVelocity;
    /* 0x0078 */ TArray<FVector> HierarchyLine;
    /* 0x0088 */ TArray<FVector> VelocityLines;
};

// Size: 0xe0
struct FRigUnit_ChainInfo : public FRigUnit_HighlevelBase {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ float Param;
    /* 0x001c */ bool bCalculateStretch;
    /* 0x001d */ bool bInitial;
    /* 0x001e */ bool bDebug;
    /* 0x0020 */ float DebugScale;
    /* 0x0030 */ FTransform InterpolatedTransform;
    /* 0x0090 */ float ChainLength;
    /* 0x0094 */ float ParamLength;
    /* 0x0098 */ float ChainStretchFactor;
    /* 0x009c */ FRigUnit_ChainInfo_SegmentInfo SegmentInfo;
    /* 0x00d0 */ TArray<FCachedRigElement> CachedElements;
};

// Size: 0x60
struct FRigUnit_ChainInfo_Segment {
    /* 0x0000 */ FCachedRigElement StartItem;
    /* 0x0020 */ int32_t StartItemIndex;
    /* 0x0028 */ FCachedRigElement EndItem;
    /* 0x0048 */ int32_t EndItemIndex;
    /* 0x004c */ float InitialLength;
    /* 0x0050 */ float InitialCumLength;
    /* 0x0054 */ float Length;
    /* 0x0058 */ float CumLength;
};

// Size: 0x34
struct FRigUnit_ChainInfo_SegmentInfo {
    /* 0x0000 */ int32_t SegmentIndex;
    /* 0x0004 */ float SegmentLength;
    /* 0x0008 */ float SegmentParam;
    /* 0x000c */ float SegmentParamLength;
    /* 0x0010 */ FRigElementKey SegmentStartItem;
    /* 0x001c */ int32_t SegmentStartItemIndex;
    /* 0x0020 */ FRigElementKey SegmentEndItem;
    /* 0x002c */ int32_t SegmentEndItemIndex;
    /* 0x0030 */ float SegmentStretchFactor;
};

// Size: 0x18
struct FRigUnit_Clamp_Float : public FRigUnit {
    /* 0x0008 */ float Value;
    /* 0x000c */ float min;
    /* 0x0010 */ float max;
    /* 0x0014 */ float Result;
};

// Size: 0x38
struct FRigUnit_CollectionAddItem : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ FRigElementKey Item;
    /* 0x0028 */ FRigElementKeyCollection Result;
};

// Size: 0x8
struct FRigUnit_CollectionBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_CollectionBaseMutable : public FRigUnitMutable {
};

// Size: 0x38
struct FRigUnit_CollectionChain : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKey FirstItem;
    /* 0x0014 */ FRigElementKey LastItem;
    /* 0x0020 */ bool Reverse;
    /* 0x0028 */ FRigElementKeyCollection Collection;
};

// Size: 0x38
struct FRigUnit_CollectionChainArray : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKey FirstItem;
    /* 0x0014 */ FRigElementKey LastItem;
    /* 0x0020 */ bool Reverse;
    /* 0x0028 */ TArray<FRigElementKey> Items;
};

// Size: 0x28
struct FRigUnit_CollectionChildren : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKey Parent;
    /* 0x0014 */ bool bIncludeParent;
    /* 0x0015 */ bool bRecursive;
    /* 0x0016 */ ERigElementType TypeToSearch;
    /* 0x0018 */ FRigElementKeyCollection Collection;
};

// Size: 0x28
struct FRigUnit_CollectionChildrenArray : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKey Parent;
    /* 0x0014 */ bool bIncludeParent;
    /* 0x0015 */ bool bRecursive;
    /* 0x0016 */ bool bDefaultChildren;
    /* 0x0017 */ ERigElementType TypeToSearch;
    /* 0x0018 */ TArray<FRigElementKey> Items;
};

// Size: 0x20
struct FRigUnit_CollectionCount : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ int32_t Count;
};

// Size: 0x38
struct FRigUnit_CollectionDifference : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection A;
    /* 0x0018 */ FRigElementKeyCollection B;
    /* 0x0028 */ FRigElementKeyCollection Collection;
};

// Size: 0x20
struct FRigUnit_CollectionGetAll : public FRigUnit_CollectionBase {
    /* 0x0008 */ ERigElementType TypeToSearch;
    /* 0x0010 */ TArray<FRigElementKey> Items;
};

// Size: 0x28
struct FRigUnit_CollectionGetItems : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ TArray<FRigElementKey> Items;
};

// Size: 0x28
struct FRigUnit_CollectionGetParentIndices : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ TArray<int32_t> ParentIndices;
};

// Size: 0x28
struct FRigUnit_CollectionGetParentIndicesItemArray : public FRigUnit_CollectionBase {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ TArray<int32_t> ParentIndices;
};

// Size: 0x38
struct FRigUnit_CollectionIntersection : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection A;
    /* 0x0018 */ FRigElementKeyCollection B;
    /* 0x0028 */ FRigElementKeyCollection Collection;
};

// Size: 0x28
struct FRigUnit_CollectionItemAtIndex : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ int32_t Index;
    /* 0x001c */ FRigElementKey Item;
};

// Size: 0x30
struct FRigUnit_CollectionItems : public FRigUnit_CollectionBase {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ bool bAllowDuplicates;
    /* 0x0020 */ FRigElementKeyCollection Collection;
};

// Size: 0x250
struct FRigUnit_CollectionLoop : public FRigUnit_CollectionBaseMutable {
    /* 0x0010 */ FName BlockToRun;
    /* 0x0018 */ FRigElementKeyCollection Collection;
    /* 0x0028 */ FRigElementKey Item;
    /* 0x0034 */ int32_t Index;
    /* 0x0038 */ int32_t Count;
    /* 0x003c */ float Ratio;
    /* 0x0040 */ FControlRigExecuteContext completed;
};

// Size: 0x28
struct FRigUnit_CollectionNameSearch : public FRigUnit_CollectionBase {
    /* 0x0008 */ FName PartialName;
    /* 0x0010 */ ERigElementType TypeToSearch;
    /* 0x0018 */ FRigElementKeyCollection Collection;
};

// Size: 0x28
struct FRigUnit_CollectionNameSearchArray : public FRigUnit_CollectionBase {
    /* 0x0008 */ FName PartialName;
    /* 0x0010 */ ERigElementType TypeToSearch;
    /* 0x0018 */ TArray<FRigElementKey> Items;
};

// Size: 0x40
struct FRigUnit_CollectionReplaceItems : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Items;
    /* 0x0018 */ FName Old;
    /* 0x0020 */ FName New;
    /* 0x0028 */ bool RemoveInvalidItems;
    /* 0x0029 */ bool bAllowDuplicates;
    /* 0x0030 */ FRigElementKeyCollection Collection;
};

// Size: 0x40
struct FRigUnit_CollectionReplaceItemsArray : public FRigUnit_CollectionBase {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ FName Old;
    /* 0x0020 */ FName New;
    /* 0x0028 */ bool RemoveInvalidItems;
    /* 0x0029 */ bool bAllowDuplicates;
    /* 0x0030 */ TArray<FRigElementKey> Result;
};

// Size: 0x28
struct FRigUnit_CollectionReverse : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection Collection;
    /* 0x0018 */ FRigElementKeyCollection Reversed;
};

// Size: 0x40
struct FRigUnit_CollectionUnion : public FRigUnit_CollectionBase {
    /* 0x0008 */ FRigElementKeyCollection A;
    /* 0x0018 */ FRigElementKeyCollection B;
    /* 0x0028 */ bool bAllowDuplicates;
    /* 0x0030 */ FRigElementKeyCollection Collection;
};

// Size: 0x220
struct FRigUnit_ConnectorExecution : public FRigUnit {
    /* 0x0010 */ FControlRigExecuteContext ExecuteContext;
};

// Size: 0x180
struct FRigUnit_Control : public FRigUnit {
    /* 0x0008 */ FEulerTransform Transform;
    /* 0x0050 */ FTransform base;
    /* 0x00b0 */ FTransform InitTransform;
    /* 0x0110 */ FTransform Result;
    /* 0x0170 */ FTransformFilter Filter;
    /* 0x0179 */ bool bIsInitialized;
};

// Size: 0x10
struct FRigUnit_ControlName : public FRigUnit {
    /* 0x0008 */ FName Control;
};

// Size: 0x1e0
struct FRigUnit_Control_StaticMesh : public FRigUnit_Control {
    /* 0x0180 */ FTransform MeshTransform;
};

// Size: 0xb0
struct FRigUnit_ConvertEulerTransform : public FRigUnit {
    /* 0x0008 */ FEulerTransform Input;
    /* 0x0050 */ FTransform Result;
};

// Size: 0x50
struct FRigUnit_ConvertQuaternion : public FRigUnit {
    /* 0x0010 */ FQuat Input;
    /* 0x0030 */ FRotator Result;
};

// Size: 0x50
struct FRigUnit_ConvertQuaternionToVector : public FRigUnit {
    /* 0x0010 */ FQuat Input;
    /* 0x0030 */ FVector Result;
};

// Size: 0x40
struct FRigUnit_ConvertRotation : public FRigUnit {
    /* 0x0008 */ FRotator Input;
    /* 0x0020 */ FQuat Result;
};

// Size: 0x38
struct FRigUnit_ConvertRotationToVector : public FRigUnit {
    /* 0x0008 */ FRotator Input;
    /* 0x0020 */ FVector Result;
};

// Size: 0xc0
struct FRigUnit_ConvertTransform : public FRigUnit {
    /* 0x0010 */ FTransform Input;
    /* 0x0070 */ FEulerTransform Result;
};

// Size: 0x40
struct FRigUnit_ConvertVectorRotation : public FRigUnit_ConvertRotation {
};

// Size: 0x40
struct FRigUnit_ConvertVectorToQuaternion : public FRigUnit {
    /* 0x0008 */ FVector Input;
    /* 0x0020 */ FQuat Result;
};

// Size: 0x38
struct FRigUnit_ConvertVectorToRotation : public FRigUnit {
    /* 0x0008 */ FVector Input;
    /* 0x0020 */ FRotator Result;
};

// Size: 0x38
struct FRigUnit_CurveExists : public FRigUnit {
    /* 0x0008 */ FName Curve;
    /* 0x0010 */ bool Exists;
    /* 0x0018 */ FCachedRigElement CachedCurveIndex;
};

// Size: 0x120
struct FRigUnit_DebugArc : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Radius;
    /* 0x0094 */ float MinimumDegrees;
    /* 0x0098 */ float MaximumDegrees;
    /* 0x009c */ float Thickness;
    /* 0x00a0 */ int32_t Detail;
    /* 0x00a4 */ FName Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x120
struct FRigUnit_DebugArcItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Radius;
    /* 0x0094 */ float MinimumDegrees;
    /* 0x0098 */ float MaximumDegrees;
    /* 0x009c */ float Thickness;
    /* 0x00a0 */ int32_t Detail;
    /* 0x00a4 */ FRigElementKey Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x10
struct FRigUnit_DebugBase : public FRigUnit {
    /* 0x0008 */ FRigVMDebugDrawSettings DebugDrawSettings;
};

// Size: 0x18
struct FRigUnit_DebugBaseMutable : public FRigUnitMutable {
    /* 0x0010 */ FRigVMDebugDrawSettings DebugDrawSettings;
};

// Size: 0x110
struct FRigUnit_DebugBezier : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FRigVMFourPointBezier Bezier;
    /* 0x0078 */ float MinimumU;
    /* 0x007c */ float MaximumU;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Thickness;
    /* 0x0094 */ int32_t Detail;
    /* 0x0098 */ FName Space;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0x120
struct FRigUnit_DebugBezierItemSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FRigVMFourPointBezier Bezier;
    /* 0x0078 */ float MinimumU;
    /* 0x007c */ float MaximumU;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Thickness;
    /* 0x0094 */ int32_t Detail;
    /* 0x0098 */ FRigElementKey Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0xb0
struct FRigUnit_DebugHierarchy : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FRigVMExecutePin ExecutePin;
    /* 0x0018 */ TArray<FRigElementKey> Items;
    /* 0x0028 */ float Scale;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ FTransform worldOffset;
    /* 0x00a0 */ bool bEnabled;
};

// Size: 0xe0
struct FRigUnit_DebugLine : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ FVector A;
    /* 0x0030 */ FVector B;
    /* 0x0048 */ FLinearColor Color;
    /* 0x0058 */ float Thickness;
    /* 0x005c */ FName Space;
    /* 0x0070 */ FTransform worldOffset;
    /* 0x00d0 */ bool bEnabled;
};

// Size: 0xe0
struct FRigUnit_DebugLineItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ FVector A;
    /* 0x0030 */ FVector B;
    /* 0x0048 */ FLinearColor Color;
    /* 0x0058 */ float Thickness;
    /* 0x005c */ FRigElementKey Space;
    /* 0x0070 */ FTransform worldOffset;
    /* 0x00d0 */ bool bEnabled;
};

// Size: 0xc0
struct FRigUnit_DebugLineStrip : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ TArray<FVector> points;
    /* 0x0028 */ FLinearColor Color;
    /* 0x0038 */ float Thickness;
    /* 0x003c */ FName Space;
    /* 0x0050 */ FTransform worldOffset;
    /* 0x00b0 */ bool bEnabled;
};

// Size: 0xc0
struct FRigUnit_DebugLineStripItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ TArray<FVector> points;
    /* 0x0028 */ FLinearColor Color;
    /* 0x0038 */ float Thickness;
    /* 0x003c */ FRigElementKey Space;
    /* 0x0050 */ FTransform worldOffset;
    /* 0x00b0 */ bool bEnabled;
};

// Size: 0x120
struct FRigUnit_DebugPose : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FRigVMExecutePin ExecutePin;
    /* 0x0018 */ FRigPose Pose;
    /* 0x0088 */ TArray<FRigElementKey> Items;
    /* 0x0098 */ float Scale;
    /* 0x009c */ FLinearColor Color;
    /* 0x00ac */ float Thickness;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x110
struct FRigUnit_DebugRectangle : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Scale;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ FName Space;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0x120
struct FRigUnit_DebugRectangleItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Scale;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ FRigElementKey Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x110
struct FRigUnit_DebugTransform : public FRigUnit_DebugBase {
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ ERigUnitDebugTransformMode Mode;
    /* 0x0074 */ FLinearColor Color;
    /* 0x0084 */ float Thickness;
    /* 0x0088 */ float Scale;
    /* 0x008c */ FName Space;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0xd0
struct FRigUnit_DebugTransformArrayMutable : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ TArray<FTransform> Transforms;
    /* 0x0028 */ ERigUnitDebugTransformMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ float Scale;
    /* 0x0044 */ FName Space;
    /* 0x0050 */ FTransform worldOffset;
    /* 0x00b0 */ bool bEnabled;
    /* 0x00b8 */ FRigUnit_DebugTransformArrayMutable_WorkData WorkData;
};

// Size: 0xd0
struct FRigUnit_DebugTransformArrayMutableItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0018 */ TArray<FTransform> Transforms;
    /* 0x0028 */ TArray<int32_t> ParentIndices;
    /* 0x0038 */ ERigUnitDebugTransformMode Mode;
    /* 0x003c */ FLinearColor Color;
    /* 0x004c */ float Thickness;
    /* 0x0050 */ float Scale;
    /* 0x0054 */ FRigElementKey Space;
    /* 0x0060 */ FTransform worldOffset;
    /* 0x00c0 */ bool bEnabled;
};

// Size: 0x10
struct FRigUnit_DebugTransformArrayMutable_WorkData {
    /* 0x0000 */ TArray<FTransform> DrawTransforms;
};

// Size: 0x120
struct FRigUnit_DebugTransformMutable : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ ERigUnitDebugTransformMode Mode;
    /* 0x0084 */ FLinearColor Color;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ float Scale;
    /* 0x009c */ FName Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x120
struct FRigUnit_DebugTransformMutableItemSpace : public FRigUnit_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ ERigUnitDebugTransformMode Mode;
    /* 0x0084 */ FLinearColor Color;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ float Scale;
    /* 0x009c */ FRigElementKey Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x30
struct FRigUnit_DiscardMatches : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigElementKey> Excluded;
    /* 0x0020 */ FString Message;
};

// Size: 0x40
struct FRigUnit_Distance_VectorVector : public FRigUnit {
    /* 0x0008 */ FVector Argument0;
    /* 0x0020 */ FVector Argument1;
    /* 0x0038 */ float Result;
};

// Size: 0x90
struct FRigUnit_DistributeRotation : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EndBone;
    /* 0x0020 */ TArray<FRigUnit_DistributeRotation_Rotation> Rotations;
    /* 0x0030 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x0034 */ float Weight;
    /* 0x0038 */ bool bPropagateToChildren;
    /* 0x0040 */ FRigUnit_DistributeRotation_WorkData WorkData;
};

// Size: 0x88
struct FRigUnit_DistributeRotationForCollection : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ TArray<FRigUnit_DistributeRotation_Rotation> Rotations;
    /* 0x0030 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x0034 */ float Weight;
    /* 0x0038 */ FRigUnit_DistributeRotation_WorkData WorkData;
};

// Size: 0x88
struct FRigUnit_DistributeRotationForItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ TArray<FRigUnit_DistributeRotation_Rotation> Rotations;
    /* 0x0030 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x0034 */ float Weight;
    /* 0x0038 */ FRigUnit_DistributeRotation_WorkData WorkData;
};

// Size: 0x30
struct FRigUnit_DistributeRotation_Rotation {
    /* 0x0000 */ FQuat Rotation;
    /* 0x0020 */ float Ratio;
};

// Size: 0x50
struct FRigUnit_DistributeRotation_WorkData {
    /* 0x0000 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0010 */ TArray<int32_t> ItemRotationA;
    /* 0x0020 */ TArray<int32_t> ItemRotationB;
    /* 0x0030 */ TArray<float> ItemRotationT;
    /* 0x0040 */ TArray<FTransform> ItemLocalTransforms;
};

// Size: 0x18
struct FRigUnit_Divide_FloatFloat : public FRigUnit_BinaryFloatOp {
};

// Size: 0x50
struct FRigUnit_Divide_VectorVector : public FRigUnit_BinaryVectorOp {
};

// Size: 0x80
struct FRigUnit_DrawContainerGetInstruction : public FRigUnit {
    /* 0x0008 */ FName InstructionName;
    /* 0x0010 */ FLinearColor Color;
    /* 0x0020 */ FTransform Transform;
};

// Size: 0x28
struct FRigUnit_DrawContainerSetColor : public FRigUnitMutable {
    /* 0x0010 */ FName InstructionName;
    /* 0x0018 */ FLinearColor Color;
};

// Size: 0x20
struct FRigUnit_DrawContainerSetThickness : public FRigUnitMutable {
    /* 0x0010 */ FName InstructionName;
    /* 0x0018 */ float Thickness;
};

// Size: 0x80
struct FRigUnit_DrawContainerSetTransform : public FRigUnitMutable {
    /* 0x0010 */ FName InstructionName;
    /* 0x0020 */ FTransform Transform;
};

// Size: 0x8
struct FRigUnit_DynamicHierarchyBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_DynamicHierarchyBaseMutable : public FRigUnitMutable {
};

// Size: 0x40
struct FRigUnit_EndProfilingTimer : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ int32_t NumberOfMeasurements;
    /* 0x0020 */ FString Prefix;
    /* 0x0030 */ float AccumulatedTime;
    /* 0x0034 */ int32_t MeasurementsLeft;
    /* 0x0038 */ bool bIsInitialized;
};

// Size: 0xe0
struct FRigUnit_FABRIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EffectorBone;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ bool bPropagateToChildren;
    /* 0x008c */ int32_t MaxIterations;
    /* 0x0090 */ FRigUnit_FABRIK_WorkData WorkData;
    /* 0x00d0 */ bool bSetEffectorTransform;
};

// Size: 0xe0
struct FRigUnit_FABRIKItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ bool bPropagateToChildren;
    /* 0x008c */ int32_t MaxIterations;
    /* 0x0090 */ FRigUnit_FABRIK_WorkData WorkData;
    /* 0x00d0 */ bool bSetEffectorTransform;
};

// Size: 0xe0
struct FRigUnit_FABRIKPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FTransform EffectorTransform;
    /* 0x0080 */ float Precision;
    /* 0x0084 */ float Weight;
    /* 0x0088 */ bool bPropagateToChildren;
    /* 0x008c */ int32_t MaxIterations;
    /* 0x0090 */ FRigUnit_FABRIK_WorkData WorkData;
    /* 0x00d0 */ bool bSetEffectorTransform;
};

// Size: 0x40
struct FRigUnit_FABRIK_WorkData {
    /* 0x0000 */ TArray<FFABRIKChainLink> Chain;
    /* 0x0010 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0020 */ FCachedRigElement CachedEffector;
};

// Size: 0x50
struct FRigUnit_FilterItemsByMetadataTags : public FRigUnit {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ TArray<FName> Tags;
    /* 0x0028 */ ERigMetaDataNameSpace Namespace;
    /* 0x0029 */ bool Inclusive;
    /* 0x0030 */ TArray<FRigElementKey> Result;
    /* 0x0040 */ TArray<FCachedRigElement> CachedIndices;
};

// Size: 0x58
struct FRigUnit_FindClosestItem : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FVector Point;
    /* 0x0038 */ FRigElementKey Item;
    /* 0x0048 */ TArray<FCachedRigElement> CachedItems;
};

// Size: 0x28
struct FRigUnit_FindItemsWithMetadata : public FRigUnit {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ ERigMetadataType Type;
    /* 0x0011 */ ERigMetaDataNameSpace Namespace;
    /* 0x0018 */ TArray<FRigElementKey> Items;
};

// Size: 0x28
struct FRigUnit_FindItemsWithMetadataTag : public FRigUnit {
    /* 0x0008 */ FName Tag;
    /* 0x0010 */ ERigMetaDataNameSpace Namespace;
    /* 0x0018 */ TArray<FRigElementKey> Items;
};

// Size: 0x30
struct FRigUnit_FindItemsWithMetadataTagArray : public FRigUnit {
    /* 0x0008 */ TArray<FName> Tags;
    /* 0x0018 */ ERigMetaDataNameSpace Namespace;
    /* 0x0020 */ TArray<FRigElementKey> Items;
};

// Size: 0x230
struct FRigUnit_FitChainToCurve : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EndBone;
    /* 0x0020 */ FRigVMFourPointBezier Bezier;
    /* 0x0080 */ EControlRigCurveAlignment Alignment;
    /* 0x0084 */ float Minimum;
    /* 0x0088 */ float Maximum;
    /* 0x008c */ int32_t SamplingPrecision;
    /* 0x0090 */ FVector PrimaryAxis;
    /* 0x00a8 */ FVector SecondaryAxis;
    /* 0x00c0 */ FVector PoleVectorPosition;
    /* 0x00d8 */ TArray<FRigUnit_FitChainToCurve_Rotation> Rotations;
    /* 0x00e8 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x00ec */ float Weight;
    /* 0x00f0 */ bool bPropagateToChildren;
    /* 0x0100 */ FRigUnit_FitChainToCurve_DebugSettings DebugSettings;
    /* 0x0190 */ FRigUnit_FitChainToCurve_WorkData WorkData;
};

// Size: 0x230
struct FRigUnit_FitChainToCurveItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FRigVMFourPointBezier Bezier;
    /* 0x0080 */ EControlRigCurveAlignment Alignment;
    /* 0x0084 */ float Minimum;
    /* 0x0088 */ float Maximum;
    /* 0x008c */ int32_t SamplingPrecision;
    /* 0x0090 */ FVector PrimaryAxis;
    /* 0x00a8 */ FVector SecondaryAxis;
    /* 0x00c0 */ FVector PoleVectorPosition;
    /* 0x00d8 */ TArray<FRigUnit_FitChainToCurve_Rotation> Rotations;
    /* 0x00e8 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x00ec */ float Weight;
    /* 0x00f0 */ bool bPropagateToChildren;
    /* 0x0100 */ FRigUnit_FitChainToCurve_DebugSettings DebugSettings;
    /* 0x0190 */ FRigUnit_FitChainToCurve_WorkData WorkData;
};

// Size: 0x230
struct FRigUnit_FitChainToCurvePerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FRigVMFourPointBezier Bezier;
    /* 0x0080 */ EControlRigCurveAlignment Alignment;
    /* 0x0084 */ float Minimum;
    /* 0x0088 */ float Maximum;
    /* 0x008c */ int32_t SamplingPrecision;
    /* 0x0090 */ FVector PrimaryAxis;
    /* 0x00a8 */ FVector SecondaryAxis;
    /* 0x00c0 */ FVector PoleVectorPosition;
    /* 0x00d8 */ TArray<FRigUnit_FitChainToCurve_Rotation> Rotations;
    /* 0x00e8 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x00ec */ float Weight;
    /* 0x00f0 */ bool bPropagateToChildren;
    /* 0x0100 */ FRigUnit_FitChainToCurve_DebugSettings DebugSettings;
    /* 0x0190 */ FRigUnit_FitChainToCurve_WorkData WorkData;
};

// Size: 0x90
struct FRigUnit_FitChainToCurve_DebugSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Scale;
    /* 0x0008 */ FLinearColor CurveColor;
    /* 0x0018 */ FLinearColor SegmentsColor;
    /* 0x0030 */ FTransform worldOffset;
};

// Size: 0x30
struct FRigUnit_FitChainToCurve_Rotation {
    /* 0x0000 */ FQuat Rotation;
    /* 0x0020 */ float Ratio;
};

// Size: 0x98
struct FRigUnit_FitChainToCurve_WorkData {
    /* 0x0000 */ float ChainLength;
    /* 0x0008 */ TArray<FVector> ItemPositions;
    /* 0x0018 */ TArray<float> ItemSegments;
    /* 0x0028 */ TArray<FVector> CurvePositions;
    /* 0x0038 */ TArray<float> CurveSegments;
    /* 0x0048 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0058 */ TArray<int32_t> ItemRotationA;
    /* 0x0068 */ TArray<int32_t> ItemRotationB;
    /* 0x0078 */ TArray<float> ItemRotationT;
    /* 0x0088 */ TArray<FTransform> ItemLocalTransforms;
};

// Size: 0x30
struct FRigUnit_GetAnimationChannelBase : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ FName Channel;
    /* 0x0018 */ bool bInitial;
    /* 0x001c */ FRigElementKey CachedChannelKey;
    /* 0x0028 */ int32_t CachedChannelHash;
};

// Size: 0x18
struct FRigUnit_GetAnimationChannelFromItemBase : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool bInitial;
};

// Size: 0xb0
struct FRigUnit_GetBoneTransform : public FRigUnit {
    /* 0x0008 */ FName bone;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedBone;
    /* 0x00a0 */ bool bFirstUpdate;
};

// Size: 0x38
struct FRigUnit_GetBoolAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ bool Value;
};

// Size: 0x20
struct FRigUnit_GetBoolAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ bool Value;
};

// Size: 0x28
struct FRigUnit_GetCandidates : public FRigUnit {
    /* 0x0008 */ FRigElementKey Connector;
    /* 0x0018 */ TArray<FRigElementKey> Candidates;
};

// Size: 0x38
struct FRigUnit_GetControlBool : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ bool boolValue;
    /* 0x0018 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_GetControlColor : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ FLinearColor Color;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_GetControlDrivenList : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ TArray<FRigElementKey> Driven;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_GetControlFloat : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ float FloatValue;
    /* 0x0014 */ float Minimum;
    /* 0x0018 */ float Maximum;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0xa0
struct FRigUnit_GetControlInitialTransform : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_GetControlInteger : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ int32_t IntegerValue;
    /* 0x0014 */ int32_t Minimum;
    /* 0x0018 */ int32_t Maximum;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0xa0
struct FRigUnit_GetControlOffset : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0020 */ FTransform OffsetTransform;
    /* 0x0080 */ FCachedRigElement CachedIndex;
};

// Size: 0x80
struct FRigUnit_GetControlRotator : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0018 */ FRotator Rotator;
    /* 0x0030 */ FRotator Minimum;
    /* 0x0048 */ FRotator Maximum;
    /* 0x0060 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x160
struct FRigUnit_GetControlTransform : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FTransform Minimum;
    /* 0x00e0 */ FTransform Maximum;
    /* 0x0140 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x80
struct FRigUnit_GetControlVector : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0018 */ FVector Vector;
    /* 0x0030 */ FVector Minimum;
    /* 0x0048 */ FVector Maximum;
    /* 0x0060 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x60
struct FRigUnit_GetControlVector2D : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ FVector2D Vector;
    /* 0x0020 */ FVector2D Minimum;
    /* 0x0030 */ FVector2D Maximum;
    /* 0x0040 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x38
struct FRigUnit_GetControlVisibility : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool bVisible;
    /* 0x0018 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x18
struct FRigUnit_GetCurrentNameSpace : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FString Namespace;
};

// Size: 0x38
struct FRigUnit_GetCurveValue : public FRigUnit {
    /* 0x0008 */ FName Curve;
    /* 0x0010 */ bool Valid;
    /* 0x0014 */ float Value;
    /* 0x0018 */ FCachedRigElement CachedCurveIndex;
};

// Size: 0x38
struct FRigUnit_GetFloatAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ float Value;
};

// Size: 0x20
struct FRigUnit_GetFloatAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ float Value;
};

// Size: 0xa0
struct FRigUnit_GetInitialBoneTransform : public FRigUnit {
    /* 0x0008 */ FName bone;
    /* 0x0010 */ ERigVMTransformSpace Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedBone;
};

// Size: 0x38
struct FRigUnit_GetIntAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ int32_t Value;
};

// Size: 0x20
struct FRigUnit_GetIntAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ int32_t Value;
};

// Size: 0x28
struct FRigUnit_GetItemModuleName : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool IsPartOfModule;
    /* 0x0018 */ FString Module;
};

// Size: 0x28
struct FRigUnit_GetItemNameSpace : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool HasNameSpace;
    /* 0x0018 */ FString Namespace;
};

// Size: 0x20
struct FRigUnit_GetItemShortName : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ FName ShortName;
};

// Size: 0x20
struct FRigUnit_GetItemsInModule : public FRigUnit_RigModulesBase {
    /* 0x0008 */ ERigElementType TypeToSearch;
    /* 0x0010 */ TArray<FRigElementKey> Items;
};

// Size: 0x20
struct FRigUnit_GetItemsInNameSpace : public FRigUnit_RigModulesBase {
    /* 0x0008 */ ERigElementType TypeToSearch;
    /* 0x0010 */ TArray<FRigElementKey> Items;
};

// Size: 0xf0
struct FRigUnit_GetJointTransform : public FRigUnitMutable {
    /* 0x0010 */ FName Joint;
    /* 0x0018 */ ETransformGetterType Type;
    /* 0x0019 */ ETransformSpaceMode TransformSpace;
    /* 0x0020 */ FTransform BaseTransform;
    /* 0x0080 */ FName BaseJoint;
    /* 0x0090 */ FTransform Output;
};

// Size: 0x48
struct FRigUnit_GetMetadataTags : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0018 */ TArray<FName> Tags;
    /* 0x0028 */ FCachedRigElement CachedIndex;
};

// Size: 0x18
struct FRigUnit_GetModuleName : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FString Module;
};

// Size: 0xc0
struct FRigUnit_GetRelativeBoneTransform : public FRigUnit {
    /* 0x0008 */ FName bone;
    /* 0x0010 */ FName Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedBone;
    /* 0x00a0 */ FCachedRigElement CachedSpace;
};

// Size: 0x130
struct FRigUnit_GetRelativeTransform : public FRigUnit_BinaryTransformOp {
};

// Size: 0xd0
struct FRigUnit_GetRelativeTransformForItem : public FRigUnit {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0014 */ bool bChildInitial;
    /* 0x0018 */ FRigElementKey Parent;
    /* 0x0024 */ bool bParentInitial;
    /* 0x0030 */ FTransform RelativeTransform;
    /* 0x0090 */ FCachedRigElement CachedChild;
    /* 0x00b0 */ FCachedRigElement CachedParent;
};

// Size: 0x48
struct FRigUnit_GetRotatorAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ FRotator Value;
};

// Size: 0x30
struct FRigUnit_GetRotatorAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ FRotator Value;
};

// Size: 0x90
struct FRigUnit_GetShapeTransform : public FRigUnit {
    /* 0x0008 */ FName Control;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FCachedRigElement CachedControlIndex;
};

// Size: 0xa0
struct FRigUnit_GetSpaceTransform : public FRigUnit {
    /* 0x0008 */ FName Space;
    /* 0x0010 */ ERigVMTransformSpace SpaceType;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedSpaceIndex;
};

// Size: 0xa0
struct FRigUnit_GetTransform : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ ERigVMTransformSpace Space;
    /* 0x0015 */ bool bInitial;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedIndex;
};

// Size: 0x90
struct FRigUnit_GetTransformAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ FTransform Value;
};

// Size: 0x80
struct FRigUnit_GetTransformAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0020 */ FTransform Value;
};

// Size: 0x40
struct FRigUnit_GetTransformArray : public FRigUnit {
    /* 0x0008 */ FRigElementKeyCollection Items;
    /* 0x0018 */ ERigVMTransformSpace Space;
    /* 0x0019 */ bool bInitial;
    /* 0x0020 */ TArray<FTransform> Transforms;
    /* 0x0030 */ TArray<FCachedRigElement> CachedIndex;
};

// Size: 0x40
struct FRigUnit_GetTransformItemArray : public FRigUnit {
    /* 0x0008 */ TArray<FRigElementKey> Items;
    /* 0x0018 */ ERigVMTransformSpace Space;
    /* 0x0019 */ bool bInitial;
    /* 0x0020 */ TArray<FTransform> Transforms;
    /* 0x0030 */ TArray<FCachedRigElement> CachedIndex;
};

// Size: 0x40
struct FRigUnit_GetVector2DAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ FVector2D Value;
};

// Size: 0x28
struct FRigUnit_GetVector2DAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ FVector2D Value;
};

// Size: 0x48
struct FRigUnit_GetVectorAnimationChannel : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ FVector Value;
};

// Size: 0x30
struct FRigUnit_GetVectorAnimationChannelFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ FVector Value;
};

// Size: 0x10
struct FRigUnit_Harmonics_TargetItem {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x000c */ float Ratio;
};

// Size: 0x40
struct FRigUnit_HasMetadata : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ FName Name;
    /* 0x001c */ ERigMetadataType Type;
    /* 0x001d */ ERigMetaDataNameSpace Namespace;
    /* 0x001e */ bool Found;
    /* 0x0020 */ FCachedRigElement CachedIndex;
};

// Size: 0x40
struct FRigUnit_HasMetadataTag : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ FName Tag;
    /* 0x001c */ ERigMetaDataNameSpace Namespace;
    /* 0x001d */ bool Found;
    /* 0x0020 */ FCachedRigElement CachedIndex;
};

// Size: 0x50
struct FRigUnit_HasMetadataTagArray : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0018 */ TArray<FName> Tags;
    /* 0x0028 */ ERigMetaDataNameSpace Namespace;
    /* 0x0029 */ bool Found;
    /* 0x0030 */ FCachedRigElement CachedIndex;
};

// Size: 0x4
struct FRigUnit_HierarchyAddAnimationChannel2DLimitSettings : public FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled X;
    /* 0x0002 */ FRigControlLimitEnabled Y;
};

// Size: 0x38
struct FRigUnit_HierarchyAddAnimationChannelBool : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ bool InitialValue;
    /* 0x0031 */ bool MinimumValue;
    /* 0x0032 */ bool MaximumValue;
    /* 0x0033 */ FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings LimitsEnabled;
};

// Size: 0x1
struct FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings {
};

// Size: 0x40
struct FRigUnit_HierarchyAddAnimationChannelFloat : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ float InitialValue;
    /* 0x0034 */ float MinimumValue;
    /* 0x0038 */ float MaximumValue;
    /* 0x003c */ FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings LimitsEnabled;
};

// Size: 0x48
struct FRigUnit_HierarchyAddAnimationChannelInteger : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ int32_t InitialValue;
    /* 0x0034 */ int32_t MinimumValue;
    /* 0x0038 */ int32_t MaximumValue;
    /* 0x003c */ FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings LimitsEnabled;
    /* 0x0040 */ UEnum* ControlEnum;
};

// Size: 0x80
struct FRigUnit_HierarchyAddAnimationChannelRotator : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FRotator InitialValue;
    /* 0x0048 */ FRotator MinimumValue;
    /* 0x0060 */ FRotator MaximumValue;
    /* 0x0078 */ FRigUnit_HierarchyAddAnimationChannelRotatorLimitSettings LimitsEnabled;
};

// Size: 0x6
struct FRigUnit_HierarchyAddAnimationChannelRotatorLimitSettings : public FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled Pitch;
    /* 0x0002 */ FRigControlLimitEnabled Yaw;
    /* 0x0004 */ FRigControlLimitEnabled Roll;
};

// Size: 0x40
struct FRigUnit_HierarchyAddAnimationChannelScaleFloat : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ float InitialValue;
    /* 0x0034 */ float MinimumValue;
    /* 0x0038 */ float MaximumValue;
    /* 0x003c */ FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings LimitsEnabled;
};

// Size: 0x80
struct FRigUnit_HierarchyAddAnimationChannelScaleVector : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FVector InitialValue;
    /* 0x0048 */ FVector MinimumValue;
    /* 0x0060 */ FVector MaximumValue;
    /* 0x0078 */ FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings LimitsEnabled;
};

// Size: 0x2
struct FRigUnit_HierarchyAddAnimationChannelSingleLimitSettings : public FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled Enabled;
};

// Size: 0x80
struct FRigUnit_HierarchyAddAnimationChannelVector : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FVector InitialValue;
    /* 0x0048 */ FVector MinimumValue;
    /* 0x0060 */ FVector MaximumValue;
    /* 0x0078 */ FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings LimitsEnabled;
};

// Size: 0x68
struct FRigUnit_HierarchyAddAnimationChannelVector2D : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FVector2D InitialValue;
    /* 0x0040 */ FVector2D MinimumValue;
    /* 0x0050 */ FVector2D MaximumValue;
    /* 0x0060 */ FRigUnit_HierarchyAddAnimationChannel2DLimitSettings LimitsEnabled;
};

// Size: 0x6
struct FRigUnit_HierarchyAddAnimationChannelVectorLimitSettings : public FRigUnit_HierarchyAddAnimationChannelEmptyLimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled X;
    /* 0x0002 */ FRigControlLimitEnabled Y;
    /* 0x0004 */ FRigControlLimitEnabled Z;
};

// Size: 0xa0
struct FRigUnit_HierarchyAddBone : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FTransform Transform;
    /* 0x0090 */ ERigVMTransformSpace Space;
};

// Size: 0xa0
struct FRigUnit_HierarchyAddControlElement : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FTransform OffsetTransform;
    /* 0x0090 */ ERigVMTransformSpace OffsetSpace;
};

// Size: 0x170
struct FRigUnit_HierarchyAddControlFloat : public FRigUnit_HierarchyAddControlElement {
    /* 0x0098 */ float InitialValue;
    /* 0x00a0 */ FRigUnit_HierarchyAddControlFloat_Settings Settings;
};

// Size: 0x10
struct FRigUnit_HierarchyAddControlFloat_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled Limit;
    /* 0x0004 */ float MinValue;
    /* 0x0008 */ float MaxValue;
    /* 0x000c */ bool bDrawLimits;
};

// Size: 0xd0
struct FRigUnit_HierarchyAddControlFloat_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigControlAxis PrimaryAxis;
    /* 0x0011 */ bool bIsScale;
    /* 0x0014 */ FRigUnit_HierarchyAddControlFloat_LimitSettings limits;
    /* 0x0030 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x00b0 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
};

// Size: 0x170
struct FRigUnit_HierarchyAddControlInteger : public FRigUnit_HierarchyAddControlElement {
    /* 0x0098 */ int32_t InitialValue;
    /* 0x00a0 */ FRigUnit_HierarchyAddControlInteger_Settings Settings;
};

// Size: 0x10
struct FRigUnit_HierarchyAddControlInteger_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled Limit;
    /* 0x0004 */ int32_t MinValue;
    /* 0x0008 */ int32_t MaxValue;
    /* 0x000c */ bool bDrawLimits;
};

// Size: 0xd0
struct FRigUnit_HierarchyAddControlInteger_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigControlAxis PrimaryAxis;
    /* 0x0018 */ UEnum* ControlEnum;
    /* 0x0020 */ FRigUnit_HierarchyAddControlInteger_LimitSettings limits;
    /* 0x0030 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x00b0 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
};

// Size: 0x1d0
struct FRigUnit_HierarchyAddControlRotator : public FRigUnit_HierarchyAddControlElement {
    /* 0x0098 */ FRotator InitialValue;
    /* 0x00b0 */ FRigUnit_HierarchyAddControlRotator_Settings Settings;
};

// Size: 0x40
struct FRigUnit_HierarchyAddControlRotator_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled LimitPitch;
    /* 0x0002 */ FRigControlLimitEnabled LimitYaw;
    /* 0x0004 */ FRigControlLimitEnabled LimitRoll;
    /* 0x0008 */ FRotator MinValue;
    /* 0x0020 */ FRotator MaxValue;
    /* 0x0038 */ bool bDrawLimits;
};

// Size: 0x120
struct FRigUnit_HierarchyAddControlRotator_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigVMTransformSpace InitialSpace;
    /* 0x0018 */ FRigUnit_HierarchyAddControlRotator_LimitSettings limits;
    /* 0x0060 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x00e0 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
    /* 0x0100 */ TArray<ERigControlTransformChannel> FilteredChannels;
    /* 0x0110 */ bool bUsePreferredRotationOrder;
    /* 0x0111 */ EEulerRotationOrder PreferredRotationOrder;
};

// Size: 0x280
struct FRigUnit_HierarchyAddControlTransform : public FRigUnit_HierarchyAddControlElement {
    /* 0x00a0 */ FTransform InitialValue;
    /* 0x0100 */ FRigUnit_HierarchyAddControlTransform_Settings Settings;
};

// Size: 0xb0
struct FRigUnit_HierarchyAddControlTransform_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled LimitTranslationX;
    /* 0x0002 */ FRigControlLimitEnabled LimitTranslationY;
    /* 0x0004 */ FRigControlLimitEnabled LimitTranslationZ;
    /* 0x0006 */ FRigControlLimitEnabled LimitPitch;
    /* 0x0008 */ FRigControlLimitEnabled LimitYaw;
    /* 0x000a */ FRigControlLimitEnabled LimitRoll;
    /* 0x000c */ FRigControlLimitEnabled LimitScaleX;
    /* 0x000e */ FRigControlLimitEnabled LimitScaleY;
    /* 0x0010 */ FRigControlLimitEnabled LimitScaleZ;
    /* 0x0018 */ FEulerTransform MinValue;
    /* 0x0060 */ FEulerTransform MaxValue;
    /* 0x00a8 */ bool bDrawLimits;
};

// Size: 0x180
struct FRigUnit_HierarchyAddControlTransform_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigVMTransformSpace InitialSpace;
    /* 0x0011 */ bool bUsePreferredRotationOrder;
    /* 0x0012 */ EEulerRotationOrder PreferredRotationOrder;
    /* 0x0018 */ FRigUnit_HierarchyAddControlTransform_LimitSettings limits;
    /* 0x00d0 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x0150 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
    /* 0x0170 */ TArray<ERigControlTransformChannel> FilteredChannels;
};

// Size: 0x1c0
struct FRigUnit_HierarchyAddControlVector : public FRigUnit_HierarchyAddControlElement {
    /* 0x0098 */ FVector InitialValue;
    /* 0x00b0 */ FRigUnit_HierarchyAddControlVector_Settings Settings;
};

// Size: 0x1b0
struct FRigUnit_HierarchyAddControlVector2D : public FRigUnit_HierarchyAddControlElement {
    /* 0x0098 */ FVector2D InitialValue;
    /* 0x00b0 */ FRigUnit_HierarchyAddControlVector2D_Settings Settings;
};

// Size: 0x30
struct FRigUnit_HierarchyAddControlVector2D_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled LimitX;
    /* 0x0002 */ FRigControlLimitEnabled LimitY;
    /* 0x0008 */ FVector2D MinValue;
    /* 0x0018 */ FVector2D MaxValue;
    /* 0x0028 */ bool bDrawLimits;
};

// Size: 0x100
struct FRigUnit_HierarchyAddControlVector2D_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigControlAxis PrimaryAxis;
    /* 0x0018 */ FRigUnit_HierarchyAddControlVector2D_LimitSettings limits;
    /* 0x0050 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x00d0 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
    /* 0x00f0 */ TArray<ERigControlTransformChannel> FilteredChannels;
};

// Size: 0x40
struct FRigUnit_HierarchyAddControlVector_LimitSettings {
    /* 0x0000 */ FRigControlLimitEnabled LimitX;
    /* 0x0002 */ FRigControlLimitEnabled LimitY;
    /* 0x0004 */ FRigControlLimitEnabled LimitZ;
    /* 0x0008 */ FVector MinValue;
    /* 0x0020 */ FVector MaxValue;
    /* 0x0038 */ bool bDrawLimits;
};

// Size: 0x110
struct FRigUnit_HierarchyAddControlVector_Settings : public FRigUnit_HierarchyAddControl_Settings {
    /* 0x0010 */ ERigVMTransformSpace InitialSpace;
    /* 0x0011 */ bool bIsPosition;
    /* 0x0018 */ FRigUnit_HierarchyAddControlVector_LimitSettings limits;
    /* 0x0060 */ FRigUnit_HierarchyAddControl_ShapeSettings Shape;
    /* 0x00e0 */ FRigUnit_HierarchyAddControl_ProxySettings Proxy;
    /* 0x0100 */ TArray<ERigControlTransformChannel> FilteredChannels;
};

// Size: 0x20
struct FRigUnit_HierarchyAddControl_ProxySettings {
    /* 0x0000 */ bool bIsProxy;
    /* 0x0008 */ TArray<FRigElementKey> DrivenControls;
    /* 0x0018 */ ERigControlVisibility ShapeVisibility;
};

// Size: 0x10
struct FRigUnit_HierarchyAddControl_Settings {
    /* 0x0008 */ FName DisplayName;
};

// Size: 0x80
struct FRigUnit_HierarchyAddControl_ShapeSettings {
    /* 0x0000 */ bool bVisible;
    /* 0x0004 */ FName Name;
    /* 0x000c */ FLinearColor Color;
    /* 0x0020 */ FTransform Transform;
};

// Size: 0x30
struct FRigUnit_HierarchyAddElement : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Parent;
    /* 0x001c */ FName Name;
    /* 0x0024 */ FRigElementKey Item;
};

// Size: 0xa0
struct FRigUnit_HierarchyAddNull : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FTransform Transform;
    /* 0x0090 */ ERigVMTransformSpace Space;
};

// Size: 0xa0
struct FRigUnit_HierarchyAddPhysicsJoint : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FTransform Transform;
    /* 0x0090 */ FRigPhysicsSolverID Solver;
};

// Size: 0x28
struct FRigUnit_HierarchyAddPhysicsSolver : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FRigPhysicsSolverID Solver;
};

// Size: 0xc0
struct FRigUnit_HierarchyAddSocket : public FRigUnit_HierarchyAddElement {
    /* 0x0030 */ FTransform Transform;
    /* 0x0090 */ ERigVMTransformSpace Space;
    /* 0x0094 */ FLinearColor Color;
    /* 0x00a8 */ FString Description;
};

// Size: 0x8
struct FRigUnit_HierarchyBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_HierarchyBaseMutable : public FRigUnitMutable {
};

// Size: 0x88
struct FRigUnit_HierarchyCreatePoseItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ TArray<FRigUnit_HierarchyCreatePoseItemArray_Entry> Entries;
    /* 0x0018 */ FRigPose Pose;
};

// Size: 0x100
struct FRigUnit_HierarchyCreatePoseItemArray_Entry {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x0010 */ FTransform LocalTransform;
    /* 0x0070 */ FTransform GlobalTransform;
    /* 0x00d0 */ bool UseEulerAngles;
    /* 0x00d8 */ FVector EulerAngles;
    /* 0x00f0 */ float CurveValue;
};

// Size: 0x88
struct FRigUnit_HierarchyGetChainItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Start;
    /* 0x0014 */ FRigElementKey End;
    /* 0x0020 */ bool bIncludeStart;
    /* 0x0021 */ bool bIncludeEnd;
    /* 0x0022 */ bool bReverse;
    /* 0x0028 */ TArray<FRigElementKey> Chain;
    /* 0x0038 */ FCachedRigElement CachedStart;
    /* 0x0058 */ FCachedRigElement CachedEnd;
    /* 0x0078 */ FRigElementKeyCollection CachedChain;
};

// Size: 0x58
struct FRigUnit_HierarchyGetChildren : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Parent;
    /* 0x0014 */ bool bIncludeParent;
    /* 0x0015 */ bool bRecursive;
    /* 0x0018 */ FRigElementKeyCollection Children;
    /* 0x0028 */ FCachedRigElement CachedParent;
    /* 0x0048 */ FRigElementKeyCollection CachedChildren;
};

// Size: 0x68
struct FRigUnit_HierarchyGetParent : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0014 */ bool bDefaultParent;
    /* 0x0018 */ FRigElementKey Parent;
    /* 0x0028 */ FCachedRigElement CachedChild;
    /* 0x0048 */ FCachedRigElement CachedParent;
};

// Size: 0x38
struct FRigUnit_HierarchyGetParentWeights : public FRigUnit_DynamicHierarchyBase {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0018 */ TArray<FRigElementWeight> Weights;
    /* 0x0028 */ FRigElementKeyCollection Parents;
};

// Size: 0x38
struct FRigUnit_HierarchyGetParentWeightsArray : public FRigUnit_DynamicHierarchyBase {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0018 */ TArray<FRigElementWeight> Weights;
    /* 0x0028 */ TArray<FRigElementKey> Parents;
};

// Size: 0x58
struct FRigUnit_HierarchyGetParents : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0014 */ bool bIncludeChild;
    /* 0x0015 */ bool bReverse;
    /* 0x0018 */ FRigElementKeyCollection Parents;
    /* 0x0028 */ FCachedRigElement CachedChild;
    /* 0x0048 */ FRigElementKeyCollection CachedParents;
};

// Size: 0x58
struct FRigUnit_HierarchyGetParentsItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0014 */ bool bIncludeChild;
    /* 0x0015 */ bool bReverse;
    /* 0x0016 */ bool bDefaultParent;
    /* 0x0018 */ TArray<FRigElementKey> Parents;
    /* 0x0028 */ FCachedRigElement CachedChild;
    /* 0x0048 */ FRigElementKeyCollection CachedParents;
};

// Size: 0x90
struct FRigUnit_HierarchyGetPose : public FRigUnit_HierarchyBase {
    /* 0x0008 */ bool Initial;
    /* 0x0009 */ ERigElementType ElementType;
    /* 0x0010 */ FRigElementKeyCollection ItemsToGet;
    /* 0x0020 */ FRigPose Pose;
};

// Size: 0x90
struct FRigUnit_HierarchyGetPoseItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ bool Initial;
    /* 0x0009 */ ERigElementType ElementType;
    /* 0x0010 */ TArray<FRigElementKey> ItemsToGet;
    /* 0x0020 */ FRigPose Pose;
};

// Size: 0xa0
struct FRigUnit_HierarchyGetShapeSettings : public FRigUnit_DynamicHierarchyBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0020 */ FRigUnit_HierarchyAddControl_ShapeSettings Settings;
};

// Size: 0x58
struct FRigUnit_HierarchyGetSiblings : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool bIncludeItem;
    /* 0x0018 */ FRigElementKeyCollection Siblings;
    /* 0x0028 */ FCachedRigElement CachedItem;
    /* 0x0048 */ FRigElementKeyCollection CachedSiblings;
};

// Size: 0x58
struct FRigUnit_HierarchyGetSiblingsItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool bIncludeItem;
    /* 0x0015 */ bool bDefaultSiblings;
    /* 0x0018 */ TArray<FRigElementKey> Siblings;
    /* 0x0028 */ FCachedRigElement CachedItem;
    /* 0x0048 */ FRigElementKeyCollection CachedSiblings;
};

// Size: 0x30
struct FRigUnit_HierarchyImportFromSkeleton : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FName Namespace;
    /* 0x0018 */ bool bIncludeCurves;
    /* 0x0019 */ bool bIncludeMeshSockets;
    /* 0x001a */ bool bIncludeVirtualBones;
    /* 0x0020 */ TArray<FRigElementKey> Items;
};

// Size: 0x20
struct FRigUnit_HierarchyRemoveElement : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ bool bSuccess;
};

// Size: 0x10
struct FRigUnit_HierarchyReset : public FRigUnit_DynamicHierarchyBaseMutable {
};

// Size: 0x30
struct FRigUnit_HierarchySetParentWeights : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x0020 */ TArray<FRigElementWeight> Weights;
};

// Size: 0xa0
struct FRigUnit_HierarchySetPose : public FRigUnit_HierarchyBaseMutable {
    /* 0x0010 */ FRigPose Pose;
    /* 0x0080 */ ERigElementType ElementType;
    /* 0x0081 */ ERigVMTransformSpace Space;
    /* 0x0088 */ FRigElementKeyCollection ItemsToSet;
    /* 0x0098 */ float Weight;
};

// Size: 0xa0
struct FRigUnit_HierarchySetPoseItemArray : public FRigUnit_HierarchyBaseMutable {
    /* 0x0010 */ FRigPose Pose;
    /* 0x0080 */ ERigElementType ElementType;
    /* 0x0081 */ ERigVMTransformSpace Space;
    /* 0x0088 */ TArray<FRigElementKey> ItemsToSet;
    /* 0x0098 */ float Weight;
};

// Size: 0xa0
struct FRigUnit_HierarchySetShapeSettings : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x0020 */ FRigUnit_HierarchyAddControl_ShapeSettings Settings;
};

// Size: 0x8
struct FRigUnit_HighlevelBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_HighlevelBaseMutable : public FRigUnitMutable {
};

// Size: 0x10
struct FRigUnit_InteractionExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x10
struct FRigUnit_InverseExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x50
struct FRigUnit_InverseQuaterion : public FRigUnit_UnaryQuaternionOp {
};

// Size: 0x20
struct FRigUnit_IsInteracting : public FRigUnit {
    /* 0x0008 */ bool bIsInteracting;
    /* 0x0009 */ bool bIsTranslating;
    /* 0x000a */ bool bIsRotating;
    /* 0x000b */ bool bIsScaling;
    /* 0x0010 */ TArray<FRigElementKey> Items;
};

// Size: 0x18
struct FRigUnit_IsItemInCurrentModule : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool Result;
};

// Size: 0x18
struct FRigUnit_IsItemInCurrentNameSpace : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool Result;
};

// Size: 0x18
struct FRigUnit_Item : public FRigUnit {
    /* 0x0008 */ FRigElementKey Item;
};

// Size: 0x18
struct FRigUnit_ItemArray : public FRigUnit {
    /* 0x0008 */ TArray<FRigElementKey> Items;
};

// Size: 0x8
struct FRigUnit_ItemBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_ItemBaseMutable : public FRigUnitMutable {
};

// Size: 0x28
struct FRigUnit_ItemEquals : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey A;
    /* 0x0014 */ FRigElementKey B;
    /* 0x0020 */ bool Result;
};

// Size: 0x38
struct FRigUnit_ItemExists : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ bool Exists;
    /* 0x0018 */ FCachedRigElement CachedIndex;
};

// Size: 0xd0
struct FRigUnit_ItemHarmonics : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigUnit_Harmonics_TargetItem> Targets;
    /* 0x0020 */ FVector WaveSpeed;
    /* 0x0038 */ FVector WaveFrequency;
    /* 0x0050 */ FVector WaveAmplitude;
    /* 0x0068 */ FVector WaveOffset;
    /* 0x0080 */ FVector WaveNoise;
    /* 0x0098 */ ERigVMAnimEasingType WaveEase;
    /* 0x009c */ float WaveMinimum;
    /* 0x00a0 */ float WaveMaximum;
    /* 0x00a4 */ EEulerRotationOrder RotationOrder;
    /* 0x00a8 */ FRigUnit_BoneHarmonics_WorkData WorkData;
};

// Size: 0x28
struct FRigUnit_ItemNotEquals : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey A;
    /* 0x0014 */ FRigElementKey B;
    /* 0x0020 */ bool Result;
};

// Size: 0x30
struct FRigUnit_ItemReplace : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey Item;
    /* 0x0014 */ FName Old;
    /* 0x001c */ FName New;
    /* 0x0024 */ FRigElementKey Result;
};

// Size: 0x20
struct FRigUnit_ItemToName : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey Value;
    /* 0x0014 */ FName Result;
};

// Size: 0x28
struct FRigUnit_ItemTypeEquals : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey A;
    /* 0x0014 */ FRigElementKey B;
    /* 0x0020 */ bool Result;
};

// Size: 0x28
struct FRigUnit_ItemTypeNotEquals : public FRigUnit_ItemBase {
    /* 0x0008 */ FRigElementKey A;
    /* 0x0014 */ FRigElementKey B;
    /* 0x0020 */ bool Result;
};

// Size: 0x20
struct FRigUnit_MapRange_Float : public FRigUnit {
    /* 0x0008 */ float Value;
    /* 0x000c */ float MinIn;
    /* 0x0010 */ float MaxIn;
    /* 0x0014 */ float MinOut;
    /* 0x0018 */ float MaxOut;
    /* 0x001c */ float Result;
};

// Size: 0x40
struct FRigUnit_ModifyBoneTransforms : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigUnit_ModifyBoneTransforms_PerBone> BoneToModify;
    /* 0x0020 */ float Weight;
    /* 0x0024 */ float WeightMinimum;
    /* 0x0028 */ float WeightMaximum;
    /* 0x002c */ EControlRigModifyBoneMode Mode;
    /* 0x0030 */ FRigUnit_ModifyBoneTransforms_WorkData WorkData;
};

// Size: 0x70
struct FRigUnit_ModifyBoneTransforms_PerBone {
    /* 0x0000 */ FName bone;
    /* 0x0010 */ FTransform Transform;
};

// Size: 0x10
struct FRigUnit_ModifyBoneTransforms_WorkData : public FRigUnit_ModifyTransforms_WorkData {
};

// Size: 0x40
struct FRigUnit_ModifyTransforms : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigUnit_ModifyTransforms_PerItem> ItemToModify;
    /* 0x0020 */ float Weight;
    /* 0x0024 */ float WeightMinimum;
    /* 0x0028 */ float WeightMaximum;
    /* 0x002c */ EControlRigModifyBoneMode Mode;
    /* 0x0030 */ FRigUnit_ModifyTransforms_WorkData WorkData;
};

// Size: 0x70
struct FRigUnit_ModifyTransforms_PerItem {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x0010 */ FTransform Transform;
};

// Size: 0x10
struct FRigUnit_ModifyTransforms_WorkData {
    /* 0x0000 */ TArray<FCachedRigElement> CachedItems;
};

// Size: 0xa8
struct FRigUnit_MultiFABRIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName RootBone;
    /* 0x0018 */ TArray<FRigUnit_MultiFABRIK_EndEffector> Effectors;
    /* 0x0028 */ float Precision;
    /* 0x002c */ bool bPropagateToChildren;
    /* 0x0030 */ int32_t MaxIterations;
    /* 0x0038 */ FRigUnit_MultiFABRIK_WorkData WorkData;
    /* 0x00a0 */ bool bIsInitialized;
};

// Size: 0x20
struct FRigUnit_MultiFABRIK_EndEffector {
    /* 0x0000 */ FName bone;
    /* 0x0008 */ FVector Location;
};

// Size: 0x68
struct FRigUnit_MultiFABRIK_WorkData {
};

// Size: 0x70
struct FRigUnit_MultiplyQuaternion : public FRigUnit_BinaryQuaternionOp {
};

// Size: 0x130
struct FRigUnit_MultiplyTransform : public FRigUnit_BinaryTransformOp {
};

// Size: 0x18
struct FRigUnit_Multiply_FloatFloat : public FRigUnit_BinaryFloatOp {
};

// Size: 0x50
struct FRigUnit_Multiply_VectorVector : public FRigUnit_BinaryVectorOp {
};

// Size: 0xb0
struct FRigUnit_OffsetTransformForItem : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x0020 */ FTransform OffsetTransform;
    /* 0x0080 */ float Weight;
    /* 0x0084 */ bool bPropagateToChildren;
    /* 0x0088 */ FCachedRigElement CachedIndex;
};

// Size: 0x70
struct FRigUnit_ParentConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FTransformFilter Filter;
    /* 0x0028 */ TArray<FConstraintParent> Parents;
    /* 0x0038 */ FRigUnit_ParentConstraint_AdvancedSettings AdvancedSettings;
    /* 0x003c */ float Weight;
    /* 0x0040 */ FCachedRigElement ChildCache;
    /* 0x0060 */ TArray<FCachedRigElement> ParentCaches;
};

// Size: 0x100
struct FRigUnit_ParentConstraintMath : public FRigUnit_HighlevelBase {
    /* 0x0010 */ FTransform Input;
    /* 0x0070 */ TArray<FConstraintParent> Parents;
    /* 0x0080 */ FRigUnit_ParentConstraintMath_AdvancedSettings AdvancedSettings;
    /* 0x0090 */ FTransform Output;
    /* 0x00f0 */ TArray<FCachedRigElement> ParentCaches;
};

// Size: 0x1
struct FRigUnit_ParentConstraintMath_AdvancedSettings {
    /* 0x0000 */ EConstraintInterpType InterpolationType;
};

// Size: 0x2
struct FRigUnit_ParentConstraint_AdvancedSettings {
    /* 0x0000 */ EConstraintInterpType InterpolationType;
    /* 0x0001 */ EEulerRotationOrder RotationOrderForFilter;
};

// Size: 0x1b0
struct FRigUnit_ParentSwitchConstraint : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Subject;
    /* 0x001c */ int32_t ParentIndex;
    /* 0x0020 */ FRigElementKeyCollection Parents;
    /* 0x0030 */ FTransform InitialGlobalTransform;
    /* 0x0090 */ float Weight;
    /* 0x00a0 */ FTransform Transform;
    /* 0x0100 */ bool Switched;
    /* 0x0108 */ FCachedRigElement CachedSubject;
    /* 0x0128 */ FCachedRigElement CachedParent;
    /* 0x0150 */ FTransform RelativeOffset;
};

// Size: 0x1b0
struct FRigUnit_ParentSwitchConstraintArray : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Subject;
    /* 0x001c */ int32_t ParentIndex;
    /* 0x0020 */ TArray<FRigElementKey> Parents;
    /* 0x0030 */ FTransform InitialGlobalTransform;
    /* 0x0090 */ float Weight;
    /* 0x00a0 */ FTransform Transform;
    /* 0x0100 */ bool Switched;
    /* 0x0108 */ FCachedRigElement CachedSubject;
    /* 0x0128 */ FCachedRigElement CachedParent;
    /* 0x0150 */ FTransform RelativeOffset;
};

// Size: 0x220
struct FRigUnit_PointSimulation : public FRigVMFunction_SimBaseMutable {
    /* 0x0010 */ TArray<FRigVMSimPoint> points;
    /* 0x0020 */ TArray<FCRSimLinearSpring> links;
    /* 0x0030 */ TArray<FCRSimPointForce> Forces;
    /* 0x0040 */ TArray<FCRSimSoftCollision> CollisionVolumes;
    /* 0x0050 */ float SimulatedStepsPerSecond;
    /* 0x0054 */ ERigVMSimPointIntegrateType IntegratorType;
    /* 0x0058 */ float VerletBlend;
    /* 0x0060 */ TArray<FRigUnit_PointSimulation_BoneTarget> BoneTargets;
    /* 0x0070 */ bool bLimitLocalPosition;
    /* 0x0071 */ bool bPropagateToChildren;
    /* 0x0078 */ FVector PrimaryAimAxis;
    /* 0x0090 */ FVector SecondaryAimAxis;
    /* 0x00b0 */ FRigUnit_PointSimulation_DebugSettings DebugSettings;
    /* 0x0130 */ FRigVMFourPointBezier Bezier;
    /* 0x0190 */ FRigUnit_PointSimulation_WorkData WorkData;
};

// Size: 0x14
struct FRigUnit_PointSimulation_BoneTarget {
    /* 0x0000 */ FName bone;
    /* 0x0008 */ int32_t TranslationPoint;
    /* 0x000c */ int32_t PrimaryAimPoint;
    /* 0x0010 */ int32_t SecondaryAimPoint;
};

// Size: 0x80
struct FRigUnit_PointSimulation_DebugSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Scale;
    /* 0x0008 */ float CollisionScale;
    /* 0x000c */ bool bDrawPointsAsSpheres;
    /* 0x0010 */ FLinearColor Color;
    /* 0x0020 */ FTransform worldOffset;
};

// Size: 0x88
struct FRigUnit_PointSimulation_WorkData {
    /* 0x0000 */ FCRSimPointContainer Simulation;
    /* 0x0078 */ TArray<FCachedRigElement> BoneIndices;
};

// Size: 0x90
struct FRigUnit_PoseGetCurve : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ FName Curve;
    /* 0x0080 */ bool Valid;
    /* 0x0084 */ float CurveValue;
    /* 0x0088 */ int32_t CachedPoseElementIndex;
    /* 0x008c */ int32_t CachedPoseHash;
};

// Size: 0x128
struct FRigUnit_PoseGetDelta : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose PoseA;
    /* 0x0078 */ FRigPose PoseB;
    /* 0x00e8 */ float PositionThreshold;
    /* 0x00ec */ float RotationThreshold;
    /* 0x00f0 */ float ScaleThreshold;
    /* 0x00f4 */ float CurveThreshold;
    /* 0x00f8 */ ERigElementType ElementType;
    /* 0x00f9 */ ERigVMTransformSpace Space;
    /* 0x0100 */ FRigElementKeyCollection ItemsToCompare;
    /* 0x0110 */ bool PosesAreEqual;
    /* 0x0118 */ FRigElementKeyCollection ItemsWithDelta;
};

// Size: 0x90
struct FRigUnit_PoseGetItems : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ ERigElementType ElementType;
    /* 0x0080 */ FRigElementKeyCollection Items;
};

// Size: 0x90
struct FRigUnit_PoseGetItemsItemArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ ERigElementType ElementType;
    /* 0x0080 */ TArray<FRigElementKey> Items;
};

// Size: 0x100
struct FRigUnit_PoseGetTransform : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ FRigElementKey Item;
    /* 0x0084 */ ERigVMTransformSpace Space;
    /* 0x0085 */ bool Valid;
    /* 0x0090 */ FTransform Transform;
    /* 0x00f0 */ float CurveValue;
    /* 0x00f4 */ int32_t CachedPoseElementIndex;
    /* 0x00f8 */ int32_t CachedPoseHash;
};

// Size: 0x90
struct FRigUnit_PoseGetTransformArray : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ ERigVMTransformSpace Space;
    /* 0x0079 */ bool Valid;
    /* 0x0080 */ TArray<FTransform> Transforms;
};

// Size: 0x80
struct FRigUnit_PoseIsEmpty : public FRigUnit_HierarchyBase {
    /* 0x0008 */ FRigPose Pose;
    /* 0x0078 */ bool IsEmpty;
};

// Size: 0x380
struct FRigUnit_PoseLoop : public FRigUnit_HierarchyBaseMutable {
    /* 0x0010 */ FName BlockToRun;
    /* 0x0018 */ FRigPose Pose;
    /* 0x0088 */ FRigElementKey Item;
    /* 0x00a0 */ FTransform GlobalTransform;
    /* 0x0100 */ FTransform LocalTransform;
    /* 0x0160 */ float CurveValue;
    /* 0x0164 */ int32_t Index;
    /* 0x0168 */ int32_t Count;
    /* 0x016c */ float Ratio;
    /* 0x0170 */ FControlRigExecuteContext completed;
};

// Size: 0x38
struct FRigUnit_PositionConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ float Weight;
};

// Size: 0x68
struct FRigUnit_PositionConstraintLocalSpaceOffset : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ float Weight;
    /* 0x0038 */ FCachedRigElement ChildCache;
    /* 0x0058 */ TArray<FCachedRigElement> ParentCaches;
};

// Size: 0x10
struct FRigUnit_PostBeginExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x10
struct FRigUnit_PostPrepareForExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x10
struct FRigUnit_PreBeginExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x10
struct FRigUnit_PrepareForExecution : public FRigUnit {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x100
struct FRigUnit_ProjectTransformToNewParent : public FRigUnit {
    /* 0x0008 */ FRigElementKey Child;
    /* 0x0014 */ bool bChildInitial;
    /* 0x0018 */ FRigElementKey OldParent;
    /* 0x0024 */ bool bOldParentInitial;
    /* 0x0028 */ FRigElementKey NewParent;
    /* 0x0034 */ bool bNewParentInitial;
    /* 0x0040 */ FTransform Transform;
    /* 0x00a0 */ FCachedRigElement CachedChild;
    /* 0x00c0 */ FCachedRigElement CachedOldParent;
    /* 0x00e0 */ FCachedRigElement CachedNewParent;
};

// Size: 0x40
struct FRigUnit_PropagateTransform : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ bool bRecomputeGlobal;
    /* 0x001d */ bool bApplyToChildren;
    /* 0x001e */ bool bRecursive;
    /* 0x0020 */ FCachedRigElement CachedIndex;
};

// Size: 0x50
struct FRigUnit_QuaternionFromAxisAndAngle : public FRigUnit {
    /* 0x0008 */ FVector Axis;
    /* 0x0020 */ float Angle;
    /* 0x0030 */ FQuat Result;
};

// Size: 0x50
struct FRigUnit_QuaternionToAngle : public FRigUnit {
    /* 0x0008 */ FVector Axis;
    /* 0x0020 */ FQuat argument;
    /* 0x0040 */ float Angle;
};

// Size: 0x50
struct FRigUnit_QuaternionToAxisAndAngle : public FRigUnit {
    /* 0x0010 */ FQuat argument;
    /* 0x0030 */ FVector Axis;
    /* 0x0048 */ float Angle;
};

// Size: 0x40
struct FRigUnit_RemoveAllMetadata : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ERigMetaDataNameSpace Namespace;
    /* 0x001d */ bool Removed;
    /* 0x0020 */ FCachedRigElement CachedIndex;
};

// Size: 0x48
struct FRigUnit_RemoveMetadata : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ FName Name;
    /* 0x0024 */ ERigMetaDataNameSpace Namespace;
    /* 0x0025 */ bool Removed;
    /* 0x0028 */ FCachedRigElement CachedIndex;
};

// Size: 0x48
struct FRigUnit_RemoveMetadataTag : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ FName Tag;
    /* 0x0024 */ ERigMetaDataNameSpace Namespace;
    /* 0x0025 */ bool Removed;
    /* 0x0028 */ FCachedRigElement CachedIndex;
};

// Size: 0x30
struct FRigUnit_ResolveArrayConnector : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Connector;
    /* 0x0014 */ bool SkipSocket;
    /* 0x0018 */ TArray<FRigElementKey> Result;
    /* 0x0028 */ bool bIsConnected;
};

// Size: 0x28
struct FRigUnit_ResolveConnector : public FRigUnit_RigModulesBase {
    /* 0x0008 */ FRigElementKey Connector;
    /* 0x0014 */ bool SkipSocket;
    /* 0x0018 */ FRigElementKey Result;
    /* 0x0024 */ bool bIsConnected;
};

// Size: 0x8
struct FRigUnit_RigModulesBase : public FRigUnit {
};

// Size: 0x10
struct FRigUnit_RigModulesBaseMutable : public FRigUnitMutable {
};

// Size: 0x38
struct FRigUnit_RotationConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ FRigUnit_RotationConstraint_AdvancedSettings AdvancedSettings;
    /* 0x0034 */ float Weight;
};

// Size: 0x68
struct FRigUnit_RotationConstraintLocalSpaceOffset : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ FRigUnit_RotationConstraint_AdvancedSettings AdvancedSettings;
    /* 0x0034 */ float Weight;
    /* 0x0038 */ FCachedRigElement ChildCache;
    /* 0x0058 */ TArray<FCachedRigElement> ParentCaches;
};

// Size: 0x2
struct FRigUnit_RotationConstraint_AdvancedSettings {
    /* 0x0000 */ EConstraintInterpType InterpolationType;
    /* 0x0001 */ EEulerRotationOrder RotationOrderForFilter;
};

// Size: 0x38
struct FRigUnit_ScaleConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ float Weight;
};

// Size: 0x68
struct FRigUnit_ScaleConstraintLocalSpaceOffset : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ bool bMaintainOffset;
    /* 0x001d */ FFilterOptionPerAxis Filter;
    /* 0x0020 */ TArray<FConstraintParent> Parents;
    /* 0x0030 */ float Weight;
    /* 0x0038 */ FCachedRigElement ChildCache;
    /* 0x0058 */ TArray<FCachedRigElement> ParentCaches;
};

// Size: 0x28
struct FRigUnit_SendEvent : public FRigUnitMutable {
    /* 0x0010 */ ERigEvent Event;
    /* 0x0014 */ FRigElementKey Item;
    /* 0x0020 */ float OffsetInSeconds;
    /* 0x0024 */ bool bEnable;
    /* 0x0025 */ bool bOnlyDuringInteraction;
};

// Size: 0xa60
struct FRigUnit_SequenceExecution : public FRigUnit {
    /* 0x0010 */ FControlRigExecuteContext ExecuteContext;
    /* 0x0220 */ FControlRigExecuteContext A;
    /* 0x0430 */ FControlRigExecuteContext B;
    /* 0x0640 */ FControlRigExecuteContext C;
    /* 0x0850 */ FControlRigExecuteContext D;
};

// Size: 0x38
struct FRigUnit_SetAnimationChannelBase : public FRigUnit_GetAnimationChannelBase {
    /* 0x0030 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x20
struct FRigUnit_SetAnimationChannelBaseFromItem : public FRigUnit_GetAnimationChannelFromItemBase {
    /* 0x0018 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x110
struct FRigUnit_SetBoneInitialTransform : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FTransform Result;
    /* 0x00e0 */ ERigVMTransformSpace Space;
    /* 0x00e1 */ bool bPropagateToChildren;
    /* 0x00e8 */ FCachedRigElement CachedBone;
};

// Size: 0x70
struct FRigUnit_SetBoneRotation : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0020 */ FQuat Rotation;
    /* 0x0040 */ ERigVMTransformSpace Space;
    /* 0x0044 */ float Weight;
    /* 0x0048 */ bool bPropagateToChildren;
    /* 0x0050 */ FCachedRigElement CachedBone;
};

// Size: 0x110
struct FRigUnit_SetBoneTransform : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FTransform Result;
    /* 0x00e0 */ ERigVMTransformSpace Space;
    /* 0x00e4 */ float Weight;
    /* 0x00e8 */ bool bPropagateToChildren;
    /* 0x00f0 */ FCachedRigElement CachedBone;
};

// Size: 0x60
struct FRigUnit_SetBoneTranslation : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0018 */ FVector Translation;
    /* 0x0030 */ ERigVMTransformSpace Space;
    /* 0x0034 */ float Weight;
    /* 0x0038 */ bool bPropagateToChildren;
    /* 0x0040 */ FCachedRigElement CachedBone;
};

// Size: 0x40
struct FRigUnit_SetBoolAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ bool Value;
};

// Size: 0x28
struct FRigUnit_SetBoolAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ bool Value;
};

// Size: 0x30
struct FRigUnit_SetChannelHosts : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Channel;
    /* 0x0020 */ TArray<FRigElementKey> Hosts;
};

// Size: 0x40
struct FRigUnit_SetControlBool : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ bool boolValue;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x48
struct FRigUnit_SetControlColor : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ FLinearColor Color;
    /* 0x0028 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x48
struct FRigUnit_SetControlDrivenList : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ TArray<FRigElementKey> Driven;
    /* 0x0028 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_SetControlFloat : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ float Weight;
    /* 0x001c */ float FloatValue;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x40
struct FRigUnit_SetControlInteger : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ int32_t Weight;
    /* 0x001c */ int32_t IntegerValue;
    /* 0x0020 */ FCachedRigElement CachedControlIndex;
};

// Size: 0xb0
struct FRigUnit_SetControlOffset : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0020 */ FTransform Offset;
    /* 0x0080 */ ERigVMTransformSpace Space;
    /* 0x0088 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x70
struct FRigUnit_SetControlRotationOffset : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0020 */ FQuat Offset;
    /* 0x0040 */ ERigVMTransformSpace Space;
    /* 0x0048 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x60
struct FRigUnit_SetControlRotator : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ float Weight;
    /* 0x0020 */ FRotator Rotator;
    /* 0x0038 */ ERigVMTransformSpace Space;
    /* 0x0040 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x58
struct FRigUnit_SetControlScaleOffset : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ FVector Scale;
    /* 0x0030 */ ERigVMTransformSpace Space;
    /* 0x0038 */ FCachedRigElement CachedControlIndex;
};

// Size: 0xb0
struct FRigUnit_SetControlTransform : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ float Weight;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ ERigVMTransformSpace Space;
    /* 0x0088 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x58
struct FRigUnit_SetControlTranslationOffset : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ FVector Offset;
    /* 0x0030 */ ERigVMTransformSpace Space;
    /* 0x0038 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x60
struct FRigUnit_SetControlVector : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ float Weight;
    /* 0x0020 */ FVector Vector;
    /* 0x0038 */ ERigVMTransformSpace Space;
    /* 0x0040 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x50
struct FRigUnit_SetControlVector2D : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0018 */ float Weight;
    /* 0x0020 */ FVector2D Vector;
    /* 0x0030 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x48
struct FRigUnit_SetControlVisibility : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x0020 */ FString pattern;
    /* 0x0030 */ bool bVisible;
    /* 0x0038 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0x40
struct FRigUnit_SetCurveValue : public FRigUnitMutable {
    /* 0x0010 */ FName Curve;
    /* 0x0018 */ float Value;
    /* 0x0020 */ FCachedRigElement CachedCurveIndex;
};

// Size: 0x20
struct FRigUnit_SetDefaultMatch : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Default;
};

// Size: 0x28
struct FRigUnit_SetDefaultParent : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ FRigElementKey Parent;
};

// Size: 0x40
struct FRigUnit_SetFloatAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ float Value;
};

// Size: 0x28
struct FRigUnit_SetFloatAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ float Value;
};

// Size: 0x40
struct FRigUnit_SetIntAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ int32_t Value;
};

// Size: 0x28
struct FRigUnit_SetIntAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ int32_t Value;
};

// Size: 0x48
struct FRigUnit_SetMetadataTag : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ FName Tag;
    /* 0x0024 */ ERigMetaDataNameSpace Namespace;
    /* 0x0028 */ FCachedRigElement CachedIndex;
};

// Size: 0x58
struct FRigUnit_SetMetadataTagArray : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x0020 */ TArray<FName> Tags;
    /* 0x0030 */ ERigMetaDataNameSpace Namespace;
    /* 0x0038 */ FCachedRigElement CachedIndex;
};

// Size: 0x30
struct FRigUnit_SetMultiControlBool : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigUnit_SetMultiControlBool_Entry> Entries;
    /* 0x0020 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0xc
struct FRigUnit_SetMultiControlBool_Entry {
    /* 0x0000 */ FName Control;
    /* 0x0008 */ bool boolValue;
};

// Size: 0x38
struct FRigUnit_SetMultiControlFloat : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigUnit_SetMultiControlFloat_Entry> Entries;
    /* 0x0020 */ float Weight;
    /* 0x0028 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0xc
struct FRigUnit_SetMultiControlFloat_Entry {
    /* 0x0000 */ FName Control;
    /* 0x0008 */ float FloatValue;
};

// Size: 0x38
struct FRigUnit_SetMultiControlInteger : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigUnit_SetMultiControlInteger_Entry> Entries;
    /* 0x0020 */ float Weight;
    /* 0x0028 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0xc
struct FRigUnit_SetMultiControlInteger_Entry {
    /* 0x0000 */ FName Control;
    /* 0x0008 */ int32_t IntegerValue;
};

// Size: 0x38
struct FRigUnit_SetMultiControlRotator : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigUnit_SetMultiControlRotator_Entry> Entries;
    /* 0x0020 */ float Weight;
    /* 0x0028 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0x28
struct FRigUnit_SetMultiControlRotator_Entry {
    /* 0x0000 */ FName Control;
    /* 0x0008 */ FRotator Rotator;
    /* 0x0020 */ ERigVMTransformSpace Space;
};

// Size: 0x38
struct FRigUnit_SetMultiControlVector2D : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigUnit_SetMultiControlVector2D_Entry> Entries;
    /* 0x0020 */ float Weight;
    /* 0x0028 */ TArray<FCachedRigElement> CachedControlIndices;
};

// Size: 0x18
struct FRigUnit_SetMultiControlVector2D_Entry {
    /* 0x0000 */ FName Control;
    /* 0x0008 */ FVector2D Vector;
};

// Size: 0xd0
struct FRigUnit_SetRelativeBoneTransform : public FRigUnitMutable {
    /* 0x0010 */ FName bone;
    /* 0x0018 */ FName Space;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ float Weight;
    /* 0x0084 */ bool bPropagateToChildren;
    /* 0x0088 */ FCachedRigElement CachedBone;
    /* 0x00a8 */ FCachedRigElement CachedSpaceIndex;
};

// Size: 0xa0
struct FRigUnit_SetRelativeRotationForItem : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ FRigElementKey Parent;
    /* 0x0028 */ bool bParentInitial;
    /* 0x0030 */ FQuat Value;
    /* 0x0050 */ float Weight;
    /* 0x0054 */ bool bPropagateToChildren;
    /* 0x0058 */ FCachedRigElement CachedChild;
    /* 0x0078 */ FCachedRigElement CachedParent;
};

// Size: 0xe0
struct FRigUnit_SetRelativeTransformForItem : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ FRigElementKey Parent;
    /* 0x0028 */ bool bParentInitial;
    /* 0x0030 */ FTransform Value;
    /* 0x0090 */ float Weight;
    /* 0x0094 */ bool bPropagateToChildren;
    /* 0x0098 */ FCachedRigElement CachedChild;
    /* 0x00b8 */ FCachedRigElement CachedParent;
};

// Size: 0x90
struct FRigUnit_SetRelativeTranslationForItem : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Child;
    /* 0x001c */ FRigElementKey Parent;
    /* 0x0028 */ bool bParentInitial;
    /* 0x0030 */ FVector Value;
    /* 0x0048 */ float Weight;
    /* 0x004c */ bool bPropagateToChildren;
    /* 0x0050 */ FCachedRigElement CachedChild;
    /* 0x0070 */ FCachedRigElement CachedParent;
};

// Size: 0x70
struct FRigUnit_SetRotation : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ERigVMTransformSpace Space;
    /* 0x001d */ bool bInitial;
    /* 0x0020 */ FQuat Value;
    /* 0x0040 */ float Weight;
    /* 0x0044 */ bool bPropagateToChildren;
    /* 0x0048 */ FCachedRigElement CachedIndex;
};

// Size: 0x50
struct FRigUnit_SetRotatorAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ FRotator Value;
};

// Size: 0x38
struct FRigUnit_SetRotatorAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ FRotator Value;
};

// Size: 0x60
struct FRigUnit_SetScale : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ERigVMTransformSpace Space;
    /* 0x001d */ bool bInitial;
    /* 0x0020 */ FVector Scale;
    /* 0x0038 */ float Weight;
    /* 0x003c */ bool bPropagateToChildren;
    /* 0x0040 */ FCachedRigElement CachedIndex;
};

// Size: 0xa0
struct FRigUnit_SetShapeTransform : public FRigUnitMutable {
    /* 0x0010 */ FName Control;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FCachedRigElement CachedControlIndex;
};

// Size: 0x110
struct FRigUnit_SetSpaceInitialTransform : public FRigUnitMutable {
    /* 0x0010 */ FName SpaceName;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FTransform Result;
    /* 0x00e0 */ ERigVMTransformSpace Space;
    /* 0x00e8 */ FCachedRigElement CachedSpaceIndex;
};

// Size: 0xb0
struct FRigUnit_SetSpaceTransform : public FRigUnitMutable {
    /* 0x0010 */ FName Space;
    /* 0x0018 */ float Weight;
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ ERigVMTransformSpace SpaceType;
    /* 0x0088 */ FCachedRigElement CachedSpaceIndex;
};

// Size: 0xb0
struct FRigUnit_SetTransform : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ERigVMTransformSpace Space;
    /* 0x001d */ bool bInitial;
    /* 0x0020 */ FTransform Value;
    /* 0x0080 */ float Weight;
    /* 0x0084 */ bool bPropagateToChildren;
    /* 0x0088 */ FCachedRigElement CachedIndex;
};

// Size: 0xa0
struct FRigUnit_SetTransformAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0040 */ FTransform Value;
};

// Size: 0x80
struct FRigUnit_SetTransformAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ FTransform Value;
};

// Size: 0x50
struct FRigUnit_SetTransformArray : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ ERigVMTransformSpace Space;
    /* 0x0021 */ bool bInitial;
    /* 0x0028 */ TArray<FTransform> Transforms;
    /* 0x0038 */ float Weight;
    /* 0x003c */ bool bPropagateToChildren;
    /* 0x0040 */ TArray<FCachedRigElement> CachedIndex;
};

// Size: 0x50
struct FRigUnit_SetTransformItemArray : public FRigUnitMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ ERigVMTransformSpace Space;
    /* 0x0021 */ bool bInitial;
    /* 0x0028 */ TArray<FTransform> Transforms;
    /* 0x0038 */ float Weight;
    /* 0x003c */ bool bPropagateToChildren;
    /* 0x0040 */ TArray<FCachedRigElement> CachedIndex;
};

// Size: 0x60
struct FRigUnit_SetTranslation : public FRigUnitMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ERigVMTransformSpace Space;
    /* 0x001d */ bool bInitial;
    /* 0x0020 */ FVector Value;
    /* 0x0038 */ float Weight;
    /* 0x003c */ bool bPropagateToChildren;
    /* 0x0040 */ FCachedRigElement CachedIndex;
};

// Size: 0x48
struct FRigUnit_SetVector2DAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ FVector2D Value;
};

// Size: 0x30
struct FRigUnit_SetVector2DAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ FVector2D Value;
};

// Size: 0x50
struct FRigUnit_SetVectorAnimationChannel : public FRigUnit_SetAnimationChannelBase {
    /* 0x0038 */ FVector Value;
};

// Size: 0x38
struct FRigUnit_SetVectorAnimationChannelFromItem : public FRigUnit_SetAnimationChannelBaseFromItem {
    /* 0x0020 */ FVector Value;
};

// Size: 0x48
struct FRigUnit_SetupShapeLibraryFromUserData : public FRigUnitMutable {
    /* 0x0010 */ FString Namespace;
    /* 0x0020 */ FString Path;
    /* 0x0030 */ FString LibraryName;
    /* 0x0040 */ bool LogShapeLibraries;
};

// Size: 0x18
struct FRigUnit_ShapeExists : public FRigUnit {
    /* 0x0008 */ FName ShapeName;
    /* 0x0010 */ bool Result;
};

// Size: 0x70
struct FRigUnit_SlideChain : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EndBone;
    /* 0x0020 */ float SlideAmount;
    /* 0x0024 */ bool bPropagateToChildren;
    /* 0x0028 */ FRigUnit_SlideChain_WorkData WorkData;
};

// Size: 0x70
struct FRigUnit_SlideChainItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ float SlideAmount;
    /* 0x0024 */ bool bPropagateToChildren;
    /* 0x0028 */ FRigUnit_SlideChain_WorkData WorkData;
};

// Size: 0x70
struct FRigUnit_SlideChainPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ float SlideAmount;
    /* 0x0024 */ bool bPropagateToChildren;
    /* 0x0028 */ FRigUnit_SlideChain_WorkData WorkData;
};

// Size: 0x48
struct FRigUnit_SlideChain_WorkData {
    /* 0x0000 */ float ChainLength;
    /* 0x0008 */ TArray<float> ItemSegments;
    /* 0x0018 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0028 */ TArray<FTransform> Transforms;
    /* 0x0038 */ TArray<FTransform> BlendedTransforms;
};

// Size: 0x10
struct FRigUnit_SpaceName : public FRigUnit {
    /* 0x0008 */ FName Space;
};

// Size: 0xb8
struct FRigUnit_SphereTraceByObjectTypes : public FRigUnit {
    /* 0x0008 */ FVector Start;
    /* 0x0020 */ FVector End;
    /* 0x0038 */ TArray<uint8_t> ObjectTypes;
    /* 0x0048 */ float Radius;
    /* 0x004c */ bool bHit;
    /* 0x0050 */ FVector HitLocation;
    /* 0x0068 */ FVector HitNormal;
    /* 0x0080 */ FRigUnit_SphereTrace_WorkData WorkData;
};

// Size: 0xb0
struct FRigUnit_SphereTraceByTraceChannel : public FRigUnit {
    /* 0x0008 */ FVector Start;
    /* 0x0020 */ FVector End;
    /* 0x0038 */ uint8_t TraceChannel;
    /* 0x003c */ float Radius;
    /* 0x0040 */ bool bHit;
    /* 0x0048 */ FVector HitLocation;
    /* 0x0060 */ FVector HitNormal;
    /* 0x0078 */ FRigUnit_SphereTrace_WorkData WorkData;
};

// Size: 0xb0
struct FRigUnit_SphereTraceWorld : public FRigUnit {
    /* 0x0008 */ FVector Start;
    /* 0x0020 */ FVector End;
    /* 0x0038 */ uint8_t Channel;
    /* 0x003c */ float Radius;
    /* 0x0040 */ bool bHit;
    /* 0x0048 */ FVector HitLocation;
    /* 0x0060 */ FVector HitNormal;
    /* 0x0078 */ FRigUnit_SphereTrace_WorkData WorkData;
};

// Size: 0x38
struct FRigUnit_SphereTrace_WorkData {
    /* 0x0000 */ uint32_t Hash;
    /* 0x0004 */ bool bHit;
    /* 0x0008 */ FVector HitLocation;
    /* 0x0020 */ FVector HitNormal;
};

// Size: 0x1b0
struct FRigUnit_SphericalPoseReader : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ float OutputParam;
    /* 0x0014 */ FRigElementKey DriverItem;
    /* 0x0020 */ FVector DriverAxis;
    /* 0x0038 */ FVector RotationOffset;
    /* 0x0050 */ float ActiveRegionSize;
    /* 0x0054 */ FRegionScaleFactors ActiveRegionScaleFactors;
    /* 0x0064 */ float FalloffSize;
    /* 0x0068 */ FRegionScaleFactors FalloffRegionScaleFactors;
    /* 0x0078 */ bool FlipWidthScaling;
    /* 0x0079 */ bool FlipHeightScaling;
    /* 0x007c */ FRigElementKey OptionalParentItem;
    /* 0x0088 */ FSphericalPoseReaderDebugSettings Debug;
    /* 0x0098 */ FSphericalRegion InnerRegion;
    /* 0x00ac */ FSphericalRegion OuterRegion;
    /* 0x00c0 */ FVector DriverNormal;
    /* 0x00d8 */ FVector Driver2D;
    /* 0x00f0 */ FCachedRigElement DriverCache;
    /* 0x0110 */ FCachedRigElement OptionalParentCache;
    /* 0x0130 */ FTransform LocalDriverTransformInit;
    /* 0x0190 */ FVector CachedRotationOffset;
    /* 0x01a8 */ bool bCachedInitTransforms;
};

// Size: 0x1e0
struct FRigUnit_SpringIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EndBone;
    /* 0x0020 */ float HierarchyStrength;
    /* 0x0024 */ float EffectorStrength;
    /* 0x0028 */ float EffectorRatio;
    /* 0x002c */ float RootStrength;
    /* 0x0030 */ float RootRatio;
    /* 0x0034 */ float Damping;
    /* 0x0038 */ FVector PoleVector;
    /* 0x0050 */ bool bFlipPolePlane;
    /* 0x0051 */ EControlRigVectorKind PoleVectorKind;
    /* 0x0054 */ FName PoleVectorSpace;
    /* 0x0060 */ FVector PrimaryAxis;
    /* 0x0078 */ FVector SecondaryAxis;
    /* 0x0090 */ bool bLiveSimulation;
    /* 0x0094 */ int32_t Iterations;
    /* 0x0098 */ bool bLimitLocalPosition;
    /* 0x0099 */ bool bPropagateToChildren;
    /* 0x00a0 */ FRigUnit_SpringIK_DebugSettings DebugSettings;
    /* 0x0120 */ FRigUnit_SpringIK_WorkData WorkData;
};

// Size: 0x80
struct FRigUnit_SpringIK_DebugSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Scale;
    /* 0x0008 */ FLinearColor Color;
    /* 0x0020 */ FTransform worldOffset;
};

// Size: 0xb8
struct FRigUnit_SpringIK_WorkData {
    /* 0x0000 */ TArray<FCachedRigElement> CachedBones;
    /* 0x0010 */ FCachedRigElement CachedPoleVector;
    /* 0x0030 */ TArray<FTransform> Transforms;
    /* 0x0040 */ FCRSimPointContainer Simulation;
};

// Size: 0x30
struct FRigUnit_SpringInterp : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Current;
    /* 0x000c */ float Target;
    /* 0x0010 */ float Stiffness;
    /* 0x0014 */ float CriticalDamping;
    /* 0x0018 */ float Mass;
    /* 0x001c */ float Result;
    /* 0x0020 */ FFloatSpringState SpringState;
};

// Size: 0x130
struct FRigUnit_SpringInterpQuaternionV2 : public FRigVMFunction_SimBase {
    /* 0x0010 */ FQuat Target;
    /* 0x0030 */ float Strength;
    /* 0x0034 */ float CriticalDamping;
    /* 0x0038 */ FVector Torque;
    /* 0x0050 */ bool bUseCurrentInput;
    /* 0x0060 */ FQuat Current;
    /* 0x0080 */ float TargetVelocityAmount;
    /* 0x0084 */ bool bInitializeFromTarget;
    /* 0x0090 */ FQuat Result;
    /* 0x00b0 */ FVector AngularVelocity;
    /* 0x00d0 */ FQuat SimulatedResult;
    /* 0x00f0 */ FQuaternionSpringState SpringState;
};

// Size: 0x40
struct FRigUnit_SpringInterpV2 : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Target;
    /* 0x000c */ float Strength;
    /* 0x0010 */ float CriticalDamping;
    /* 0x0014 */ float Force;
    /* 0x0018 */ bool bUseCurrentInput;
    /* 0x001c */ float Current;
    /* 0x0020 */ float TargetVelocityAmount;
    /* 0x0024 */ bool bInitializeFromTarget;
    /* 0x0028 */ float Result;
    /* 0x002c */ float Velocity;
    /* 0x0030 */ float SimulatedResult;
    /* 0x0034 */ FFloatSpringState SpringState;
};

// Size: 0x98
struct FRigUnit_SpringInterpVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Current;
    /* 0x0020 */ FVector Target;
    /* 0x0038 */ float Stiffness;
    /* 0x003c */ float CriticalDamping;
    /* 0x0040 */ float Mass;
    /* 0x0048 */ FVector Result;
    /* 0x0060 */ FVectorSpringState SpringState;
};

// Size: 0xe8
struct FRigUnit_SpringInterpVectorV2 : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Target;
    /* 0x0020 */ float Strength;
    /* 0x0024 */ float CriticalDamping;
    /* 0x0028 */ FVector Force;
    /* 0x0040 */ bool bUseCurrentInput;
    /* 0x0048 */ FVector Current;
    /* 0x0060 */ float TargetVelocityAmount;
    /* 0x0064 */ bool bInitializeFromTarget;
    /* 0x0068 */ FVector Result;
    /* 0x0080 */ FVector Velocity;
    /* 0x0098 */ FVector SimulatedResult;
    /* 0x00b0 */ FVectorSpringState SpringState;
};

// Size: 0x18
struct FRigUnit_StartProfilingTimer : public FRigVMFunction_DebugBaseMutable {
};

// Size: 0x18
struct FRigUnit_Subtract_FloatFloat : public FRigUnit_BinaryFloatOp {
};

// Size: 0x50
struct FRigUnit_Subtract_VectorVector : public FRigUnit_BinaryVectorOp {
};

// Size: 0x30
struct FRigUnit_SwitchParent : public FRigUnit_DynamicHierarchyBaseMutable {
    /* 0x0010 */ ERigSwitchParentMode Mode;
    /* 0x0014 */ FRigElementKey Child;
    /* 0x0020 */ FRigElementKey Parent;
    /* 0x002c */ bool bMaintainGlobal;
};

// Size: 0x38
struct FRigUnit_ToRigSpace_Location : public FRigUnit {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Global;
};

// Size: 0x50
struct FRigUnit_ToRigSpace_Rotation : public FRigUnit {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FQuat Global;
};

// Size: 0xd0
struct FRigUnit_ToRigSpace_Transform : public FRigUnit {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FTransform Global;
};

// Size: 0x90
struct FRigUnit_ToSwingAndTwist : public FRigUnit {
    /* 0x0010 */ FQuat Input;
    /* 0x0030 */ FVector TwistAxis;
    /* 0x0050 */ FQuat Swing;
    /* 0x0070 */ FQuat Twist;
};

// Size: 0x38
struct FRigUnit_ToWorldSpace_Location : public FRigUnit {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector World;
};

// Size: 0x50
struct FRigUnit_ToWorldSpace_Rotation : public FRigUnit {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FQuat World;
};

// Size: 0xd0
struct FRigUnit_ToWorldSpace_Transform : public FRigUnit {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FTransform World;
};

// Size: 0x100
struct FRigUnit_TransformConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName bone;
    /* 0x0018 */ ETransformSpaceMode BaseTransformSpace;
    /* 0x0020 */ FTransform BaseTransform;
    /* 0x0080 */ FName BaseBone;
    /* 0x0088 */ TArray<FConstraintTarget> Targets;
    /* 0x0098 */ bool bUseInitialTransforms;
    /* 0x00a0 */ FRigUnit_TransformConstraint_WorkData WorkData;
};

// Size: 0x110
struct FRigUnit_TransformConstraintPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Item;
    /* 0x001c */ ETransformSpaceMode BaseTransformSpace;
    /* 0x0020 */ FTransform BaseTransform;
    /* 0x0080 */ FRigElementKey BaseItem;
    /* 0x0090 */ TArray<FConstraintTarget> Targets;
    /* 0x00a0 */ bool bUseInitialTransforms;
    /* 0x00a8 */ FRigUnit_TransformConstraint_WorkData WorkData;
};

// Size: 0x60
struct FRigUnit_TransformConstraint_WorkData {
    /* 0x0000 */ TArray<FConstraintData> ConstraintData;
    /* 0x0010 */ TMap<int32_t, int32_t> ConstraintDataToTargets;
};

// Size: 0x90
struct FRigUnit_TwistBones : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName StartBone;
    /* 0x0018 */ FName EndBone;
    /* 0x0020 */ FVector TwistAxis;
    /* 0x0038 */ FVector PoleAxis;
    /* 0x0050 */ ERigVMAnimEasingType TwistEaseType;
    /* 0x0054 */ float Weight;
    /* 0x0058 */ bool bPropagateToChildren;
    /* 0x0060 */ FRigUnit_TwistBones_WorkData WorkData;
};

// Size: 0x90
struct FRigUnit_TwistBonesPerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FVector TwistAxis;
    /* 0x0038 */ FVector PoleAxis;
    /* 0x0050 */ ERigVMAnimEasingType TwistEaseType;
    /* 0x0054 */ float Weight;
    /* 0x0058 */ bool bPropagateToChildren;
    /* 0x0060 */ FRigUnit_TwistBones_WorkData WorkData;
};

// Size: 0x30
struct FRigUnit_TwistBones_WorkData {
    /* 0x0000 */ TArray<FCachedRigElement> CachedItems;
    /* 0x0010 */ TArray<float> ItemRatios;
    /* 0x0020 */ TArray<FTransform> ItemTransforms;
};

// Size: 0x320
struct FRigUnit_TwoBoneIKFK : public FRigUnitMutable {
    /* 0x0010 */ FName StartJoint;
    /* 0x0018 */ FName EndJoint;
    /* 0x0020 */ FVector PoleTarget;
    /* 0x0038 */ float Spin;
    /* 0x0040 */ FTransform EndEffector;
    /* 0x00a0 */ float IKBlend;
    /* 0x00b0 */ FTransform StartJointFKTransform;
    /* 0x0110 */ FTransform MidJointFKTransform;
    /* 0x0170 */ FTransform EndJointFKTransform;
    /* 0x01d0 */ float PreviousFKIKBlend;
    /* 0x01e0 */ FTransform StartJointIKTransform;
    /* 0x0240 */ FTransform MidJointIKTransform;
    /* 0x02a0 */ FTransform EndJointIKTransform;
    /* 0x0300 */ int32_t StartJointIndex;
    /* 0x0304 */ int32_t MidJointIndex;
    /* 0x0308 */ int32_t EndJointIndex;
    /* 0x030c */ float UpperLimbLength;
    /* 0x0310 */ float LowerLimbLength;
    /* 0x0314 */ bool bIsInitialized;
};

// Size: 0x200
struct FRigUnit_TwoBoneIKSimple : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName BoneA;
    /* 0x0018 */ FName BoneB;
    /* 0x0020 */ FName EffectorBone;
    /* 0x0030 */ FTransform Effector;
    /* 0x0090 */ FVector PrimaryAxis;
    /* 0x00a8 */ FVector SecondaryAxis;
    /* 0x00c0 */ float SecondaryAxisWeight;
    /* 0x00c8 */ FVector PoleVector;
    /* 0x00e0 */ EControlRigVectorKind PoleVectorKind;
    /* 0x00e4 */ FName PoleVectorSpace;
    /* 0x00ec */ bool bEnableStretch;
    /* 0x00f0 */ float StretchStartRatio;
    /* 0x00f4 */ float StretchMaximumRatio;
    /* 0x00f8 */ float Weight;
    /* 0x00fc */ float BoneALength;
    /* 0x0100 */ float BoneBLength;
    /* 0x0104 */ bool bPropagateToChildren;
    /* 0x0110 */ FRigUnit_TwoBoneIKSimple_DebugSettings DebugSettings;
    /* 0x0180 */ FCachedRigElement CachedBoneAIndex;
    /* 0x01a0 */ FCachedRigElement CachedBoneBIndex;
    /* 0x01c0 */ FCachedRigElement CachedEffectorBoneIndex;
    /* 0x01e0 */ FCachedRigElement CachedPoleVectorSpaceIndex;
};

// Size: 0x210
struct FRigUnit_TwoBoneIKSimplePerItem : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey ItemA;
    /* 0x001c */ FRigElementKey ItemB;
    /* 0x0028 */ FRigElementKey EffectorItem;
    /* 0x0040 */ FTransform Effector;
    /* 0x00a0 */ FVector PrimaryAxis;
    /* 0x00b8 */ FVector SecondaryAxis;
    /* 0x00d0 */ float SecondaryAxisWeight;
    /* 0x00d8 */ FVector PoleVector;
    /* 0x00f0 */ EControlRigVectorKind PoleVectorKind;
    /* 0x00f4 */ FRigElementKey PoleVectorSpace;
    /* 0x0100 */ bool bEnableStretch;
    /* 0x0104 */ float StretchStartRatio;
    /* 0x0108 */ float StretchMaximumRatio;
    /* 0x010c */ float Weight;
    /* 0x0110 */ float ItemALength;
    /* 0x0114 */ float ItemBLength;
    /* 0x0118 */ bool bPropagateToChildren;
    /* 0x0120 */ FRigUnit_TwoBoneIKSimple_DebugSettings DebugSettings;
    /* 0x0190 */ FCachedRigElement CachedItemAIndex;
    /* 0x01b0 */ FCachedRigElement CachedItemBIndex;
    /* 0x01d0 */ FCachedRigElement CachedEffectorItemIndex;
    /* 0x01f0 */ FCachedRigElement CachedPoleVectorSpaceIndex;
};

// Size: 0x1a0
struct FRigUnit_TwoBoneIKSimpleTransforms : public FRigUnit_HighlevelBase {
    /* 0x0010 */ FTransform Root;
    /* 0x0070 */ FVector PoleVector;
    /* 0x0090 */ FTransform Effector;
    /* 0x00f0 */ FVector PrimaryAxis;
    /* 0x0108 */ FVector SecondaryAxis;
    /* 0x0120 */ float SecondaryAxisWeight;
    /* 0x0124 */ bool bEnableStretch;
    /* 0x0128 */ float StretchStartRatio;
    /* 0x012c */ float StretchMaximumRatio;
    /* 0x0130 */ float BoneALength;
    /* 0x0134 */ float BoneBLength;
    /* 0x0140 */ FTransform Elbow;
};

// Size: 0x80
struct FRigUnit_TwoBoneIKSimpleVectors : public FRigUnit_HighlevelBase {
    /* 0x0008 */ FVector Root;
    /* 0x0020 */ FVector PoleVector;
    /* 0x0038 */ FVector Effector;
    /* 0x0050 */ bool bEnableStretch;
    /* 0x0054 */ float StretchStartRatio;
    /* 0x0058 */ float StretchMaximumRatio;
    /* 0x005c */ float BoneALength;
    /* 0x0060 */ float BoneBLength;
    /* 0x0068 */ FVector Elbow;
};

// Size: 0x70
struct FRigUnit_TwoBoneIKSimple_DebugSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float Scale;
    /* 0x0010 */ FTransform worldOffset;
};

// Size: 0x50
struct FRigUnit_UnaryQuaternionOp : public FRigUnit {
    /* 0x0010 */ FQuat argument;
    /* 0x0030 */ FQuat Result;
};

// Size: 0x38
struct FRigUnit_UnsetCurveValue : public FRigUnitMutable {
    /* 0x0010 */ FName Curve;
    /* 0x0018 */ FCachedRigElement CachedCurveIndex;
};

// Size: 0x50
struct FRigUnit_VisualDebugQuat : public FRigUnit_DebugBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ bool bEnabled;
    /* 0x0034 */ float Thickness;
    /* 0x0038 */ float Scale;
    /* 0x003c */ FName BoneSpace;
};

// Size: 0x50
struct FRigUnit_VisualDebugQuatItemSpace : public FRigUnit_DebugBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ bool bEnabled;
    /* 0x0034 */ float Thickness;
    /* 0x0038 */ float Scale;
    /* 0x003c */ FRigElementKey Space;
};

// Size: 0x90
struct FRigUnit_VisualDebugTransform : public FRigUnit_DebugBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ bool bEnabled;
    /* 0x0074 */ float Thickness;
    /* 0x0078 */ float Scale;
    /* 0x007c */ FName BoneSpace;
};

// Size: 0x90
struct FRigUnit_VisualDebugTransformItemSpace : public FRigUnit_DebugBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ bool bEnabled;
    /* 0x0074 */ float Thickness;
    /* 0x0078 */ float Scale;
    /* 0x007c */ FRigElementKey Space;
};

// Size: 0x50
struct FRigUnit_VisualDebugVector : public FRigUnit_DebugBase {
    /* 0x0010 */ FVector Value;
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ ERigUnitVisualDebugPointMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ float Scale;
    /* 0x0044 */ FName BoneSpace;
};

// Size: 0x50
struct FRigUnit_VisualDebugVectorItemSpace : public FRigUnit_DebugBase {
    /* 0x0010 */ FVector Value;
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ ERigUnitVisualDebugPointMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ float Scale;
    /* 0x0044 */ FRigElementKey Space;
};

// Size: 0x30
struct FRigVectorArrayMetadata : public FRigBaseMetadata {
    /* 0x0020 */ TArray<FVector> Value;
};

// Size: 0x38
struct FRigVectorMetadata : public FRigBaseMetadata {
    /* 0x0020 */ FVector Value;
};

// Size: 0x10
struct FSampleTrackHost {
};

// Size: 0x30
struct FSampleTrackMemoryData {
    /* 0x0000 */ TArray<uint8_t> Buffer;
    /* 0x0010 */ TArray<FName> Names;
    /* 0x0020 */ TArray<FString> ObjectPaths;
};

// Size: 0x118
struct FSpaceControlNameAndChannel {
    /* 0x0000 */ FName ControlName;
    /* 0x0008 */ FMovieSceneControlRigSpaceChannel SpaceCurve;
};

// Size: 0x10
struct FSphericalPoseReaderDebugSettings {
    /* 0x0000 */ bool bDrawDebug;
    /* 0x0001 */ bool bDraw2D;
    /* 0x0002 */ bool bDrawLocalAxes;
    /* 0x0004 */ float DebugScale;
    /* 0x0008 */ int32_t DebugSegments;
    /* 0x000c */ float DebugThickness;
};

// Size: 0x14
struct FSphericalRegion {
};

// Size: 0x8
struct FStructReference {
};

// Size: 0x140
class UTransformableControlHandle : public UTransformableHandle {
    /* 0x0060 */ TSoftObjectPtr<UControlRig> ControlRig;
    /* 0x0088 */ FName ControlName;
};

// Size: 0x18
struct FControlRigSpline {
};

// Size: 0x68
struct FControlRigSplineImpl {
};

enum class ESplineType {
    BSpline = 0,
    Hermite = 1,
    Max = 2,
};

// Size: 0x40
struct FRigUnit_ClosestParameterFromControlRigSpline : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ FVector position;
    /* 0x0038 */ float U;
};

// Size: 0x8
struct FRigUnit_ControlRigSplineBase : public FRigUnit {
};

// Size: 0x40
struct FRigUnit_ControlRigSplineFromPoints : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ TArray<FVector> points;
    /* 0x0018 */ ESplineType SplineMode;
    /* 0x0019 */ bool bClosed;
    /* 0x001c */ int32_t SamplesPerSegment;
    /* 0x0020 */ float Compression;
    /* 0x0024 */ float Stretch;
    /* 0x0028 */ FControlRigSpline Spline;
};

// Size: 0x40
struct FRigUnit_ControlRigSplineFromTransforms : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ TArray<FTransform> Transforms;
    /* 0x0018 */ ESplineType SplineMode;
    /* 0x0019 */ bool bClosed;
    /* 0x001c */ int32_t SamplesPerSegment;
    /* 0x0020 */ float Compression;
    /* 0x0024 */ float Stretch;
    /* 0x0028 */ FControlRigSpline Spline;
};

// Size: 0x40
struct FRigUnit_DrawControlRigSpline : public FRigUnitMutable {
    /* 0x0010 */ FControlRigSpline Spline;
    /* 0x0028 */ FLinearColor Color;
    /* 0x0038 */ float Thickness;
    /* 0x003c */ int32_t Detail;
};

// Size: 0x1e0
struct FRigUnit_FitChainToSplineCurve : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FControlRigSpline Spline;
    /* 0x0038 */ EControlRigCurveAlignment Alignment;
    /* 0x003c */ float Minimum;
    /* 0x0040 */ float Maximum;
    /* 0x0044 */ int32_t SamplingPrecision;
    /* 0x0048 */ FVector PrimaryAxis;
    /* 0x0060 */ FVector SecondaryAxis;
    /* 0x0078 */ FVector PoleVectorPosition;
    /* 0x0090 */ TArray<FRigUnit_FitChainToCurve_Rotation> Rotations;
    /* 0x00a0 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x00a4 */ float Weight;
    /* 0x00a8 */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_FitChainToCurve_DebugSettings DebugSettings;
    /* 0x0140 */ FRigUnit_FitChainToCurve_WorkData WorkData;
};

// Size: 0x1e0
struct FRigUnit_FitChainToSplineCurveItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FControlRigSpline Spline;
    /* 0x0038 */ EControlRigCurveAlignment Alignment;
    /* 0x003c */ float Minimum;
    /* 0x0040 */ float Maximum;
    /* 0x0044 */ int32_t SamplingPrecision;
    /* 0x0048 */ FVector PrimaryAxis;
    /* 0x0060 */ FVector SecondaryAxis;
    /* 0x0078 */ FVector PoleVectorPosition;
    /* 0x0090 */ TArray<FRigUnit_FitChainToCurve_Rotation> Rotations;
    /* 0x00a0 */ ERigVMAnimEasingType RotationEaseType;
    /* 0x00a4 */ float Weight;
    /* 0x00a8 */ bool bPropagateToChildren;
    /* 0x00b0 */ FRigUnit_FitChainToCurve_DebugSettings DebugSettings;
    /* 0x0140 */ FRigUnit_FitChainToCurve_WorkData WorkData;
};

// Size: 0x38
struct FRigUnit_FitSplineCurveToChain : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKeyCollection Items;
    /* 0x0020 */ FControlRigSpline Spline;
};

// Size: 0x38
struct FRigUnit_FitSplineCurveToChainItemArray : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FControlRigSpline Spline;
};

// Size: 0x28
struct FRigUnit_GetLengthAtParamControlRigSpline : public FRigUnit {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float U;
    /* 0x0024 */ float Length;
};

// Size: 0x28
struct FRigUnit_GetLengthControlRigSpline : public FRigUnit {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float Length;
};

// Size: 0x28
struct FRigUnit_ParameterAtPercentage : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float Percentage;
    /* 0x0024 */ float U;
};

// Size: 0x40
struct FRigUnit_PositionFromControlRigSpline : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float U;
    /* 0x0028 */ FVector position;
};

// Size: 0x38
struct FRigUnit_SetSplinePoints : public FRigUnitMutable {
    /* 0x0010 */ TArray<FVector> points;
    /* 0x0020 */ FControlRigSpline Spline;
};

// Size: 0x38
struct FRigUnit_SetSplineTransforms : public FRigUnitMutable {
    /* 0x0010 */ TArray<FTransform> Transforms;
    /* 0x0020 */ FControlRigSpline Spline;
};

// Size: 0xb8
struct FRigUnit_SplineConstraint : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ TArray<FRigElementKey> Items;
    /* 0x0020 */ FControlRigSpline Spline;
    /* 0x0038 */ EControlRigCurveAlignment Alignment;
    /* 0x003c */ float Minimum;
    /* 0x0040 */ float Maximum;
    /* 0x0048 */ FVector PrimaryAxis;
    /* 0x0060 */ FVector SecondaryAxis;
    /* 0x0078 */ bool bPropagateToChildren;
    /* 0x0080 */ FRigUnit_SplineConstraint_WorkData WorkData;
};

// Size: 0x38
struct FRigUnit_SplineConstraint_WorkData {
    /* 0x0000 */ float ChainLength;
    /* 0x0008 */ TArray<FTransform> ItemTransforms;
    /* 0x0018 */ TArray<float> ItemSegments;
    /* 0x0028 */ TArray<FCachedRigElement> CachedItems;
};

// Size: 0x40
struct FRigUnit_TangentFromControlRigSpline : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float U;
    /* 0x0028 */ FVector Tangent;
};

// Size: 0xa0
struct FRigUnit_TransformFromControlRigSpline : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ FVector UpVector;
    /* 0x0038 */ float Roll;
    /* 0x003c */ float U;
    /* 0x0040 */ FTransform Transform;
};

// Size: 0xc0
struct FRigUnit_TransformFromControlRigSpline2 : public FRigUnit_ControlRigSplineBase {
    /* 0x0008 */ FControlRigSpline Spline;
    /* 0x0020 */ float U;
    /* 0x0028 */ FVector PrimaryAxis;
    /* 0x0040 */ FVector SecondaryAxis;
    /* 0x0060 */ FTransform Transform;
};

enum class ECoreOnlineDummy {
    Dummy = 0,
    ECoreOnlineDummy_MAX = 1,
};

// Size: 0x14
struct FJoinabilitySettings {
    /* 0x0000 */ FName SessionName;
    /* 0x0008 */ bool bPublicSearchable;
    /* 0x0009 */ bool bAllowInvites;
    /* 0x000a */ bool bJoinViaPresence;
    /* 0x000b */ bool bJoinViaPresenceFriendsOnly;
    /* 0x000c */ int32_t MaxPlayers;
    /* 0x0010 */ int32_t MaxPartySize;
};

// Size: 0x1
struct FUniqueNetIdWrapper {
};

// Size: 0x150
struct FARFilter {
    /* 0x0000 */ TArray<FName> PackageNames;
    /* 0x0010 */ TArray<FName> PackagePaths;
    /* 0x0020 */ TArray<FSoftObjectPath> SoftObjectPaths;
    /* 0x0030 */ TArray<FName> ClassNames;
    /* 0x0040 */ TArray<FTopLevelAssetPath> ClassPaths;
    /* 0x00a0 */ TSet<FName> RecursiveClassesExclusionSet;
    /* 0x00f0 */ TSet<FTopLevelAssetPath> RecursiveClassPathsExclusionSet;
    /* 0x0140 */ bool bRecursivePaths;
    /* 0x0141 */ bool bRecursiveClasses;
    /* 0x0142 */ bool bIncludeOnlyOnDiskAssets;
};

// Size: 0x78
class UArrayProperty : public UProperty {
};

// Size: 0x10
struct FAssetBundleData {
    /* 0x0000 */ TArray<FAssetBundleEntry> Bundles;
};

// Size: 0x18
struct FAssetBundleEntry {
    /* 0x0000 */ FName BundleName;
    /* 0x0008 */ TArray<FTopLevelAssetPath> AssetPaths;
};

// Size: 0x68
struct FAssetData {
    /* 0x0000 */ FName PackageName;
    /* 0x0008 */ FName PackagePath;
    /* 0x0010 */ FName AssetName;
    /* 0x0018 */ FName AssetClass;
    /* 0x0020 */ FTopLevelAssetPath AssetClassPath;
};

// Size: 0x38
struct FAutomationEvent {
    /* 0x0000 */ EAutomationEventType Type;
    /* 0x0008 */ FString Message;
    /* 0x0018 */ FString Context;
    /* 0x0028 */ FGuid Artifact;
};

// Size: 0x58
struct FAutomationExecutionEntry {
    /* 0x0000 */ FAutomationEvent Event;
    /* 0x0038 */ FString Filename;
    /* 0x0048 */ int32_t LineNumber;
    /* 0x0050 */ FDateTime Timestamp;
};

// Size: 0x78
class UBoolProperty : public UProperty {
};

// Size: 0x38
struct FBox {
    /* 0x0000 */ FVector min;
    /* 0x0018 */ FVector max;
    /* 0x0030 */ bool IsValid;
};

// Size: 0x28
struct FBox2D {
    /* 0x0000 */ FVector2D min;
    /* 0x0010 */ FVector2D max;
    /* 0x0020 */ bool bIsValid;
};

// Size: 0x14
struct FBox2f {
    /* 0x0000 */ FVector2f min;
    /* 0x0008 */ FVector2f max;
    /* 0x0010 */ bool bIsValid;
};

// Size: 0x38
struct FBox3d {
    /* 0x0000 */ FVector3d min;
    /* 0x0018 */ FVector3d max;
    /* 0x0030 */ bool IsValid;
};

// Size: 0x1c
struct FBox3f {
    /* 0x0000 */ FVector3f min;
    /* 0x000c */ FVector3f max;
    /* 0x0018 */ bool IsValid;
};

// Size: 0x38
struct FBoxSphereBounds {
    /* 0x0000 */ FVector Origin;
    /* 0x0018 */ FVector BoxExtent;
    /* 0x0030 */ double SphereRadius;
};

// Size: 0x38
struct FBoxSphereBounds3d {
    /* 0x0000 */ FVector3d Origin;
    /* 0x0018 */ FVector3d BoxExtent;
    /* 0x0030 */ double SphereRadius;
};

// Size: 0x1c
struct FBoxSphereBounds3f {
    /* 0x0000 */ FVector3f Origin;
    /* 0x000c */ FVector3f BoxExtent;
    /* 0x0018 */ float SphereRadius;
};

// Size: 0x78
class UByteProperty : public UNumericProperty {
};

// Size: 0x200
class UClass : public UStruct {
};

// Size: 0x118
class UClassCookedMetaData : public UObject {
    /* 0x0028 */ FStructCookedMetaDataStore ClassMetaData;
    /* 0x00c8 */ TMap<FName, FStructCookedMetaDataStore> FunctionsMetaData;
};

// Size: 0x80
class UClassProperty : public UObjectProperty {
};

// Size: 0x4
struct FColor {
    /* 0x0000 */ uint8_t B;
    /* 0x0001 */ uint8_t G;
    /* 0x0002 */ uint8_t R;
    /* 0x0003 */ uint8_t A;
};

// Size: 0x10
struct FConstSharedStruct {
};

// Size: 0x8
struct FDateTime {
    /* 0x0000 */ int64_t Ticks;
};

// Size: 0xe0
class UDelegateFunction : public UFunction {
};

// Size: 0x78
class UDelegateProperty : public UProperty {
};

// Size: 0x10
struct FDirectoryPath {
    /* 0x0000 */ FString Path;
};

// Size: 0x70
class UDoubleProperty : public UNumericProperty {
};

// Size: 0x20
struct FDoubleRange {
    /* 0x0000 */ FDoubleRangeBound LowerBound;
    /* 0x0010 */ FDoubleRangeBound UpperBound;
};

// Size: 0x10
struct FDoubleRangeBound {
    /* 0x0000 */ uint8_t Type;
    /* 0x0008 */ double Value;
};

enum class EAppMsgCategory {
    Warning = 0,
    Error = 1,
    Success = 2,
    Info = 3,
    EAppMsgCategory_MAX = 4,
};

enum class EAppMsgType {
    Ok = 0,
    YesNo = 1,
    OkCancel = 2,
    YesNoCancel = 3,
    CancelRetryContinue = 4,
    YesNoYesAllNoAll = 5,
    YesNoYesAllNoAllCancel = 6,
    YesNoYesAll = 7,
    EAppMsgType_MAX = 8,
};

enum class EAppReturnType {
    No = 0,
    Yes = 1,
    YesAll = 2,
    NoAll = 3,
    Cancel = 4,
    Ok = 5,
    Retry = 6,
    Continue = 7,
    EAppReturnType_MAX = 8,
};

enum class EAutomationEventType {
    Info = 0,
    Warning = 1,
    Error = 2,
    EAutomationEventType_MAX = 3,
};

enum class EAxis {
    None = 0,
    X = 1,
    Y = 2,
    Z = 3,
    EAxis_MAX = 4,
};

enum class EAxisList {
    None = 0,
    X = 1,
    Y = 2,
    Z = 4,
    Screen = 8,
    XY = 3,
    XZ = 5,
    YZ = 6,
    XYZ = 7,
    All = 15,
    ZRotation = 6,
    Rotate2D = 8,
    Left = 16,
    Up = 32,
    Forward = 64,
    LU = 48,
    LF = 80,
    UF = 96,
    LeftUpForward = 112,
    EAxisList_MAX = 113,
};

enum class EDataValidationResult {
    Invalid = 0,
    Valid = 1,
    NotValidated = 2,
    EDataValidationResult_MAX = 3,
};

enum class EDataValidationUsecase {
    None = 0,
    Manual = 1,
    Commandlet = 2,
    Save = 3,
    PreSubmit = 4,
    Script = 5,
    EDataValidationUsecase_MAX = 6,
};

enum class EFallbackEnum {
    EFallbackEnum_MAX = 1,
};

enum class EInputDeviceAnalogStickMask {
    None = 0,
    Left = 1,
    Right = 2,
    EInputDeviceAnalogStickMask_MAX = 3,
};

enum class EInputDeviceConnectionState {
    Invalid = 0,
    Unknown = 1,
    Disconnected = 2,
    Connected = 3,
    EInputDeviceConnectionState_MAX = 4,
};

enum class EInputDeviceMappingPolicy {
    Invalid = -1,
    UseManagedPlatformLogin = 0,
    PrimaryUserSharesKeyboardAndFirstGamepad = 1,
    CreateUniquePlatformUserForEachDevice = 2,
    MapAllDevicesToPrimaryUser = 3,
    EInputDeviceMappingPolicy_MAX = 4,
};

enum class EInputDeviceTriggerMask {
    None = 0,
    Left = 1,
    Right = 2,
    All = 3,
    EInputDeviceTriggerMask_MAX = 4,
};

enum class EInterpCurveMode {
    CIM_Linear = 0,
    CIM_CurveAuto = 1,
    CIM_Constant = 2,
    CIM_CurveUser = 3,
    CIM_CurveBreak = 4,
    CIM_CurveAutoClamped = 5,
    CIM_MAX = 6,
};

enum class ELifetimeCondition {
    COND_None = 0,
    COND_InitialOnly = 1,
    COND_OwnerOnly = 2,
    COND_SkipOwner = 3,
    COND_SimulatedOnly = 4,
    COND_AutonomousOnly = 5,
    COND_SimulatedOrPhysics = 6,
    COND_InitialOrOwner = 7,
    COND_Custom = 8,
    COND_ReplayOrOwner = 9,
    COND_ReplayOnly = 10,
    COND_SimulatedOnlyNoReplay = 11,
    COND_SimulatedOrPhysicsNoReplay = 12,
    COND_SkipReplay = 13,
    COND_Dynamic = 14,
    COND_Never = 15,
    COND_NetGroup = 16,
    COND_Max = 17,
};

enum class ELocalizedTextSourceCategory {
    Game = 0,
    Engine = 1,
    Editor = 2,
    ELocalizedTextSourceCategory_MAX = 3,
};

enum class ELogTimes {
    None = 0,
    UTC = 1,
    SinceGStartTime = 2,
    Local = 3,
    ELogTimes_MAX = 4,
};

enum class EMouseCursor {
    None = 0,
    Default = 1,
    TextEditBeam = 2,
    ResizeLeftRight = 3,
    ResizeUpDown = 4,
    ResizeSouthEast = 5,
    ResizeSouthWest = 6,
    CardinalCross = 7,
    Crosshairs = 8,
    Hand = 9,
    GrabHand = 10,
    GrabHandClosed = 11,
    SlashedCircle = 12,
    EyeDropper = 13,
    Custom = 14,
    EMouseCursor_MAX = 15,
};

enum class EOverriddenPropertyOperation {
    None = 0,
    Modified = 1,
    Replace = 2,
    Add = 3,
    Remove = 4,
    SubObjectsShadowing = 5,
    EOverriddenPropertyOperation_MAX = 6,
};

enum class EOverriddenState {
    NoOverrides = 0,
    HasOverrides = 1,
    AllOverridden = 2,
    SubObjectsHasOverrides = 3,
    Added = 4,
    EOverriddenState_MAX = 5,
};

enum class EPixelFormat {
    PF_Unknown = 0,
    PF_A32B32G32R32F = 1,
    PF_B8G8R8A8 = 2,
    PF_G8 = 3,
    PF_G16 = 4,
    PF_DXT1 = 5,
    PF_DXT3 = 6,
    PF_DXT5 = 7,
    PF_UYVY = 8,
    PF_FloatRGB = 9,
    PF_FloatRGBA = 10,
    PF_DepthStencil = 11,
    PF_ShadowDepth = 12,
    PF_R32_FLOAT = 13,
    PF_G16R16 = 14,
    PF_G16R16F = 15,
    PF_G16R16F_FILTER = 16,
    PF_G32R32F = 17,
    PF_A2B10G10R10 = 18,
    PF_A16B16G16R16 = 19,
    PF_D24 = 20,
    PF_R16F = 21,
    PF_R16F_FILTER = 22,
    PF_BC5 = 23,
    PF_V8U8 = 24,
    PF_A1 = 25,
    PF_FloatR11G11B10 = 26,
    PF_A8 = 27,
    PF_R32_UINT = 28,
    PF_R32_SINT = 29,
    PF_PVRTC2 = 30,
    PF_PVRTC4 = 31,
    PF_R16_UINT = 32,
    PF_R16_SINT = 33,
    PF_R16G16B16A16_UINT = 34,
    PF_R16G16B16A16_SINT = 35,
    PF_R5G6B5_UNORM = 36,
    PF_R8G8B8A8 = 37,
    PF_A8R8G8B8 = 38,
    PF_BC4 = 39,
    PF_R8G8 = 40,
    PF_ATC_RGB = 41,
    PF_ATC_RGBA_E = 42,
    PF_ATC_RGBA_I = 43,
    PF_X24_G8 = 44,
    PF_ETC1 = 45,
    PF_ETC2_RGB = 46,
    PF_ETC2_RGBA = 47,
    PF_R32G32B32A32_UINT = 48,
    PF_R16G16_UINT = 49,
    PF_ASTC_4x4 = 50,
    PF_ASTC_6x6 = 51,
    PF_ASTC_8x8 = 52,
    PF_ASTC_10x10 = 53,
    PF_ASTC_12x12 = 54,
    PF_BC6H = 55,
    PF_BC7 = 56,
    PF_R8_UINT = 57,
    PF_L8 = 58,
    PF_XGXR8 = 59,
    PF_R8G8B8A8_UINT = 60,
    PF_R8G8B8A8_SNORM = 61,
    PF_R16G16B16A16_UNORM = 62,
    PF_R16G16B16A16_SNORM = 63,
    PF_PLATFORM_HDR_0 = 64,
    PF_PLATFORM_HDR_1 = 65,
    PF_PLATFORM_HDR_2 = 66,
    PF_NV12 = 67,
    PF_R32G32_UINT = 68,
    PF_ETC2_R11_EAC = 69,
    PF_ETC2_RG11_EAC = 70,
    PF_R8 = 71,
    PF_B5G5R5A1_UNORM = 72,
    PF_ASTC_4x4_HDR = 73,
    PF_ASTC_6x6_HDR = 74,
    PF_ASTC_8x8_HDR = 75,
    PF_ASTC_10x10_HDR = 76,
    PF_ASTC_12x12_HDR = 77,
    PF_G16R16_SNORM = 78,
    PF_R8G8_UINT = 79,
    PF_R32G32B32_UINT = 80,
    PF_R32G32B32_SINT = 81,
    PF_R32G32B32F = 82,
    PF_R8_SINT = 83,
    PF_R64_UINT = 84,
    PF_R9G9B9EXP5 = 85,
    PF_P010 = 86,
    PF_ASTC_4x4_NORM_RG = 87,
    PF_ASTC_6x6_NORM_RG = 88,
    PF_ASTC_8x8_NORM_RG = 89,
    PF_ASTC_10x10_NORM_RG = 90,
    PF_ASTC_12x12_NORM_RG = 91,
    PF_R16G16_SINT = 92,
    PF_MAX = 94,
};

enum class EPropertyAccessChangeNotifyMode {
    Default = 0,
    Never = 1,
    Always = 2,
    EPropertyAccessChangeNotifyMode_MAX = 3,
};

enum class EPropertyBagAlterationResult {
    Success = 0,
    NoOperation = 0,
    InternalError = 1,
    PropertyNameEmpty = 2,
    PropertyNameInvalidCharacters = 3,
    SourcePropertyNotFound = 4,
    TargetPropertyNotFound = 5,
    TargetPropertyAlreadyExists = 6,
    EPropertyBagAlterationResult_MAX = 7,
};

enum class EPropertyBagContainerType {
    None = 0,
    Array = 1,
    Set = 2,
    Count = 3,
    EPropertyBagContainerType_MAX = 4,
};

enum class EPropertyBagMissingEnum {
    Missing = 0,
    EPropertyBagMissingEnum_MAX = 1,
};

enum class EPropertyBagPropertyType {
    None = 0,
    Bool = 1,
    Byte = 2,
    Int32 = 3,
    Int64 = 4,
    Float = 5,
    Double = 6,
    Name = 7,
    String = 8,
    Text = 9,
    Enum = 10,
    Struct = 11,
    Object = 12,
    SoftObject = 13,
    Class = 14,
    SoftClass = 15,
    UInt32 = 16,
    UInt64 = 17,
    Count = 18,
    EPropertyBagPropertyType_MAX = 19,
};

enum class EPropertyBagResult {
    Success = 0,
    TypeMismatch = 1,
    OutOfBounds = 2,
    PropertyNotFound = 3,
    DuplicatedValue = 4,
    EPropertyBagResult_MAX = 5,
};

enum class ERangeBoundTypes {
    Exclusive = 0,
    Inclusive = 1,
    Open = 2,
    ERangeBoundTypes_MAX = 3,
};

enum class ESearchCase {
    CaseSensitive = 0,
    IgnoreCase = 1,
    ESearchCase_MAX = 2,
};

enum class ESearchDir {
    FromStart = 0,
    FromEnd = 1,
    ESearchDir_MAX = 2,
};

enum class EUnit {
    Micrometers = 0,
    Millimeters = 1,
    Centimeters = 2,
    Meters = 3,
    Kilometers = 4,
    Inches = 5,
    Feet = 6,
    Yards = 7,
    Miles = 8,
    Lightyears = 9,
    Degrees = 10,
    Radians = 11,
    CentimetersPerSecond = 12,
    MetersPerSecond = 13,
    KilometersPerHour = 14,
    MilesPerHour = 15,
    DegreesPerSecond = 16,
    RadiansPerSecond = 17,
    CentimetersPerSecondSquared = 18,
    MetersPerSecondSquared = 19,
    Celsius = 20,
    Farenheit = 21,
    Kelvin = 22,
    Micrograms = 23,
    Milligrams = 24,
    Grams = 25,
    Kilograms = 26,
    MetricTons = 27,
    Ounces = 28,
    Pounds = 29,
    Stones = 30,
    GramsPerCubicCentimeter = 31,
    GramsPerCubicMeter = 32,
    KilogramsPerCubicCentimeter = 33,
    KilogramsPerCubicMeter = 34,
    Newtons = 35,
    PoundsForce = 36,
    KilogramsForce = 37,
    KilogramCentimetersPerSecondSquared = 38,
    NewtonMeters = 39,
    KilogramCentimetersSquaredPerSecondSquared = 40,
    NewtonSeconds = 41,
    KilogramCentimeters = 42,
    KilogramMeters = 43,
    Hertz = 44,
    Kilohertz = 45,
    Megahertz = 46,
    Gigahertz = 47,
    RevolutionsPerMinute = 48,
    Bytes = 49,
    Kilobytes = 50,
    Megabytes = 51,
    Gigabytes = 52,
    Terabytes = 53,
    Lumens = 54,
    Candela = 55,
    Lux = 56,
    CandelaPerMeter2 = 57,
    ExposureValue = 59,
    Nanoseconds = 60,
    Microseconds = 61,
    Milliseconds = 62,
    Seconds = 63,
    Minutes = 64,
    Hours = 65,
    Days = 66,
    Months = 67,
    Years = 68,
    PixelsPerInch = 69,
    Percentage = 70,
    Multiplier = 71,
    Pascals = 72,
    KiloPascals = 73,
    MegaPascals = 74,
    GigaPascals = 75,
    Unspecified = 76,
    EUnit_MAX = 77,
};

enum class EUserDefinedStructureStatus {
    UDSS_UpToDate = 0,
    UDSS_Dirty = 1,
    UDSS_Error = 2,
    UDSS_Duplicate = 3,
    UDSS_MAX = 4,
};

enum class EVerseEffectSet {
    None = 0,
    Suspends = 1,
    Decides = 2,
    Diverges = 4,
    Reads = 8,
    Writes = 16,
    Allocates = 32,
    NoRollback = 64,
    EVerseEffectSet_MAX = 128,
};

enum class EVerseEnumFlags {
    None = 0,
    NativeBound = 1,
    UHTNative = 2,
    EVerseEnumFlags_MAX = 4,
};

enum class EVerseFalse {
    Value = 0,
    EVerseFalse_MAX = 1,
};

enum class EVerseFunctionFlags {
    None = 0,
    UHTNative = 1,
    EVerseFunctionFlags_MAX = 2,
};

enum class EVersePackageScope {
    PublicAPI = 0,
    InternalAPI = 1,
    PublicUser = 2,
    InternalUser = 3,
    EVersePackageScope_MAX = 4,
};

enum class EVersePackageType {
    VNI = 0,
    Content = 1,
    PublishedContent = 2,
    Assets = 3,
    EVersePackageType_MAX = 4,
};

enum class EVerseTrue {
    Value = 0,
    EVerseTrue_MAX = 1,
};

// Size: 0x28
class IEditorPathObjectInterface : public UInterface {
};

// Size: 0x68
class UEnum : public UField {
};

// Size: 0x78
class UEnumCookedMetaData : public UObject {
    /* 0x0028 */ FObjectCookedMetaDataStore EnumMetaData;
};

// Size: 0x80
class UEnumProperty : public UProperty {
};

// Size: 0x1
struct FFallbackStruct {
};

// Size: 0x30
class UField : public UObject {
};

// Size: 0x10
struct FFieldCookedMetaDataKey {
    /* 0x0000 */ TArray<FName> FieldPath;
};

// Size: 0xa0
struct FFieldCookedMetaDataStore {
    /* 0x0000 */ TMap<FName, FString> FieldMetaData;
    /* 0x0050 */ TMap<FFieldCookedMetaDataKey, FFieldCookedMetaDataValue> SubFieldMetaData;
};

// Size: 0x50
struct FFieldCookedMetaDataValue {
    /* 0x0000 */ TMap<FName, FString> MetaData;
};

// Size: 0x10
struct FFilePath {
    /* 0x0000 */ FString FilePath;
};

// Size: 0x8
struct FFloatInterval {
    /* 0x0000 */ float min;
    /* 0x0004 */ float max;
};

// Size: 0x70
class UFloatProperty : public UNumericProperty {
};

// Size: 0x10
struct FFloatRange {
    /* 0x0000 */ FFloatRangeBound LowerBound;
    /* 0x0008 */ FFloatRangeBound UpperBound;
};

// Size: 0x8
struct FFloatRangeBound {
    /* 0x0000 */ uint8_t Type;
    /* 0x0004 */ float Value;
};

// Size: 0x4
struct FFrameNumber {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x10
struct FFrameNumberRange {
    /* 0x0000 */ FFrameNumberRangeBound LowerBound;
    /* 0x0008 */ FFrameNumberRangeBound UpperBound;
};

// Size: 0x8
struct FFrameNumberRangeBound {
    /* 0x0000 */ uint8_t Type;
    /* 0x0004 */ FFrameNumber Value;
};

// Size: 0x8
struct FFrameRate {
    /* 0x0000 */ int32_t Numerator;
    /* 0x0004 */ int32_t Denominator;
};

// Size: 0x8
struct FFrameTime {
    /* 0x0000 */ FFrameNumber FrameNumber;
    /* 0x0004 */ float SubFrame;
};

// Size: 0x4
struct FFreezablePerPlatformInt {
};

// Size: 0xe0
class UFunction : public UStruct {
};

// Size: 0x38
class UGCObjectReferencer : public UObject {
};

// Size: 0x10
struct FGuid {
    /* 0x0000 */ int32_t A;
    /* 0x0004 */ int32_t B;
    /* 0x0008 */ int32_t C;
    /* 0x000c */ int32_t D;
};

// Size: 0x4
struct FInputDeviceId {
    /* 0x0000 */ int32_t InternalId;
};

// Size: 0x10
struct FInstancedPropertyBag {
    /* 0x0000 */ FInstancedStruct Value;
};

// Size: 0x10
struct FInstancedStruct {
};

// Size: 0x10
struct FInstancedStructContainer {
};

// Size: 0x70
class UInt16Property : public UNumericProperty {
};

// Size: 0x8
struct FInt32Interval {
    /* 0x0000 */ int32_t min;
    /* 0x0004 */ int32_t max;
};

// Size: 0x8
struct FInt32Point {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x10
struct FInt32Range {
    /* 0x0000 */ FInt32RangeBound LowerBound;
    /* 0x0008 */ FInt32RangeBound UpperBound;
};

// Size: 0x8
struct FInt32RangeBound {
    /* 0x0000 */ uint8_t Type;
    /* 0x0004 */ int32_t Value;
};

// Size: 0x10
struct FInt32Rect {
    /* 0x0000 */ FInt32Point min;
    /* 0x0008 */ FInt32Point max;
};

// Size: 0xc
struct FInt32Vector {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
    /* 0x0008 */ int32_t Z;
};

// Size: 0x8
struct FInt32Vector2 {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x10
struct FInt32Vector4 {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
    /* 0x0008 */ int32_t Z;
    /* 0x000c */ int32_t W;
};

// Size: 0x10
struct FInt64Point {
    /* 0x0000 */ int64_t X;
    /* 0x0008 */ int64_t Y;
};

// Size: 0x70
class UInt64Property : public UNumericProperty {
};

// Size: 0x20
struct FInt64Rect {
    /* 0x0000 */ FInt64Point min;
    /* 0x0010 */ FInt64Point max;
};

// Size: 0x18
struct FInt64Vector {
    /* 0x0000 */ int64_t X;
    /* 0x0008 */ int64_t Y;
    /* 0x0010 */ int64_t Z;
};

// Size: 0x10
struct FInt64Vector2 {
    /* 0x0000 */ int64_t X;
    /* 0x0008 */ int64_t Y;
};

// Size: 0x20
struct FInt64Vector4 {
    /* 0x0000 */ int64_t X;
    /* 0x0008 */ int64_t Y;
    /* 0x0010 */ int64_t Z;
    /* 0x0018 */ int64_t W;
};

// Size: 0x70
class UInt8Property : public UNumericProperty {
};

// Size: 0x8
struct FIntPoint {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x70
class UIntProperty : public UNumericProperty {
};

// Size: 0x10
struct FIntRect {
    /* 0x0000 */ FIntPoint min;
    /* 0x0008 */ FIntPoint max;
};

// Size: 0xc
struct FIntVector {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
    /* 0x0008 */ int32_t Z;
};

// Size: 0x8
struct FIntVector2 {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x10
struct FIntVector4 {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
    /* 0x0008 */ int32_t Z;
    /* 0x000c */ int32_t W;
};

// Size: 0x28
class UInterface : public UObject {
};

// Size: 0x78
class UInterfaceProperty : public UProperty {
};

// Size: 0x18
struct FInterpCurveFloat {
    /* 0x0000 */ TArray<FInterpCurvePointFloat> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x18
struct FInterpCurveLinearColor {
    /* 0x0000 */ TArray<FInterpCurvePointLinearColor> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x14
struct FInterpCurvePointFloat {
    /* 0x0000 */ float InVal;
    /* 0x0004 */ float OutVal;
    /* 0x0008 */ float ArriveTangent;
    /* 0x000c */ float LeaveTangent;
    /* 0x0010 */ uint8_t InterpMode;
};

// Size: 0x38
struct FInterpCurvePointLinearColor {
    /* 0x0000 */ float InVal;
    /* 0x0004 */ FLinearColor OutVal;
    /* 0x0014 */ FLinearColor ArriveTangent;
    /* 0x0024 */ FLinearColor LeaveTangent;
    /* 0x0034 */ uint8_t InterpMode;
};

// Size: 0x80
struct FInterpCurvePointQuat {
    /* 0x0000 */ float InVal;
    /* 0x0010 */ FQuat OutVal;
    /* 0x0030 */ FQuat ArriveTangent;
    /* 0x0050 */ FQuat LeaveTangent;
    /* 0x0070 */ uint8_t InterpMode;
};

// Size: 0xa0
struct FInterpCurvePointTwoVectors {
    /* 0x0000 */ float InVal;
    /* 0x0008 */ FTwoVectors OutVal;
    /* 0x0038 */ FTwoVectors ArriveTangent;
    /* 0x0068 */ FTwoVectors LeaveTangent;
    /* 0x0098 */ uint8_t InterpMode;
};

// Size: 0x58
struct FInterpCurvePointVector {
    /* 0x0000 */ float InVal;
    /* 0x0008 */ FVector OutVal;
    /* 0x0020 */ FVector ArriveTangent;
    /* 0x0038 */ FVector LeaveTangent;
    /* 0x0050 */ uint8_t InterpMode;
};

// Size: 0x40
struct FInterpCurvePointVector2D {
    /* 0x0000 */ float InVal;
    /* 0x0008 */ FVector2D OutVal;
    /* 0x0018 */ FVector2D ArriveTangent;
    /* 0x0028 */ FVector2D LeaveTangent;
    /* 0x0038 */ uint8_t InterpMode;
};

// Size: 0x18
struct FInterpCurveQuat {
    /* 0x0000 */ TArray<FInterpCurvePointQuat> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x18
struct FInterpCurveTwoVectors {
    /* 0x0000 */ TArray<FInterpCurvePointTwoVectors> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x18
struct FInterpCurveVector {
    /* 0x0000 */ TArray<FInterpCurvePointVector> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x18
struct FInterpCurveVector2D {
    /* 0x0000 */ TArray<FInterpCurvePointVector2D> points;
    /* 0x0010 */ bool bIsLooped;
    /* 0x0014 */ float LoopKeyOffset;
};

// Size: 0x78
class ULazyObjectProperty : public UObjectPropertyBase {
};

// Size: 0x10
struct FLinearColor {
    /* 0x0000 */ float R;
    /* 0x0004 */ float G;
    /* 0x0008 */ float B;
    /* 0x000c */ float A;
};

// Size: 0x3c0
class ULinkerPlaceholderClass : public UClass {
};

// Size: 0xf8
class ULinkerPlaceholderExportObject : public UObject {
};

// Size: 0x2a0
class ULinkerPlaceholderFunction : public UFunction {
};

// Size: 0x98
class UMapProperty : public UProperty {
};

// Size: 0x80
struct FMatrix {
    /* 0x0000 */ FPlane XPlane;
    /* 0x0020 */ FPlane YPlane;
    /* 0x0040 */ FPlane ZPlane;
    /* 0x0060 */ FPlane WPlane;
};

// Size: 0x80
struct FMatrix44d {
    /* 0x0000 */ FPlane4d XPlane;
    /* 0x0020 */ FPlane4d YPlane;
    /* 0x0040 */ FPlane4d ZPlane;
    /* 0x0060 */ FPlane4d WPlane;
};

// Size: 0x40
struct FMatrix44f {
    /* 0x0000 */ FPlane4f XPlane;
    /* 0x0010 */ FPlane4f YPlane;
    /* 0x0020 */ FPlane4f ZPlane;
    /* 0x0030 */ FPlane4f WPlane;
};

// Size: 0xc8
class UMetaData : public UObject {
};

// Size: 0x78
class UMulticastDelegateProperty : public UProperty {
};

// Size: 0x30
class UMulticastDelegatePropertyWrapper : public UPropertyWrapper {
};

// Size: 0x78
class UMulticastInlineDelegateProperty : public UMulticastDelegateProperty {
};

// Size: 0x30
class UMulticastInlineDelegatePropertyWrapper : public UMulticastDelegatePropertyWrapper {
};

// Size: 0x78
class UMulticastSparseDelegateProperty : public UMulticastDelegateProperty {
};

// Size: 0x10
struct FMusicalTime {
    /* 0x0000 */ int32_t Bar;
    /* 0x0004 */ int32_t TickInBar;
    /* 0x0008 */ int32_t TicksPerBar;
    /* 0x000c */ int32_t TicksPerBeat;
};

// Size: 0x70
class UNameProperty : public UProperty {
};

// Size: 0x70
class UNumericProperty : public UProperty {
};

// Size: 0x28
class UObject {

    void ExecuteUbergraph(int32_t EntryPoint);
};

// Size: 0x50
struct FObjectCookedMetaDataStore {
    /* 0x0000 */ TMap<FName, FString> ObjectMetaData;
};

// Size: 0x78
class UObjectProperty : public UObjectPropertyBase {
};

// Size: 0x78
class UObjectPropertyBase : public UProperty {
};

// Size: 0x38
class UObjectReachabilityStressData : public UObject {
};

// Size: 0x30
class UObjectRedirector : public UObject {
};

// Size: 0x78
struct FOrientedBox {
    /* 0x0000 */ FVector Center;
    /* 0x0018 */ FVector AxisX;
    /* 0x0030 */ FVector AxisY;
    /* 0x0048 */ FVector AxisZ;
    /* 0x0060 */ double ExtentX;
    /* 0x0068 */ double ExtentY;
    /* 0x0070 */ double ExtentZ;
};

// Size: 0x68
struct FOverriddenPropertyNode {
    /* 0x0000 */ FOverriddenPropertyNodeID NodeID;
    /* 0x0010 */ EOverriddenPropertyOperation Operation;
    /* 0x0018 */ TMap<FOverriddenPropertyNodeID, FOverriddenPropertyNodeID> SubPropertyNodeKeys;
};

// Size: 0x10
struct FOverriddenPropertyNodeID {
    /* 0x0000 */ FName Path;
    /* 0x0008 */ UObject* Object;
};

// Size: 0x68
struct FOverriddenPropertySet {
    /* 0x0000 */ UObject* Owner;
    /* 0x0008 */ bool bWasAdded;
    /* 0x0010 */ TSet<FOverriddenPropertyNode> OverriddenPropertyNodes;
};

// Size: 0x50
class UPackage : public UObject {
};

// Size: 0xe0
class UPackageMap : public UObject {
};

// Size: 0x4
struct FPackedNormal {
    /* 0x0000 */ uint8_t X;
    /* 0x0001 */ uint8_t Y;
    /* 0x0002 */ uint8_t Z;
    /* 0x0003 */ uint8_t W;
};

// Size: 0x4
struct FPackedRGB10A2N {
    /* 0x0000 */ int32_t Packed;
};

// Size: 0x8
struct FPackedRGBA16N {
    /* 0x0000 */ int32_t XY;
    /* 0x0004 */ int32_t ZW;
};

// Size: 0x20
struct FPackedRemoteObjectPathName {
    /* 0x0000 */ TArray<uint16_t> RemoteIds;
    /* 0x0010 */ TArray<uint16_t> Names;
};

// Size: 0x1
struct FPerPlatformBool {
    /* 0x0000 */ bool Default;
};

// Size: 0x4
struct FPerPlatformFloat {
    /* 0x0000 */ float Default;
};

// Size: 0x8
struct FPerPlatformFrameRate {
    /* 0x0000 */ FFrameRate Default;
};

// Size: 0x4
struct FPerPlatformInt {
    /* 0x0000 */ int32_t Default;
};

// Size: 0x20
struct FPlane : public FVector {
    /* 0x0018 */ double W;
};

// Size: 0x20
struct FPlane4d : public FVector3d {
    /* 0x0018 */ double W;
};

// Size: 0x10
struct FPlane4f : public FVector3f {
    /* 0x000c */ float W;
};

// Size: 0x8
struct FPlatformInputDeviceState {
    /* 0x0000 */ FPlatformUserId OwningPlatformUser;
    /* 0x0004 */ EInputDeviceConnectionState ConnectionState;
};

// Size: 0x4
struct FPlatformUserId {
    /* 0x0000 */ int32_t InternalId;
};

// Size: 0xb0
struct FPolyglotTextData {
    /* 0x0000 */ ELocalizedTextSourceCategory Category;
    /* 0x0008 */ FString NativeCulture;
    /* 0x0018 */ FString Namespace;
    /* 0x0028 */ FString Key;
    /* 0x0038 */ FString NativeString;
    /* 0x0048 */ TMap<FString, FString> LocalizedStrings;
    /* 0x0098 */ bool bIsMinimalPatch;
    /* 0x00a0 */ FText CachedText;
};

// Size: 0x10
struct FPrimaryAssetId {
    /* 0x0000 */ FPrimaryAssetType PrimaryAssetType;
    /* 0x0008 */ FName PrimaryAssetName;
};

// Size: 0x8
struct FPrimaryAssetType {
    /* 0x0000 */ FName Name;
};

// Size: 0x30
struct FProfileLocus {
};

// Size: 0x70
class UProperty : public UField {
};

// Size: 0xd8
class UPropertyBag : public UScriptStruct {
    /* 0x00c0 */ TArray<FPropertyBagPropertyDesc> PropertyDescs;
};

// Size: 0x3
struct FPropertyBagContainerTypes {
};

// Size: 0x28
class UPropertyBagMissingObject : public UObject {
};

// Size: 0x1
struct FPropertyBagMissingStruct {
};

// Size: 0x40
struct FPropertyBagPropertyDesc {
    /* 0x0000 */ UObject* ValueTypeObject;
    /* 0x0008 */ FGuid ID;
    /* 0x0018 */ FName Name;
    /* 0x0020 */ EPropertyBagPropertyType ValueType;
    /* 0x0021 */ FPropertyBagContainerTypes ContainerTypes;
    /* 0x0028 */ uint64_t PropertyFlags;
};

// Size: 0x18
struct FPropertyBagPropertyDescMetaData {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FString Value;
};

// Size: 0x18
struct FPropertyTextFName {
};

// Size: 0x20
struct FPropertyTextString {
};

// Size: 0x30
class UPropertyWrapper : public UObject {
};

// Size: 0x10
struct FQualifiedFrameTime {
    /* 0x0000 */ FFrameTime Time;
    /* 0x0008 */ FFrameRate Rate;
};

// Size: 0x20
struct FQuat {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
    /* 0x0018 */ double W;
};

// Size: 0x20
struct FQuat4d {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
    /* 0x0018 */ double W;
};

// Size: 0x10
struct FQuat4f {
    /* 0x0000 */ float X;
    /* 0x0004 */ float Y;
    /* 0x0008 */ float Z;
    /* 0x000c */ float W;
};

// Size: 0x8
struct FRandomStream {
    /* 0x0000 */ int32_t InitialSeed;
    /* 0x0004 */ int32_t Seed;
};

// Size: 0x30
struct FRay {
    /* 0x0000 */ FVector Origin;
    /* 0x0018 */ FVector Direction;
};

// Size: 0x30
struct FRay3d {
    /* 0x0000 */ FVector3d Origin;
    /* 0x0018 */ FVector3d Direction;
};

// Size: 0x18
struct FRay3f {
    /* 0x0000 */ FVector3f Origin;
    /* 0x000c */ FVector3f Direction;
};

// Size: 0x10
struct FRemoteObjectBytes {
    /* 0x0000 */ TArray<uint8_t> Bytes;
};

// Size: 0x40
struct FRemoteObjectData {
    /* 0x0000 */ FRemoteObjectTables Tables;
    /* 0x0020 */ TArray<FPackedRemoteObjectPathName> PathNames;
    /* 0x0030 */ TArray<FRemoteObjectBytes> Bytes;
};

// Size: 0x8
struct FRemoteObjectId {
    /* 0x0000 */ uint64_t ID;
};

// Size: 0x20
struct FRemoteObjectPathName : public FRemoteObjectTables {
};

// Size: 0x10
struct FRemoteObjectReference {
    /* 0x0000 */ FRemoteObjectId ObjectId;
    /* 0x0008 */ FRemoteServerId ServerId;
};

// Size: 0x20
struct FRemoteObjectTables {
    /* 0x0000 */ TArray<FName> Names;
    /* 0x0010 */ TArray<FRemoteObjectId> RemoteIds;
};

// Size: 0x4
struct FRemoteServerId {
    /* 0x0000 */ uint32_t ID;
};

// Size: 0x4
struct FRemoteTransactionId {
    /* 0x0000 */ uint32_t ID;
};

// Size: 0x8
struct FRemoteWorkPriority {
    /* 0x0000 */ uint64_t PackedData;
};

// Size: 0x18
struct FRotator {
    /* 0x0000 */ double Pitch;
    /* 0x0008 */ double Yaw;
    /* 0x0010 */ double Roll;
};

// Size: 0x18
struct FRotator3d {
    /* 0x0000 */ double Pitch;
    /* 0x0008 */ double Yaw;
    /* 0x0010 */ double Roll;
};

// Size: 0xc
struct FRotator3f {
    /* 0x0000 */ float Pitch;
    /* 0x0004 */ float Yaw;
    /* 0x0008 */ float Roll;
};

// Size: 0xc0
class UScriptStruct : public UStruct {
};

// Size: 0x90
class USetProperty : public UProperty {
};

// Size: 0x10
struct FSharedStruct {
};

// Size: 0x20
struct FSoftClassPath : public FSoftObjectPath {
};

// Size: 0x80
class USoftClassProperty : public USoftObjectProperty {
};

// Size: 0x20
struct FSoftObjectPath {
    /* 0x0000 */ FTopLevelAssetPath AssetPath;
    /* 0x0010 */ char* SubPathString;
};

// Size: 0x78
class USoftObjectProperty : public UObjectPropertyBase {
};

// Size: 0x38
struct FSolarisProfilingData {
};

// Size: 0xf0
class USparseDelegateFunction : public UDelegateFunction {
};

// Size: 0x20
struct FSphere {
    /* 0x0000 */ FVector Center;
    /* 0x0018 */ double W;
};

// Size: 0x20
struct FSphere3d {
    /* 0x0000 */ FVector3d Center;
    /* 0x0018 */ double W;
};

// Size: 0x10
struct FSphere3f {
    /* 0x0000 */ FVector3f Center;
    /* 0x000c */ float W;
};

// Size: 0x70
class UStrProperty : public UProperty {
};

// Size: 0xb0
class UStruct : public UField {
};

// Size: 0xc8
class UStructCookedMetaData : public UObject {
    /* 0x0028 */ FStructCookedMetaDataStore StructMetaData;
};

// Size: 0xa0
struct FStructCookedMetaDataStore {
    /* 0x0000 */ FObjectCookedMetaDataStore ObjectMetaData;
    /* 0x0050 */ TMap<FName, FFieldCookedMetaDataStore> PropertiesMetaData;
};

// Size: 0x78
class UStructProperty : public UProperty {
};

// Size: 0x20
struct FTemplateString {
    /* 0x0000 */ FString Template;
    /* 0x0010 */ FText Resolved;
};

// Size: 0x58
struct FTestUndeclaredScriptStructObjectReferencesTest {
    /* 0x0000 */ UObject* StrongObjectPointer;
    /* 0x0008 */ TSoftObjectPtr<UObject> SoftObjectPointer;
    /* 0x0030 */ FSoftObjectPath SoftObjectPath;
    /* 0x0050 */ TWeakObjectPtr<UObject> WeakObjectPointer;
};

// Size: 0x18
struct FTestUninitializedScriptStructMembersTest {
    /* 0x0000 */ UObject* UninitializedObjectReference;
    /* 0x0008 */ UObject* InitializedObjectReference;
    /* 0x0010 */ float UnusedValue;
};

// Size: 0x50
class UTextBuffer : public UObject {
};

// Size: 0x70
class UTextProperty : public UProperty {
};

// Size: 0x18
struct FTimecode {
    /* 0x0000 */ int32_t Hours;
    /* 0x0004 */ int32_t Minutes;
    /* 0x0008 */ int32_t Seconds;
    /* 0x000c */ int32_t Frames;
    /* 0x0010 */ float SubFrame;
    /* 0x0014 */ bool bDropFrameFormat;
};

// Size: 0x8
struct FTimespan {
    /* 0x0000 */ int64_t Ticks;
};

// Size: 0x10
struct FTopLevelAssetPath {
    /* 0x0000 */ FName PackageName;
    /* 0x0008 */ FName AssetName;
};

// Size: 0x60
struct FTransform {
    /* 0x0000 */ FQuat Rotation;
    /* 0x0020 */ FVector Translation;
    /* 0x0040 */ FVector Scale3D;
};

// Size: 0x60
struct FTransform3d {
    /* 0x0000 */ FQuat4d Rotation;
    /* 0x0020 */ FVector3d Translation;
    /* 0x0040 */ FVector3d Scale3D;
};

// Size: 0x30
struct FTransform3f {
    /* 0x0000 */ FQuat4f Rotation;
    /* 0x0010 */ FVector3f Translation;
    /* 0x0020 */ FVector3f Scale3D;
};

// Size: 0x30
struct FTwoVectors {
    /* 0x0000 */ FVector v1;
    /* 0x0018 */ FVector v2;
};

// Size: 0x70
class UUInt16Property : public UNumericProperty {
};

// Size: 0x70
class UUInt32Property : public UNumericProperty {
};

// Size: 0x70
class UUInt64Property : public UNumericProperty {
};

// Size: 0x8
struct FUint32Point {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x10
struct FUint32Rect {
    /* 0x0000 */ FUint32Point min;
    /* 0x0008 */ FUint32Point max;
};

// Size: 0xc
struct FUint32Vector {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
    /* 0x0008 */ uint32_t Z;
};

// Size: 0x8
struct FUint32Vector2 {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
};

// Size: 0x10
struct FUint32Vector4 {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
    /* 0x0008 */ uint32_t Z;
    /* 0x000c */ uint32_t W;
};

// Size: 0x10
struct FUint64Point {
    /* 0x0000 */ int64_t X;
    /* 0x0008 */ int64_t Y;
};

// Size: 0x20
struct FUint64Rect {
    /* 0x0000 */ FUint64Point min;
    /* 0x0010 */ FUint64Point max;
};

// Size: 0x18
struct FUint64Vector {
    /* 0x0000 */ uint64_t X;
    /* 0x0008 */ uint64_t Y;
    /* 0x0010 */ uint64_t Z;
};

// Size: 0x10
struct FUint64Vector2 {
    /* 0x0000 */ uint64_t X;
    /* 0x0008 */ uint64_t Y;
};

// Size: 0x20
struct FUint64Vector4 {
    /* 0x0000 */ uint64_t X;
    /* 0x0008 */ uint64_t Y;
    /* 0x0010 */ uint64_t Z;
    /* 0x0018 */ uint64_t W;
};

// Size: 0x8
struct FUintPoint {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
};

// Size: 0x10
struct FUintRect {
    /* 0x0000 */ FUintPoint min;
    /* 0x0008 */ FUintPoint max;
};

// Size: 0xc
struct FUintVector {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
    /* 0x0008 */ uint32_t Z;
};

// Size: 0x8
struct FUintVector2 {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
};

// Size: 0x10
struct FUintVector4 {
    /* 0x0000 */ uint32_t X;
    /* 0x0004 */ uint32_t Y;
    /* 0x0008 */ uint32_t Z;
    /* 0x000c */ uint32_t W;
};

// Size: 0x108
class UUserDefinedStruct : public UScriptStruct {
    /* 0x00c0 */ uint8_t Status;
    /* 0x00c4 */ FGuid Guid;
};

// Size: 0x28
class UUserDefinedStructEditorDataBase : public UObject {
};

// Size: 0x18
struct FVector {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
};

// Size: 0x10
struct FVector2D {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
};

// Size: 0x8
struct FVector2f {
    /* 0x0000 */ float X;
    /* 0x0004 */ float Y;
};

// Size: 0x18
struct FVector3d {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
};

// Size: 0xc
struct FVector3f {
    /* 0x0000 */ float X;
    /* 0x0004 */ float Y;
    /* 0x0008 */ float Z;
};

// Size: 0x20
struct FVector4 {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
    /* 0x0018 */ double W;
};

// Size: 0x20
struct FVector4d {
    /* 0x0000 */ double X;
    /* 0x0008 */ double Y;
    /* 0x0010 */ double Z;
    /* 0x0018 */ double W;
};

// Size: 0x10
struct FVector4f {
    /* 0x0000 */ float X;
    /* 0x0004 */ float Y;
    /* 0x0008 */ float Z;
    /* 0x000c */ float W;
};

// Size: 0x388
class UVerseClass : public UClass {
    /* 0x0200 */ uint32_t SolClassFlags;
    /* 0x0208 */ TArray<UVerseClass*> TaskClasses;
    /* 0x0218 */ UFunction* InitInstanceFunction;
    /* 0x0220 */ TArray<FVersePersistentVar> PersistentVars;
    /* 0x0230 */ TArray<FVerseSessionVar> SessionVars;
    /* 0x0240 */ TMap<FName, FVerseClassVarAccessors> VarAccessors;
    /* 0x0290 */ EVerseEffectSet ConstructorEffects;
    /* 0x0294 */ FName MangledPackageVersePath;
    /* 0x02a0 */ FString PackageRelativeVersePath;
    /* 0x02b0 */ TMap<FName, FName> DisplayNameToUENameFunctionMap;
    /* 0x0300 */ TArray<UVerseClass*> DirectInterfaces;
    /* 0x0310 */ TArray<FFieldPath> PropertiesWrittenByInitCDO;
    /* 0x0320 */ TMap<FName, FName> FunctionMangledNames;
    /* 0x0370 */ TArray<FName> PredictsFunctionNames;
};

// Size: 0x10
struct FVerseClassVarAccessor {
    /* 0x0000 */ UFunction* Func;
    /* 0x0008 */ bool bIsInstanceMember;
    /* 0x0009 */ bool bIsFallible;
};

// Size: 0xa0
struct FVerseClassVarAccessors {
    /* 0x0000 */ TMap<int32_t, FVerseClassVarAccessor> Getters;
    /* 0x0050 */ TMap<int32_t, FVerseClassVarAccessor> Setters;
};

// Size: 0x80
class UVerseEnum : public UEnum {
    /* 0x0068 */ EVerseEnumFlags VerseEnumFlags;
    /* 0x0070 */ char* QualifiedName;
};

// Size: 0xf0
class UVerseFunction : public UFunction {
};

// Size: 0x30
struct FVersePersistentVar {
    /* 0x0000 */ FString Path;
    /* 0x0010 */ FFieldPath Property;
};

// Size: 0x20
struct FVerseSessionVar {
    /* 0x0000 */ FFieldPath Property;
};

// Size: 0x110
class UVerseStruct : public UScriptStruct {
    /* 0x00c0 */ uint32_t VerseClassFlags;
    /* 0x00c8 */ char* QualifiedName;
    /* 0x00d8 */ UFunction* InitFunction;
    /* 0x00e0 */ UVerseClass* ModuleClass;
    /* 0x00e8 */ FGuid Guid;
    /* 0x00f8 */ UFunction* FactoryFunction;
    /* 0x0100 */ UFunction* OverrideFactoryFunction;
    /* 0x0108 */ EVerseEffectSet ConstructorEffects;
};

// Size: 0x78
class UWeakObjectProperty : public UObjectPropertyBase {
};

// Size: 0x88
class UCsvActorCountMetric : public UWorldMetricInterface {
};

// Size: 0x60
class UCsvMetricsSubsystem : public UWorldSubsystem {
    /* 0x0030 */ TArray<UClass*> MetricClasses;
};

// Size: 0x580
class UCustomMeshComponent : public UMeshComponent {

    void AddCustomMeshTriangles(const TArray<FCustomMeshTriangle>& Triangles);
    void ClearCustomMeshTriangles();
    bool SetCustomMeshTriangles(const TArray<FCustomMeshTriangle>& Triangles);
};

// Size: 0x48
struct FCustomMeshTriangle {
    /* 0x0000 */ FVector Vertex0;
    /* 0x0018 */ FVector Vertex1;
    /* 0x0030 */ FVector Vertex2;
};

// Size: 0x30
class UDLSSOverrideSettings : public UObject {
    /* 0x0028 */ bool bShowDLSSIncompatiblePluginsToolsWarnings;
    /* 0x0029 */ EDLSSSettingOverride ShowDLSSSDebugOnScreenMessages;
    /* 0x002a */ EDLSSSettingOverride EnableDLSSInEditorViewportsOverride;
    /* 0x002b */ EDLSSSettingOverride EnableDLSSInPlayInEditorViewportsOverride;
};

// Size: 0x98
class UDLSSSettings : public UObject {
    /* 0x0028 */ bool bAllowOTAUpdate;
    /* 0x002c */ uint32_t NVIDIANGXApplicationId;
    /* 0x0030 */ uint8_t BiasCurrentColorStencilValue;
    /* 0x0031 */ bool bEnableDLSSD3D12;
    /* 0x0032 */ bool bEnableDLSSD3D11;
    /* 0x0033 */ bool bEnableDLSSVulkan;
    /* 0x0034 */ bool bShowDLSSIncompatiblePluginsToolsWarnings;
    /* 0x0035 */ bool bEnableDLSSInEditorViewports;
    /* 0x0036 */ bool bEnableDLSSInPlayInEditorViewports;
    /* 0x0037 */ bool bShowDLSSSDebugOnScreenMessages;
    /* 0x0038 */ FString GenericDLSSSRBinaryPath;
    /* 0x0048 */ bool bGenericDLSSSRBinaryExists;
    /* 0x0050 */ FString CustomDLSSSRBinaryPath;
    /* 0x0060 */ bool bCustomDLSSSRBinaryExists;
    /* 0x0061 */ EDLSSPreset DLAAPreset;
    /* 0x0063 */ EDLSSPreset DLSSQualityPreset;
    /* 0x0064 */ EDLSSPreset DLSSBalancedPreset;
    /* 0x0065 */ EDLSSPreset DLSSPerformancePreset;
    /* 0x0066 */ EDLSSPreset DLSSUltraPerformancePreset;
    /* 0x0068 */ FString GenericDLSSRRBinaryPath;
    /* 0x0078 */ bool bGenericDLSSRRBinaryExists;
    /* 0x0080 */ FString CustomDLSSRRBinaryPath;
    /* 0x0090 */ bool bCustomDLSSRRBinaryExists;
    /* 0x0091 */ EDLSSRRPreset DLAARRPreset;
    /* 0x0093 */ EDLSSRRPreset DLSSRRQualityPreset;
    /* 0x0094 */ EDLSSRRPreset DLSSRRBalancedPreset;
    /* 0x0095 */ EDLSSRRPreset DLSSRRPerformancePreset;
    /* 0x0096 */ EDLSSRRPreset DLSSRRUltraPerformancePreset;
};

// Size: 0x1
struct FDLSSUpscalerModularFeatureSettings {
    /* 0x0000 */ EDLSSUpscalerModularFeatureQuality Quality;
};

enum class EDLSSPreset {
    Default = 0,
    A = 1,
    B = 2,
    C = 3,
    D = 4,
    E = 5,
    F = 6,
    G = 7,
    H = 8,
    I = 9,
    J = 10,
    K = 11,
    L = 12,
    M = 13,
    N = 14,
    O = 15,
    MAX = 16,
};

enum class EDLSSRRPreset {
    Default = 0,
    A = 1,
    B = 2,
    C = 3,
    D = 4,
    E = 5,
    F = 6,
    G = 7,
    H = 8,
    I = 9,
    J = 10,
    K = 11,
    L = 12,
    M = 13,
    N = 14,
    O = 15,
    MAX = 16,
};

enum class EDLSSSettingOverride {
    Enabled = 0,
    Disabled = 1,
    UseProjectSettings = 2,
    EDLSSSettingOverride_MAX = 3,
};

enum class EDLSSUpscalerModularFeatureQuality {
    Auto = 0,
    UltraQuality = 1,
    Quality = 2,
    Balanced = 3,
    Performance = 4,
    UltraPerformance = 5,
    DLAA = 6,
    Count = 7,
    EDLSSUpscalerModularFeatureQuality_MAX = 8,
};

// Size: 0x28
class UDLSSLibrary : public UBlueprintFunctionLibrary {

    static void EnableDLAA(bool bEnabled);
    static void EnableDLSS(bool bEnabled);
    static void EnableDLSSRR(bool bEnabled);
    static void GetDLSSMinimumDriverVersion(int32_t& MinDriverVersionMajor, int32_t& MinDriverVersionMinor);
    static UDLSSMode GetDLSSMode();
    static void GetDLSSModeInformation(UDLSSMode DLSSMode, FVector2D ScreenResolution, bool& bIsSupported, float& OptimalScreenPercentage, bool& bIsFixedScreenPercentage, float& MinScreenPercentage, float& MaxScreenPercentage, float& OptimalSharpness);
    static void GetDLSSRRMinimumDriverVersion(int32_t& MinDriverVersionMajor, int32_t& MinDriverVersionMinor);
    static void GetDLSSScreenPercentageRange(float& MinScreenPercentage, float& MaxScreenPercentage);
    static UDLSSMode GetDefaultDLSSMode();
    static TArray<UDLSSMode> GetSupportedDLSSModes();
    static bool IsDLAAEnabled();
    static bool IsDLSSEnabled();
    static bool IsDLSSModeSupported(UDLSSMode DLSSMode);
    static bool IsDLSSRREnabled();
    static bool IsDLSSRRSupported();
    static bool IsDLSSSupported();
    static bool IsRayTracingAvailable();
    static UDLSSSupport QueryDLSSRRSupport();
    static UDLSSSupport QueryDLSSSupport();
    static void SetDLSSMode(UObject* WorldContextObject, UDLSSMode DLSSMode);
};

enum class UDLSSMode {
    Off = 0,
    Auto = 1,
    DLAA = 2,
    UltraQuality = 3,
    Quality = 4,
    Balanced = 5,
    Performance = 6,
    UltraPerformance = 7,
    UDLSSMode_MAX = 8,
};

enum class UDLSSSupport {
    Supported = 0,
    NotSupported = 1,
    NotSupportedIncompatibleHardware = 2,
    NotSupportedDriverOutOfDate = 3,
    NotSupportedOperatingSystemOutOfDate = 4,
    NotSupportedByPlatformAtBuildTime = 5,
    NotSupportedIncompatibleAPICaptureToolActive = 6,
    UDLSSSupport_MAX = 7,
};

// Size: 0x2a0
struct FConvertBoolArrayTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowBoolArrayTypes In;
    /* 0x0290 */ FDataflowBoolArrayTypes Out;
};

// Size: 0x288
struct FConvertBoolTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowBoolTypes In;
    /* 0x0281 */ FDataflowBoolTypes Out;
};

// Size: 0x2a0
struct FConvertNumericArrayTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericArrayTypes In;
    /* 0x0290 */ FDataflowNumericArrayTypes Out;
};

// Size: 0x290
struct FConvertNumericTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes In;
    /* 0x0288 */ FDataflowNumericTypes Out;
};

// Size: 0x2b0
struct FConvertRotationDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowRotationTypes In;
    /* 0x0298 */ FDataflowRotationTypes Out;
};

// Size: 0x388
struct FConvertSelectionTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FManagedArrayCollection Collection;
    /* 0x0330 */ FDataflowSelectionTypes In;
    /* 0x0358 */ bool bAllElementsMustBeSelected;
    /* 0x0360 */ FDataflowSelectionTypes Out;
};

// Size: 0x2a0
struct FConvertStringArrayTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowStringArrayTypes In;
    /* 0x0290 */ FDataflowStringArrayTypes Out;
};

// Size: 0x2a0
struct FConvertStringConvertibleTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowStringConvertibleTypes In;
    /* 0x0290 */ FDataflowStringConvertibleTypes Out;
};

// Size: 0x2a0
struct FConvertStringTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowStringTypes In;
    /* 0x0290 */ FDataflowStringTypes Out;
};

// Size: 0x2a0
struct FConvertTransformArrayTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowTransformArrayTypes In;
    /* 0x0290 */ FDataflowTransformArrayTypes Out;
};

// Size: 0x340
struct FConvertTransformTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowTransformTypes In;
    /* 0x02e0 */ FDataflowTransformTypes Out;
};

// Size: 0x290
struct FConvertUObjectConvertibleTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowUObjectConvertibleTypes In;
    /* 0x0288 */ FDataflowUObjectConvertibleTypes Out;
};

// Size: 0x2a0
struct FConvertVectorArrayTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorArrayTypes In;
    /* 0x0290 */ FDataflowVectorArrayTypes Out;
};

// Size: 0x2c0
struct FConvertVectorTypesDataflowNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes In;
    /* 0x02a0 */ FDataflowVectorTypes Out;
};

// Size: 0x1
struct FDataflowAllTypes : public FDataflowAnyType {
};

// Size: 0x1
struct FDataflowAnyType {
};

// Size: 0x80
struct FDataflowArrayInput : public FDataflowInput {
};

// Size: 0xa0
struct FDataflowArrayOutput : public FDataflowOutput {
};

// Size: 0x1
struct FDataflowArrayTypes : public FDataflowAnyType {
};

// Size: 0x60
struct FDataflowBaseElement {
};

// Size: 0x10
struct FDataflowBoolArrayTypes : public FDataflowAnyType {
    /* 0x0000 */ TArray<bool> Value;
};

// Size: 0x1
struct FDataflowBoolTypes : public FDataflowAnyType {
    /* 0x0000 */ bool Value;
};

// Size: 0x288
struct FDataflowBranchNode : public FDataflowNode {
    /* 0x0280 */ FDataflowAnyType TrueValue;
    /* 0x0281 */ FDataflowAnyType FalseValue;
    /* 0x0282 */ bool bCondition;
    /* 0x0283 */ FDataflowAnyType Result;
};

// Size: 0x60
struct FDataflowConnection {
};

// Size: 0x28
struct FDataflowFaceSelection : public FDataflowSelection {
};

// Size: 0x288
struct FDataflowForceDependencyNode : public FDataflowNode {
    /* 0x0280 */ FDataflowAnyType Value;
    /* 0x0281 */ FDataflowAnyType DependentValue;
};

// Size: 0x1
struct FDataflowFreezeActions {
};

// Size: 0x28
struct FDataflowGeometrySelection : public FDataflowSelection {
};

// Size: 0x28
class IDataflowGraphInterface : public UInterface {
};

// Size: 0x28
struct FDataflowImage {
};

// Size: 0x350
struct FDataflowImageCombineChannelsNode : public FDataflowNode {
    /* 0x0280 */ FDataflowImage Red;
    /* 0x02a8 */ FDataflowImage Green;
    /* 0x02d0 */ FDataflowImage Blue;
    /* 0x02f8 */ FDataflowImage Alpha;
    /* 0x0320 */ FDataflowImage Image;
    /* 0x0348 */ EDataflowImageCombineResolutionOption ResolutionOptions;
    /* 0x034c */ EDataflowImageResolution Resolution;
};

// Size: 0x2c0
struct FDataflowImageFromColorNode : public FDataflowNode {
    /* 0x0280 */ FLinearColor FillColor;
    /* 0x0290 */ EDataflowImageResolution Resolution;
    /* 0x0298 */ FDataflowImage Image;
};

// Size: 0x348
struct FDataflowImageSplitChannelsNode : public FDataflowNode {
    /* 0x0280 */ FDataflowImage Image;
    /* 0x02a8 */ FDataflowImage Red;
    /* 0x02d0 */ FDataflowImage Green;
    /* 0x02f8 */ FDataflowImage Blue;
    /* 0x0320 */ FDataflowImage Alpha;
};

// Size: 0x70
struct FDataflowInput : public FDataflowConnection {
};

// Size: 0x28
struct FDataflowMaterialSelection : public FDataflowSelection {
};

// Size: 0x290
struct FDataflowMathAbsNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathAddNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x290
struct FDataflowMathArcCosNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathArcSinNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathArcTan2Node : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x290
struct FDataflowMathArcTanNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathCeilNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x2a0
struct FDataflowMathClampNode : public FDataflowMathOneInputOperatorNode {
    /* 0x0290 */ FDataflowNumericTypes min;
    /* 0x0298 */ FDataflowNumericTypes max;
};

// Size: 0x290
struct FDataflowMathConstantNode : public FDataflowNode {
    /* 0x0280 */ EDataflowMathConstantsEnum Constant;
    /* 0x0288 */ FDataflowNumericTypes Result;
};

// Size: 0x290
struct FDataflowMathCosNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathCubeNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathDegToRadNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x2a0
struct FDataflowMathDivideNode : public FDataflowMathTwoInputsOperatorNode {
    /* 0x0298 */ FDataflowNumericTypes Fallback;
};

// Size: 0x290
struct FDataflowMathExpNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathFloorNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathFracNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathInverseSquareRootNode : public FDataflowMathOneInputOperatorNode {
    /* 0x0290 */ FDataflowNumericTypes Fallback;
};

// Size: 0x290
struct FDataflowMathLogNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathLogXNode : public FDataflowMathOneInputOperatorNode {
    /* 0x0290 */ FDataflowNumericTypes base;
};

// Size: 0x298
struct FDataflowMathMaximumNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x298
struct FDataflowMathMaximumNode_v2 : public FDataflowNode {
    /* 0x0280 */ TArray<FDataflowNumericTypes> Inputs;
    /* 0x0290 */ FDataflowNumericTypes Result;
};

// Size: 0x298
struct FDataflowMathMinimumNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x298
struct FDataflowMathMinimumNode_v2 : public FDataflowNode {
    /* 0x0280 */ TArray<FDataflowNumericTypes> Inputs;
    /* 0x0290 */ FDataflowNumericTypes Result;
};

// Size: 0x298
struct FDataflowMathMultiplyNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x290
struct FDataflowMathNegateNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathOneInputOperatorNode : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes A;
    /* 0x0288 */ FDataflowNumericTypes Result;
};

// Size: 0x290
struct FDataflowMathOneMinusNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathPowNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x290
struct FDataflowMathRadToDegNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathReciprocalNode : public FDataflowMathOneInputOperatorNode {
    /* 0x0290 */ FDataflowNumericTypes Fallback;
};

// Size: 0x290
struct FDataflowMathRoundNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathSignNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathSinNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathSquareNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathSquareRootNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathSubtractNode : public FDataflowMathTwoInputsOperatorNode {
};

// Size: 0x290
struct FDataflowMathTanNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x290
struct FDataflowMathTruncNode : public FDataflowMathOneInputOperatorNode {
};

// Size: 0x298
struct FDataflowMathTwoInputsOperatorNode : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes A;
    /* 0x0288 */ FDataflowNumericTypes B;
    /* 0x0290 */ FDataflowNumericTypes Result;
};

// Size: 0x280
struct FDataflowNode {
    /* 0x00d8 */ bool bActive;
    /* 0x00d9 */ bool bOverrideColor;
    /* 0x00dc */ FLinearColor OverrideColor;
    /* 0x0230 */ FInstancedPropertyBag FrozenProperties;
    /* 0x0240 */ bool bIsFrozen;
};

// Size: 0x10
struct FDataflowNumericArrayTypes : public FDataflowAnyType {
    /* 0x0000 */ TArray<double> Value;
};

// Size: 0x8
struct FDataflowNumericTypes : public FDataflowAnyType {
    /* 0x0000 */ double Value;
};

// Size: 0x90
struct FDataflowOutput : public FDataflowConnection {
};

// Size: 0x2a0
struct FDataflowOverrideNode : public FDataflowNode {
    /* 0x0280 */ FName Key;
    /* 0x0288 */ FString Default;
    /* 0x0298 */ bool IsOverriden;
};

// Size: 0x40
struct FDataflowPath {
};

// Size: 0x290
struct FDataflowPrintNode : public FDataflowNode {
    /* 0x0280 */ FDataflowStringConvertibleTypes Value;
};

// Size: 0x288
struct FDataflowReRouteNode : public FDataflowNode {
    /* 0x0280 */ FDataflowAnyType Value;
};

// Size: 0x18
struct FDataflowRotationTypes : public FDataflowAnyType {
    /* 0x0000 */ FRotator Value;
};

// Size: 0x298
struct FDataflowSelectNode : public FDataflowNode {
    /* 0x0280 */ TArray<FDataflowAnyType> Inputs;
    /* 0x0290 */ int32_t SelectedIndex;
    /* 0x0294 */ FDataflowAnyType Result;
};

// Size: 0x28
struct FDataflowSelection {
};

// Size: 0x28
struct FDataflowSelectionTypes : public FDataflowAnyType {
    /* 0x0000 */ FDataflowSelection Value;
};

// Size: 0x128
class UDataflowSettings : public UDeveloperSettings {
    /* 0x0038 */ TMap<FName, FNodeColors> NodeColorsMap;
    /* 0x0088 */ TMap<FName, FPinSettings> PinSettingsMap;
    /* 0x00d8 */ FTransformLevelColors TransformLevelColors;
};

// Size: 0x10
struct FDataflowStringArrayTypes : public FDataflowAnyType {
    /* 0x0000 */ TArray<FString> Value;
};

// Size: 0x10
struct FDataflowStringConvertibleTypes : public FDataflowAnyType {
    /* 0x0000 */ FString Value;
};

// Size: 0x10
struct FDataflowStringTypes : public FDataflowAnyType {
    /* 0x0000 */ FString Value;
};

// Size: 0x280
struct FDataflowTerminalNode : public FDataflowNode {
};

// Size: 0x10
struct FDataflowTransformArrayTypes : public FDataflowAnyType {
    /* 0x0000 */ TArray<FTransform> Value;
};

// Size: 0x28
struct FDataflowTransformSelection : public FDataflowSelection {
};

// Size: 0x60
struct FDataflowTransformTypes : public FDataflowAnyType {
    /* 0x0000 */ FTransform Value;
};

// Size: 0x8
struct FDataflowUObjectConvertibleTypes : public FDataflowAnyType {
    /* 0x0000 */ UObject* Value;
};

// Size: 0x2e0
struct FDataflowVectorAddNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes A;
    /* 0x02a0 */ FDataflowVectorTypes B;
    /* 0x02c0 */ FDataflowVectorTypes V;
};

// Size: 0x10
struct FDataflowVectorArrayTypes : public FDataflowAnyType {
    /* 0x0000 */ TArray<FVector4> Value;
};

// Size: 0x2c0
struct FDataflowVectorBreakNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes V;
    /* 0x02a0 */ FDataflowNumericTypes X;
    /* 0x02a8 */ FDataflowNumericTypes Y;
    /* 0x02b0 */ FDataflowNumericTypes Z;
    /* 0x02b8 */ FDataflowNumericTypes W;
};

// Size: 0x2e0
struct FDataflowVectorCrossProductNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes A;
    /* 0x02a0 */ FDataflowVectorTypes B;
    /* 0x02c0 */ FDataflowVectorTypes CrossProduct;
};

// Size: 0x2d0
struct FDataflowVectorDistanceNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes A;
    /* 0x02a0 */ FDataflowVectorTypes B;
    /* 0x02c0 */ FDataflowNumericTypes Distance;
};

// Size: 0x2d0
struct FDataflowVectorDotProductNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes A;
    /* 0x02a0 */ FDataflowVectorTypes B;
    /* 0x02c0 */ FDataflowNumericTypes DotProduct;
};

// Size: 0x2b0
struct FDataflowVectorLengthNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes V;
    /* 0x02a0 */ FDataflowNumericTypes Length;
};

// Size: 0x2b0
struct FDataflowVectorMakeVec2Node : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes X;
    /* 0x0288 */ FDataflowNumericTypes Y;
    /* 0x0290 */ FDataflowVectorTypes Vector2D;
};

// Size: 0x2c0
struct FDataflowVectorMakeVec3Node : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes X;
    /* 0x0288 */ FDataflowNumericTypes Y;
    /* 0x0290 */ FDataflowNumericTypes Z;
    /* 0x02a0 */ FDataflowVectorTypes Vector3d;
};

// Size: 0x2c0
struct FDataflowVectorMakeVec4Node : public FDataflowNode {
    /* 0x0280 */ FDataflowNumericTypes X;
    /* 0x0288 */ FDataflowNumericTypes Y;
    /* 0x0290 */ FDataflowNumericTypes Z;
    /* 0x0298 */ FDataflowNumericTypes W;
    /* 0x02a0 */ FDataflowVectorTypes Vector4d;
};

// Size: 0x2c0
struct FDataflowVectorNormalize : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes V;
    /* 0x02a0 */ FDataflowVectorTypes Normalized;
};

// Size: 0x2d0
struct FDataflowVectorScaleNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes V;
    /* 0x02a0 */ FDataflowNumericTypes Scale;
    /* 0x02b0 */ FDataflowVectorTypes Scaled;
};

// Size: 0x2b0
struct FDataflowVectorSquaredLengthNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes V;
    /* 0x02a0 */ FDataflowNumericTypes SquaredLength;
};

// Size: 0x2e0
struct FDataflowVectorSubtractNode : public FDataflowNode {
    /* 0x0280 */ FDataflowVectorTypes A;
    /* 0x02a0 */ FDataflowVectorTypes B;
    /* 0x02c0 */ FDataflowVectorTypes V;
};

// Size: 0x20
struct FDataflowVectorTypes : public FDataflowAnyType {
    /* 0x0000 */ FVector4 Value;
};

// Size: 0x28
struct FDataflowVertexSelection : public FDataflowSelection {
};

enum class EDataflowImageChannel {
    Red = 0,
    Green = 1,
    Blue = 2,
    Alpha = 3,
    EDataflowImageChannel_MAX = 4,
};

enum class EDataflowImageCombineResolutionOption {
    Lowest = 0,
    Highest = 1,
    UserDefined = 2,
    EDataflowImageCombineResolutionOption_MAX = 3,
};

enum class EDataflowImageResolution {
    Resolution16 = 16,
    Resolution32 = 32,
    Resolution64 = 64,
    Resolution128 = 128,
    Resolution256 = 256,
    Resolution512 = 512,
    Resolution1024 = 1024,
    Resolution2048 = 2048,
    Resolution4096 = 4096,
    Resolution8192 = 8192,
    EDataflowImageResolution_MAX = 8193,
};

enum class EDataflowMathConstantsEnum {
    Dataflow_Math_Constants_Pi = 0,
    Dataflow_Math_Constants_HalfPi = 1,
    Dataflow_Math_Constants_TwoPi = 2,
    Dataflow_Math_Constants_FourPi = 3,
    Dataflow_Math_Constants_InvPi = 4,
    Dataflow_Math_Constants_InvTwoPi = 5,
    Dataflow_Math_Constants_Sqrt2 = 6,
    Dataflow_Math_Constants_InvSqrt2 = 7,
    Dataflow_Math_Constants_Sqrt3 = 8,
    Dataflow_Math_Constants_InvSqrt3 = 9,
    Dataflow_Math_Constants_E = 10,
    Dataflow_Math_Constants_Gamma = 11,
    Dataflow_Math_Constants_GoldenRatio = 12,
    Dataflow_Math_Constants_Max = 13,
};

enum class EDataflowSelectionType {
    Transform = 0,
    Vertices = 1,
    Faces = 2,
    Geometry = 3,
    EDataflowSelectionType_MAX = 4,
};

// Size: 0x20
struct FNodeColors {
    /* 0x0000 */ FLinearColor NodeTitleColor;
    /* 0x0010 */ FLinearColor NodeBodyTintColor;
};

// Size: 0x14
struct FPinSettings {
    /* 0x0000 */ FLinearColor PinColor;
    /* 0x0010 */ float WireThickness;
};

// Size: 0x20
struct FTransformLevelColors {
    /* 0x0000 */ TArray<FLinearColor> LevelColors;
    /* 0x0010 */ FLinearColor BlankColor;
};

// Size: 0x108
class UDataflow : public UEdGraph {
    /* 0x00a8 */ bool bActive;
    /* 0x00b0 */ TArray<UObject*> Targets;
    /* 0x00c0 */ UMaterial* Material;
    /* 0x00c8 */ EDataflowType Type;
    /* 0x00d0 */ FInstancedPropertyBag Variables;
    /* 0x00e0 */ TArray<UDataflowSubGraph*> DataflowSubGraphs;
};

// Size: 0xa8
class UDataflowBaseContent : public UDataflowContextObject {
    /* 0x0078 */ FString DataflowTerminal;
    /* 0x0088 */ UObject* TerminalAsset;
    /* 0x0098 */ bool bIsConstructionDirty;
    /* 0x0099 */ bool bIsSimulationDirty;
};

// Size: 0x28
class UDataflowBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void EvaluateTerminalNodeByName(UDataflow* Dataflow, FName TerminalNodeName, UObject* ResultAsset);
    static bool OverrideDataflowVariableBool(UObject* Asset, FName VariableName, bool VariableValue);
    static bool OverrideDataflowVariableBoolArray(UObject* Asset, FName VariableName, const TArray<bool>& VariableArrayValue);
    static bool OverrideDataflowVariableFloat(UObject* Asset, FName VariableName, float VariableValue);
    static bool OverrideDataflowVariableFloatArray(UObject* Asset, FName VariableName, const TArray<float>& VariableArrayValue);
    static bool OverrideDataflowVariableInt(UObject* Asset, FName VariableName, int64_t VariableValue);
    static bool OverrideDataflowVariableIntArray(UObject* Asset, FName VariableName, const TArray<int32_t>& VariableArrayValue);
    static bool OverrideDataflowVariableObject(UObject* Asset, FName VariableName, UObject* VariableValue);
    static bool OverrideDataflowVariableObjectArray(UObject* Asset, FName VariableName, const TArray<UObject*>& VariableArrayValue);
    static bool RegenerateAssetFromDataflow(UObject* AssetToRegenerate, bool bRegenerateDependentAssets);
};

// Size: 0x3c0
struct FDataflowCallSubGraphNode : public FDataflowNode {
    /* 0x0290 */ FGuid SubGraphGuid;
    /* 0x02a0 */ FDataflowDynamicConnections DynamicInputs;
    /* 0x0318 */ FInstancedPropertyBag InputsPropertyBag;
    /* 0x0328 */ FDataflowDynamicConnections DynamicOutputs;
    /* 0x03a0 */ FInstancedPropertyBag OutputsPropertyBag;
};

// Size: 0x28
class IDataflowContentOwner : public UInterface {
};

// Size: 0x78
class UDataflowContextObject : public UObject {
    /* 0x0038 */ UDataflowEdNode* SelectedNode;
    /* 0x0058 */ UDataflow* DataflowGraph;
};

// Size: 0x580
class UDataflowDebugDrawComponent : public UDebugDrawComponent {
};

// Size: 0x78
struct FDataflowDynamicConnections {
    /* 0x0000 */ TArray<FDataflowAllTypes> DynamicProperties;
};

// Size: 0xd8
class UDataflowEdNode : public UEdGraphNode {
    /* 0x00b8 */ bool bRenderInAssetEditor;
    /* 0x00b9 */ bool bRenderWireframeInAssetEditor;
    /* 0x00ba */ bool bCanEnableRenderWireframe;
};

// Size: 0x2b8
struct FDataflowImageToTextureNode : public FDataflowNode {
    /* 0x0280 */ FDataflowImage Image;
    /* 0x02a8 */ FName TextureName;
    /* 0x02b0 */ UTexture2D* TransientTexture;
};

// Size: 0x40
struct FDataflowInstance {
    /* 0x0000 */ UDataflow* DataflowAsset;
    /* 0x0008 */ FName DataflowTerminal;
    /* 0x0010 */ FDataflowVariableOverrides VariableOverrides;
    /* 0x0038 */ UObject* Owner;
};

// Size: 0x28
class IDataflowInstanceInterface : public UInterface {
};

// Size: 0x40
class UDataflowMesh : public UObject {
    /* 0x0030 */ TArray<UMaterialInterface*> Materials;
};

// Size: 0x18
struct FDataflowNodeDebugDrawSettings {
    /* 0x0000 */ EDataflowDebugDrawRenderType RenderType;
    /* 0x0001 */ bool bTranslucent;
    /* 0x0004 */ FLinearColor Color;
    /* 0x0014 */ float LineWidthMultiplier;
};

// Size: 0x40
struct FDataflowNodeSphereCoveringDebugDrawSettings {
    /* 0x0000 */ bool bDisplaySphereCovering;
    /* 0x0001 */ EDataflowDebugDrawRenderType RenderType;
    /* 0x0002 */ bool bTranslucent;
    /* 0x0004 */ float LineWidthMultiplier;
    /* 0x0008 */ EDataflowSphereCoveringColorMethod ColorMethod;
    /* 0x000c */ FLinearColor Color;
    /* 0x001c */ int32_t ColorRandomSeed;
    /* 0x0020 */ FLinearColor ColorA;
    /* 0x0030 */ FLinearColor ColorB;
};

// Size: 0x24
struct FDataflowPreviewCacheParams {
    /* 0x0000 */ int32_t FrameRate;
    /* 0x0004 */ int32_t SubframeRate;
    /* 0x0008 */ bool bCanEditSubframeRate;
    /* 0x000c */ FVector2f TimeRange;
    /* 0x0014 */ bool bRestartSimulation;
    /* 0x0018 */ FVector2f RestartTimeRange;
    /* 0x0020 */ bool bAsyncCaching;
};

// Size: 0x68
struct FDataflowProxyElement : public FDataflowBaseElement {
};

// Size: 0xc0
class UDataflowSkeletalContent : public UDataflowBaseContent {
    /* 0x00a8 */ USkeletalMesh* SkeletalMesh;
    /* 0x00b0 */ UAnimationAsset* AnimationAsset;
};

// Size: 0x78
class UDataflowSubGraph : public UEdGraph {
    /* 0x0060 */ FGuid SubGraphGuid;
    /* 0x0070 */ bool bIsForEach;
};

// Size: 0x288
struct FDataflowSubGraphGetCurrentIndexNode : public FDataflowNode {
    /* 0x0280 */ int32_t Index;
};

// Size: 0x310
struct FDataflowSubGraphInputNode : public FDataflowNode {
    /* 0x0288 */ FDataflowDynamicConnections DynamicConnections;
    /* 0x0300 */ FInstancedPropertyBag PropertyBag;
};

// Size: 0x310
struct FDataflowSubGraphOutputNode : public FDataflowNode {
    /* 0x0288 */ FDataflowDynamicConnections DynamicConnections;
    /* 0x0300 */ FInstancedPropertyBag PropertyBag;
};

// Size: 0x2b0
struct FDataflowTextureTerminalNode : public FDataflowTerminalNode {
    /* 0x0280 */ FDataflowImage Image;
    /* 0x02a8 */ UTexture2D* TextureAsset;
};

// Size: 0x2b0
struct FDataflowTextureToImageNode : public FDataflowNode {
    /* 0x0280 */ UTexture2D* TextureAsset;
    /* 0x0288 */ FDataflowImage Image;
};

// Size: 0x28
struct FDataflowVariableOverrides {
    /* 0x0000 */ FInstancedPropertyBag Variables;
    /* 0x0010 */ TArray<FGuid> OverriddenVariableGuids;
};

enum class EDataflowDebugDrawRenderType {
    Wireframe = 0,
    Shaded = 1,
    EDataflowDebugDrawRenderType_MAX = 2,
};

enum class EDataflowSphereCoveringColorMethod {
    Single = 0,
    ColorByRadius = 1,
    Random = 2,
    EDataflowSphereCoveringColorMethod_MAX = 3,
};

enum class EDataflowType {
    Construction = 0,
    Simulation = 1,
    EDataflowType_MAX = 2,
};

// Size: 0x2b8
struct FGetDataflowVariableNode : public FDataflowNode {
    /* 0x0280 */ FDataflowAnyType Value;
    /* 0x0288 */ FInstancedPropertyBag VariablePropertyBag;
    /* 0x0298 */ FName VariableName;
};

// Size: 0x20
struct FStringValuePair {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ FString Value;
};

// Size: 0x20
struct FCollectionAttributeKey {
    /* 0x0000 */ FString Attribute;
    /* 0x0010 */ FString Group;
};

// Size: 0x2b0
class ADataflowActor : public AActor {
    /* 0x02a8 */ UDataflowComponent* DataflowComponent;
};

// Size: 0x670
class UDataflowComponent : public UPrimitiveComponent {
};

// Size: 0x10
struct FDataflowDynamicMeshArray : public FDataflowAnyType {
    /* 0x0000 */ TArray<UDynamicMesh*> Value;
};

// Size: 0x2c0
struct FBreakAttributeKeyDataflowNode : public FDataflowNode {
    /* 0x0280 */ FCollectionAttributeKey AttributeKeyIn;
    /* 0x02a0 */ FString AttributeOut;
    /* 0x02b0 */ FString GroupOut;
};

// Size: 0x380
struct FDataflowCollectionAddScalarVertexPropertyNode : public FDataflowNode {
    /* 0x0280 */ FManagedArrayCollection Collection;
    /* 0x0330 */ FString Name;
    /* 0x0340 */ FCollectionAttributeKey AttributeKey;
    /* 0x0360 */ TArray<float> VertexWeights;
    /* 0x0370 */ FScalarVertexPropertyGroup TargetGroup;
    /* 0x0378 */ EDataflowWeightMapOverrideType OverrideType;
};

// Size: 0x3e8
struct FDataflowCollectionEditSkinWeightsNode : public FDataflowPrimitiveNode {
    /* 0x0280 */ FManagedArrayCollection Collection;
    /* 0x0330 */ FString BoneIndicesName;
    /* 0x0340 */ FString BoneWeightsName;
    /* 0x0350 */ FScalarVertexPropertyGroup VertexGroup;
    /* 0x0358 */ FCollectionAttributeKey BoneIndicesKey;
    /* 0x0378 */ FCollectionAttributeKey BoneWeightsKey;
    /* 0x0398 */ USkeleton* ObjectSkeleton;
    /* 0x03a0 */ bool bCompressSkinWeights;
    /* 0x03a8 */ TArray<FDataflowSkinWeightData> SkinWeights;
    /* 0x03d0 */ TArray<USkeletalMesh*> SkeletalMeshes;
};

// Size: 0x10
struct FDataflowFunctionProperty {
};

// Size: 0x280
struct FDataflowPrimitiveNode : public FDataflowNode {
};

// Size: 0x20
struct FDataflowSkinWeightData {
    /* 0x0000 */ TArray<float> BoneWeights;
    /* 0x0010 */ TArray<int32_t> BoneIndices;
};

enum class EDataflowWeightMapOverrideType {
    ReplaceAll = 0,
    AddDifference = 1,
    ReplaceChanged = 2,
    EDataflowWeightMapOverrideType_MAX = 3,
};

// Size: 0x298
struct FFloatOverrideDataflowNode : public FDataflowNode {
    /* 0x0280 */ FName PropertyName;
    /* 0x0288 */ FName KeyName;
    /* 0x0290 */ float ValueOut;
};

// Size: 0x290
struct FGetPhysicsAssetFromSkeletalMeshDataflowNode : public FDataflowNode {
    /* 0x0280 */ USkeletalMesh* SkeletalMesh;
    /* 0x0288 */ UPhysicsAsset* PhysicsAsset;
};

// Size: 0x290
struct FGetSkeletalMeshDataflowNode : public FDataflowNode {
    /* 0x0280 */ USkeletalMesh* SkeletalMesh;
    /* 0x0288 */ FName PropertyName;
};

// Size: 0x290
struct FGetSkeletonDataflowNode : public FDataflowNode {
    /* 0x0280 */ USkeleton* Skeleton;
    /* 0x0288 */ FName PropertyName;
};

// Size: 0x290
struct FGetStaticMeshDataflowNode : public FDataflowNode {
    /* 0x0280 */ UStaticMesh* StaticMesh;
    /* 0x0288 */ FName PropertyName;
};

// Size: 0x2c0
struct FMakeAttributeKeyDataflowNode : public FDataflowNode {
    /* 0x0280 */ FString GroupIn;
    /* 0x0290 */ FString AttributeIn;
    /* 0x02a0 */ FCollectionAttributeKey AttributeKeyOut;
};

// Size: 0x8
struct FScalarVertexPropertyGroup {
    /* 0x0000 */ FName Name;
};

// Size: 0x2a0
struct FSelectionSetDataflowNode : public FDataflowNode {
    /* 0x0280 */ FString Indices;
    /* 0x0290 */ TArray<int32_t> IndicesOut;
};

// Size: 0x2a0
struct FSkeletalMeshBoneDataflowNode : public FDataflowNode {
    /* 0x0280 */ FName BoneName;
    /* 0x0288 */ USkeletalMesh* SkeletalMesh;
    /* 0x0290 */ int32_t BoneIndexOut;
    /* 0x0294 */ FName PropertyName;
};

// Size: 0x2f0
struct FSkeletalMeshReferenceTransformDataflowNode : public FDataflowNode {
    /* 0x0280 */ USkeletalMesh* SkeletalMeshIn;
    /* 0x0288 */ int32_t BoneIndexIn;
    /* 0x0290 */ FTransform TransformOut;
};

// Size: 0x2a0
struct FAdvancePhysicsSolversDataflowNode : public FDataflowSimulationNode {
    /* 0x0280 */ FDataflowSimulationTime SimulationTime;
    /* 0x0290 */ TArray<FDataflowSimulationProperty> PhysicsSolvers;
};

// Size: 0x28
class UDataflowCollisionObjectInterface : public IDataflowSimulationInterface {
};

// Size: 0x78
struct FDataflowCollisionObjectProxy : public FDataflowSimulationProxy {
};

// Size: 0x28
class UDataflowConstraintObjectInterface : public IDataflowSimulationInterface {
};

// Size: 0x78
struct FDataflowConstraintObjectProxy : public FDataflowSimulationProxy {
};

// Size: 0x280
struct FDataflowExecutionNode : public FDataflowSimulationNode {
};

// Size: 0x28
class IDataflowGeometryCachable : public UInterface {
};

// Size: 0x280
struct FDataflowInvalidNode : public FDataflowSimulationNode {
};

// Size: 0x28
class UDataflowPhysicsObjectInterface : public IDataflowSimulationInterface {
};

// Size: 0x78
struct FDataflowPhysicsObjectProxy : public FDataflowSimulationProxy {
};

// Size: 0x28
class UDataflowPhysicsSolverInterface : public IDataflowSimulationInterface {
};

// Size: 0x78
struct FDataflowPhysicsSolverProxy : public FDataflowSimulationProxy {
};

// Size: 0x28
class IDataflowSimulationActor : public UInterface {

    void PostDataflowSimulationTick(const float SimulationTime, const float deltaTime);
    void PreDataflowSimulationTick(const float SimulationTime, const float deltaTime);
};

// Size: 0x58
struct FDataflowSimulationAsset {
    /* 0x0000 */ UDataflow* DataflowAsset;
    /* 0x0008 */ TSet<FString> SimulationGroups;
};

// Size: 0x28
class IDataflowSimulationInterface : public UInterface {
};

// Size: 0xa8
class UDataflowSimulationManager : public UTickableWorldSubsystem {
};

// Size: 0x280
struct FDataflowSimulationNode : public FDataflowNode {
};

// Size: 0x8
struct FDataflowSimulationProperty {
};

// Size: 0x78
struct FDataflowSimulationProxy {
};

// Size: 0xc
struct FDataflowSimulationTime {
    /* 0x0000 */ float deltaTime;
    /* 0x0004 */ float CurrentTime;
    /* 0x0008 */ float TimeOffset;
};

// Size: 0x2b0
struct FFilterSimulationProxiesDataflowNode : public FDataflowSimulationNode {
    /* 0x0280 */ TArray<FDataflowSimulationProperty> SimulationProxies;
    /* 0x0290 */ TArray<FDataflowSimulationProperty> FilteredProxies;
    /* 0x02a0 */ TArray<FString> SimulationGroups;
};

// Size: 0x2a0
struct FGetPhysicsSolversDataflowNode : public FDataflowInvalidNode {
    /* 0x0280 */ TArray<FDataflowSimulationProperty> PhysicsSolvers;
    /* 0x0290 */ TArray<FString> SimulationGroups;
};

// Size: 0x290
struct FGetSimulationTimeDataflowNode : public FDataflowInvalidNode {
    /* 0x0280 */ FDataflowSimulationTime SimulationTime;
};

// Size: 0x290
struct FSimulationProxiesTerminalDataflowNode : public FDataflowExecutionNode {
    /* 0x0280 */ TArray<FDataflowSimulationProperty> SimulationProxies;
};

// Size: 0x38
class UDeveloperSettings : public UObject {
};

// Size: 0x38
class UDeveloperSettingsBackedByCVars : public UDeveloperSettings {
};

// Size: 0x10
struct FPerPlatformSettings {
    /* 0x0000 */ TArray<UPlatformSettings*> Settings;
};

// Size: 0x40
class UPlatformSettings : public UObject {
};

// Size: 0x58
struct FPlatformSettingsInstances {
    /* 0x0000 */ UPlatformSettings* PlatformInstance;
    /* 0x0008 */ TMap<FName, UPlatformSettings*> OtherPlatforms;
};

// Size: 0x80
class UPlatformSettingsManager : public UObject {
    /* 0x0028 */ TMap<UClass*, FPlatformSettingsInstances> SettingsMap;
};

// Size: 0x28
struct FA2CSPose : public FA2Pose {
    /* 0x0018 */ TArray<uint8_t> ComponentSpaceFlags;
};

// Size: 0x10
struct FA2Pose {
    /* 0x0000 */ TArray<FTransform> Bones;
};

// Size: 0x60
class UAISystemBase : public UObject {
    /* 0x0028 */ FSoftClassPath AISystemClassName;
    /* 0x0048 */ FName AISystemModuleName;
    /* 0x0058 */ bool bInstantiateAISystemOnClient;
};

// Size: 0xc
struct FActivateDevicePropertyParams {
    /* 0x0000 */ FPlatformUserId UserId;
    /* 0x0004 */ FInputDeviceId DeviceID;
    /* 0x0008 */ bool bLooping;
    /* 0x0008 */ bool bIgnoreTimeDilation;
    /* 0x0008 */ bool bPlayWhilePaused;
};

// Size: 0xa0
struct FActivatedCells {
    /* 0x0000 */ TSet<UWorldPartitionRuntimeCell*> Cells;
};

// Size: 0x18
struct FActiveCameraShakeInfo {
    /* 0x0000 */ UCameraShakeBase* ShakeInstance;
    /* 0x0008 */ TWeakObjectPtr<UCameraShakeSourceComponent> ShakeSource;
    /* 0x0010 */ bool bIsCustomInitialized;
};

// Size: 0x20
struct FActiveDeviceProperty {
    /* 0x0000 */ TWeakObjectPtr<UInputDeviceProperty> Property;
};

// Size: 0x70
struct FActiveForceFeedbackEffect {
    /* 0x0000 */ UForceFeedbackEffect* ForceFeedbackEffect;
    /* 0x0020 */ TSet<FInputDevicePropertyHandle> ActiveDeviceProperties;
};

// Size: 0x48
struct FActiveHapticFeedbackEffect {
    /* 0x0000 */ UHapticFeedbackEffect_Base* HapticEffect;
};

// Size: 0x28
class IActiveSoundUpdateInterface : public UInterface {
};

// Size: 0x2a8
class AActor : public UObject {
    /* 0x0028 */ FActorTickFunction PrimaryActorTick;
    /* 0x0058 */ bool bNetTemporary;
    /* 0x0058 */ bool bOnlyRelevantToOwner;
    /* 0x0058 */ bool bAlwaysRelevant;
    /* 0x0058 */ bool bReplicateMovement;
    /* 0x0058 */ bool bCallPreReplication;
    /* 0x0058 */ bool bCallPreReplicationForReplay;
    /* 0x0058 */ bool bHidden;
    /* 0x0059 */ bool bTearOff;
    /* 0x0059 */ bool bForceNetAddressable;
    /* 0x0059 */ bool bExchangedRoles;
    /* 0x0059 */ bool bNetLoadOnClient;
    /* 0x0059 */ bool bNetUseOwnerRelevancy;
    /* 0x0059 */ bool bRelevantForNetworkReplays;
    /* 0x0059 */ bool bRelevantForLevelBounds;
    /* 0x0059 */ bool bReplayRewindable;
    /* 0x005a */ bool bAllowTickBeforeBeginPlay;
    /* 0x005a */ bool bAutoDestroyWhenFinished;
    /* 0x005a */ bool bCanBeDamaged;
    /* 0x005a */ bool bBlockInput;
    /* 0x005a */ bool bCollideWhenPlacing;
    /* 0x005a */ bool bFindCameraComponentWhenViewTarget;
    /* 0x005a */ bool bGenerateOverlapEventsDuringLevelStreaming;
    /* 0x005a */ bool bIgnoresOriginShifting;
    /* 0x005b */ bool bEnableAutoLODGeneration;
    /* 0x005b */ bool bIsEditorOnlyActor;
    /* 0x005b */ bool bReplicates;
    /* 0x005b */ bool bCanBeInCluster;
    /* 0x005b */ bool bAllowReceiveTickEventOnDedicatedServer;
    /* 0x005b */ bool bReplicateUsingRegisteredSubObjectList;
    /* 0x005d */ bool bActorEnableCollision;
    /* 0x005d */ bool bActorIsBeingDestroyed;
    /* 0x005d */ bool bAsyncPhysicsTickEnabled;
    /* 0x005e */ EActorUpdateOverlapsMethod UpdateOverlapsMethodDuringLevelStreaming;
    /* 0x005f */ EActorUpdateOverlapsMethod DefaultUpdateOverlapsMethodDuringLevelStreaming;
    /* 0x0060 */ uint8_t RemoteRole;
    /* 0x0064 */ float InitialLifeSpan;
    /* 0x0068 */ float CustomTimeDilation;
    /* 0x006c */ int32_t RayTracingGroupId;
    /* 0x0070 */ FRepAttachment AttachmentReplication;
    /* 0x00d0 */ FRepMovement ReplicatedMovement;
    /* 0x0158 */ AActor* Owner;
    /* 0x0160 */ FName NetDriverName;
    /* 0x0168 */ uint8_t Role;
    /* 0x0169 */ uint8_t NetDormancy;
    /* 0x016a */ ESpawnActorCollisionHandlingMethod SpawnCollisionHandlingMethod;
    /* 0x016b */ uint8_t AutoReceiveInput;
    /* 0x016c */ int32_t InputPriority;
    /* 0x0178 */ UInputComponent* InputComponent;
    /* 0x0180 */ int32_t NetTag;
    /* 0x0184 */ float NetCullDistanceSquared;
    /* 0x0188 */ float NetUpdateFrequency;
    /* 0x018c */ float MinNetUpdateFrequency;
    /* 0x0190 */ float NetPriority;
    /* 0x0194 */ EPhysicsReplicationMode PhysicsReplicationMode;
    /* 0x01a0 */ APawn* Instigator;
    /* 0x01a8 */ TArray<AActor*> Children;
    /* 0x01b8 */ USceneComponent* RootComponent;
    /* 0x01c8 */ TArray<FName> Layers;
    /* 0x01d8 */ TWeakObjectPtr<UChildActorComponent> ParentComponent;
    /* 0x01e0 */ TArray<FName> Tags;
    /* 0x01f0 */ FMulticastSparseDelegate OnTakeAnyDamage;
    /* 0x01f1 */ FMulticastSparseDelegate OnTakePointDamage;
    /* 0x01f2 */ FMulticastSparseDelegate OnTakeRadialDamage;
    /* 0x01f3 */ FMulticastSparseDelegate OnActorBeginOverlap;
    /* 0x01f4 */ FMulticastSparseDelegate OnActorEndOverlap;
    /* 0x01f5 */ FMulticastSparseDelegate OnBeginCursorOver;
    /* 0x01f6 */ FMulticastSparseDelegate OnEndCursorOver;
    /* 0x01f7 */ FMulticastSparseDelegate OnClicked;
    /* 0x01f8 */ FMulticastSparseDelegate OnReleased;
    /* 0x01f9 */ FMulticastSparseDelegate OnInputTouchBegin;
    /* 0x01fa */ FMulticastSparseDelegate OnInputTouchEnd;
    /* 0x01fb */ FMulticastSparseDelegate OnInputTouchEnter;
    /* 0x01fc */ FMulticastSparseDelegate OnInputTouchLeave;
    /* 0x01fd */ FMulticastSparseDelegate OnActorHit;
    /* 0x01fe */ FMulticastSparseDelegate OnDestroyed;
    /* 0x01ff */ FMulticastSparseDelegate OnEndPlay;
    /* 0x0280 */ TArray<UActorComponent*> InstanceComponents;
    /* 0x0290 */ TArray<UActorComponent*> BlueprintCreatedComponents;

    bool ActorHasTag(FName Tag) const;
    UActorComponent* AddComponent(FName TemplateName, bool bManualAttachment, const FTransform& RelativeTransform, const UObject* ComponentTemplateContext, bool bDeferredFinish);
    UActorComponent* AddComponentByClass(UClass* Class, bool bManualAttachment, const FTransform& RelativeTransform, bool bDeferredFinish);
    void AddTickPrerequisiteActor(AActor* PrerequisiteActor);
    void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
    bool CanTriggerResimulation() const;
    void CreateInputComponent(UClass* InputComponentToCreate);
    void DetachRootComponentFromParent(bool bMaintainWorldPosition);
    void DisableInput(APlayerController* PlayerController);
    void EnableInput(APlayerController* PlayerController);
    UActorComponent* FindComponentByTag(UClass* ComponentClass, FName Tag) const;
    void FinishAddComponent(UActorComponent* Component, bool bManualAttachment, const FTransform& RelativeTransform);
    void FlushNetDormancy();
    void ForceNetUpdate();
    void GetActorBounds(bool bOnlyCollidingComponents, FVector& Origin, FVector& BoxExtent, bool bIncludeFromChildActors) const;
    bool GetActorEnableCollision() const;
    void GetActorEyesViewPoint(FVector& OutLocation, FRotator& OutRotation) const;
    FVector GetActorForwardVector() const;
    FVector GetActorRelativeScale3D() const;
    FVector GetActorRightVector() const;
    FVector GetActorScale3D() const;
    float GetActorTickInterval() const;
    float GetActorTimeDilation() const;
    FVector GetActorUpVector() const;
    void GetAllChildActors(TArray<AActor*>& ChildActors, bool bIncludeDescendants) const;
    AActor* GetAttachParentActor() const;
    FName GetAttachParentSocketName() const;
    void GetAttachedActors(TArray<AActor*>& OutActors, bool bResetArray, bool bRecursivelyIncludeAttachedActors) const;
    UActorComponent* GetComponentByClass(UClass* ComponentClass) const;
    TArray<UActorComponent*> GetComponentsByInterface(UClass* Interface) const;
    TArray<UActorComponent*> GetComponentsByTag(UClass* ComponentClass, FName Tag) const;
    float GetDistanceTo(const AActor* OtherActor) const;
    float GetDotProductTo(const AActor* OtherActor) const;
    float GetGameTimeSinceCreation() const;
    float GetHorizontalDistanceTo(const AActor* OtherActor) const;
    float GetHorizontalDotProductTo(const AActor* OtherActor) const;
    float GetInputAxisKeyValue(const FKey InputAxisKey) const;
    float GetInputAxisValue(const FName InputAxisName) const;
    FVector GetInputVectorAxisValue(const FKey InputAxisKey) const;
    APawn* GetInstigator() const;
    AController* GetInstigatorController() const;
    ULevel* GetLevel() const;
    FTransform GetLevelTransform() const;
    float GetLifeSpan() const;
    uint8_t GetLocalRole() const;
    float GetMinNetUpdateFrequency() const;
    float GetNetCullDistanceSquared() const;
    float GetNetUpdateFrequency() const;
    void GetOverlappingActors(TArray<AActor*>& OverlappingActors, UClass* ClassFilter) const;
    void GetOverlappingComponents(TArray<UPrimitiveComponent*>& OverlappingComponents) const;
    AActor* GetOwner() const;
    AActor* GetParentActor() const;
    UChildActorComponent* GetParentComponent() const;
    EPhysicsReplicationMode GetPhysicsReplicationMode();
    int32_t GetRayTracingGroupId() const;
    uint8_t GetRemoteRole() const;
    float GetResimulationThreshold() const;
    float GetSquaredDistanceTo(const AActor* OtherActor) const;
    float GetSquaredHorizontalDistanceTo(const AActor* OtherActor) const;
    bool GetTickableWhenPaused();
    FTransform GetTransform() const;
    FVector GetVelocity() const;
    float GetVerticalDistanceTo(const AActor* OtherActor) const;
    bool HasAuthority() const;
    bool IsActorBeingDestroyed() const;
    bool IsActorTickEnabled() const;
    bool IsChildActor() const;
    bool IsOverlappingActor(const AActor* Other) const;
    void K2_AddActorLocalOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorLocalRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorLocalTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorWorldOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorWorldRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorWorldTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddActorWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AttachRootComponentTo(USceneComponent* InParent, FName InSocketName, uint8_t AttachLocationType, bool bWeldSimulatedBodies);
    void K2_AttachRootComponentToActor(AActor* InParentActor, FName InSocketName, uint8_t AttachLocationType, bool bWeldSimulatedBodies);
    bool K2_AttachToActor(AActor* ParentActor, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
    bool K2_AttachToComponent(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
    void K2_DestroyActor();
    void K2_DetachFromActor(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule);
    FVector K2_GetActorLocation() const;
    FRotator K2_GetActorRotation() const;
    TArray<UActorComponent*> K2_GetComponentsByClass(UClass* ComponentClass) const;
    USceneComponent* K2_GetRootComponent() const;
    void K2_OnBecomeViewTarget(APlayerController* PC);
    void K2_OnEndViewTarget(APlayerController* PC);
    void K2_OnReset();
    bool K2_SetActorLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    bool K2_SetActorLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetActorRelativeLocation(FVector NewRelativeLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetActorRelativeRotation(FRotator NewRelativeRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetActorRelativeTransform(const FTransform& NewRelativeTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    bool K2_SetActorRotation(FRotator NewRotation, bool bTeleportPhysics);
    bool K2_SetActorTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    bool K2_TeleportTo(FVector DestLocation, FRotator DestRotation);
    void MakeNoise(float Loudness, APawn* NoiseInstigator, FVector NoiseLocation, float MaxRange, FName Tag);
    void OnRep_AttachmentReplication();
    void OnRep_Instigator();
    void OnRep_Owner();
    void OnRep_ReplicateMovement();
    void OnRep_ReplicatedMovement();
    void PrestreamTextures(float Seconds, bool bEnableStreaming, int32_t CinematicTextureGroups);
    void ReceiveActorBeginCursorOver();
    void ReceiveActorBeginOverlap(AActor* OtherActor);
    void ReceiveActorEndCursorOver();
    void ReceiveActorEndOverlap(AActor* OtherActor);
    void ReceiveActorOnClicked(FKey ButtonPressed);
    void ReceiveActorOnInputTouchBegin(const uint8_t FingerIndex);
    void ReceiveActorOnInputTouchEnd(const uint8_t FingerIndex);
    void ReceiveActorOnInputTouchEnter(const uint8_t FingerIndex);
    void ReceiveActorOnInputTouchLeave(const uint8_t FingerIndex);
    void ReceiveActorOnReleased(FKey ButtonReleased);
    void ReceiveAnyDamage(float Damage, const UDamageType* DamageType, AController* InstigatedBy, AActor* DamageCauser);
    void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
    void ReceiveBeginPlay();
    void ReceiveDestroyed();
    void ReceiveEndPlay(uint8_t EndPlayReason);
    void ReceiveHit(UPrimitiveComponent* MyComp, AActor* Other, UPrimitiveComponent* OtherComp, bool bSelfMoved, FVector HitLocation, FVector HitNormal, FVector NormalImpulse, const FHitResult& Hit);
    void ReceivePointDamage(float Damage, const UDamageType* DamageType, FVector HitLocation, FVector HitNormal, UPrimitiveComponent* HitComponent, FName BoneName, FVector ShotFromDirection, AController* InstigatedBy, AActor* DamageCauser, const FHitResult& HitInfo);
    void ReceiveRadialDamage(float DamageReceived, const UDamageType* DamageType, FVector Origin, const FHitResult& HitInfo, AController* InstigatedBy, AActor* DamageCauser);
    void ReceiveTick(float DeltaSeconds);
    void RegisterAsFocalPointInPhysicsReplicationLOD() const;
    void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor);
    void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
    void SetActorEnableCollision(bool bNewActorEnableCollision);
    void SetActorHiddenInGame(bool bNewHidden);
    void SetActorRelativeScale3D(FVector NewRelativeScale);
    void SetActorScale3D(FVector NewScale3D);
    void SetActorTickEnabled(bool bEnabled);
    void SetActorTickInterval(float TickInterval);
    void SetAutoDestroyWhenFinished(bool bVal);
    void SetLifeSpan(float InLifespan);
    void SetMinNetUpdateFrequency(float MinFrequency);
    void SetNetCullDistanceSquared(float DistanceSq);
    void SetNetDormancy(uint8_t NewDormancy);
    void SetNetUpdateFrequency(float Frequency);
    void SetOwner(AActor* NewOwner);
    void SetPhysicsReplicationMode(const EPhysicsReplicationMode ReplicationMode);
    void SetRayTracingGroupId(int32_t InRaytracingGroupId);
    void SetReplicateMovement(bool bInReplicateMovement);
    void SetReplicates(bool bInReplicates);
    void SetTickGroup(uint8_t NewTickGroup);
    void SetTickableWhenPaused(bool bTickableWhenPaused);
    void TearOff();
    void UnregisterAsFocalPointInPhysicsReplicationLOD() const;
    void UserConstructionScript();
    bool WasRecentlyRendered(float Tolerance) const;
};

// Size: 0x298
class UActorChannel : public UChannel {
    /* 0x0068 */ AActor* Actor;
    /* 0x0160 */ TArray<UObject*> CreateSubObjects;
};

// Size: 0xb8
class UActorComponent : public UObject {
    /* 0x0038 */ FActorComponentTickFunction PrimaryComponentTick;
    /* 0x0068 */ TArray<FName> ComponentTags;
    /* 0x0078 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x008c */ int32_t UCSSerializationIndex;
    /* 0x0094 */ bool bNetAddressable;
    /* 0x0094 */ bool bReplicateUsingRegisteredSubObjectList;
    /* 0x0094 */ bool bReplicates;
    /* 0x0096 */ bool bAutoActivate;
    /* 0x0096 */ bool bIsActive;
    /* 0x0096 */ bool bEditableWhenInherited;
    /* 0x0096 */ bool bCanEverAffectNavigation;
    /* 0x0097 */ bool bIsEditorOnly;
    /* 0x00b1 */ EComponentCreationMethod CreationMethod;
    /* 0x00b2 */ FMulticastSparseDelegate OnComponentActivated;
    /* 0x00b3 */ FMulticastSparseDelegate OnComponentDeactivated;

    void Activate(bool bReset);
    void AddTickPrerequisiteActor(AActor* PrerequisiteActor);
    void AddTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
    bool ComponentHasTag(FName Tag) const;
    void Deactivate();
    float GetComponentTickInterval() const;
    AActor* GetOwner() const;
    bool IsActive() const;
    bool IsBeingDestroyed() const;
    bool IsComponentTickEnabled() const;
    void K2_DestroyComponent(UObject* Object);
    void OnRep_IsActive();
    void ReceiveAsyncPhysicsTick(float DeltaSeconds, float SimSeconds);
    void ReceiveBeginPlay();
    void ReceiveEndPlay(uint8_t EndPlayReason);
    void ReceiveTick(float DeltaSeconds);
    void RemoveTickPrerequisiteActor(AActor* PrerequisiteActor);
    void RemoveTickPrerequisiteComponent(UActorComponent* PrerequisiteComponent);
    void SetActive(bool bNewActive, bool bReset);
    void SetAutoActivate(bool bNewAutoActivate);
    void SetComponentTickEnabled(bool bEnabled);
    void SetComponentTickInterval(float TickInterval);
    void SetComponentTickIntervalAndCooldown(float TickInterval);
    void SetIsReplicated(bool ShouldReplicate);
    void SetTickGroup(uint8_t NewTickGroup);
    void SetTickableWhenPaused(bool bTickableWhenPaused);
    void ToggleActive();
};

// Size: 0x68
struct FActorComponentInstanceData : public FInstanceCacheDataBase {
    /* 0x0058 */ UObject* SourceComponentTemplate;
    /* 0x0060 */ EComponentCreationMethod SourceComponentCreationMethod;
    /* 0x0064 */ int32_t SourceComponentTypeSerializedIndex;
};

// Size: 0x10
struct FActorComponentInstanceSourceInfo {
    /* 0x0000 */ UObject* SourceComponentTemplate;
    /* 0x0008 */ EComponentCreationMethod SourceComponentCreationMethod;
    /* 0x000c */ int32_t SourceComponentTypeSerializedIndex;
};

// Size: 0x30
struct FActorComponentTickFunction : public FTickFunction {
};

// Size: 0x78
class UActorContainer : public UObject {
    /* 0x0028 */ TMap<FName, AActor*> Actors;
};

// Size: 0x10
struct FActorContainerID {
    /* 0x0000 */ FGuid Guid;
};

// Size: 0x10
struct FActorContainerPath {
    /* 0x0000 */ TArray<FGuid> ContainerGuids;
};

// Size: 0x8
struct FActorDataLayer {
    /* 0x0000 */ FName Name;
};

// Size: 0xb0
struct FActorDesc {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ UClass* NativeClass;
    /* 0x0018 */ FSoftObjectPath Class;
    /* 0x0038 */ FName Name;
    /* 0x0040 */ FName Label;
    /* 0x0048 */ FBox Bounds;
    /* 0x0080 */ FName RuntimeGrid;
    /* 0x0088 */ bool bIsSpatiallyLoaded;
    /* 0x0089 */ bool bActorIsEditorOnly;
    /* 0x008c */ FName ActorPackage;
    /* 0x0094 */ FName ActorPath;
    /* 0x00a0 */ TArray<FSoftObjectPath> DataLayerAssets;
};

// Size: 0x28
class UActorDescContainer : public UObject {
};

// Size: 0x28
class UActorDescContainerInstance : public UObject {
};

// Size: 0x30
class UActorDescContainerSubsystem : public UEngineSubsystem {
};

// Size: 0x30
class UActorElementAssetDataInterface : public UObject {
};

// Size: 0x30
class UActorElementCounterInterface : public UObject {
};

// Size: 0x30
class UActorElementHierarchyInterface : public UObject {
};

// Size: 0x30
class UActorElementObjectInterface : public UObject {
};

// Size: 0x30
class UActorElementSelectionInterface : public UObject {
};

// Size: 0x30
class UActorElementWorldInterface : public UObject {
};

// Size: 0x28
class UActorFolder : public UObject {
};

// Size: 0x50
struct FActorFolderSet {
    /* 0x0000 */ TSet<UActorFolder*> ActorFolders;
};

// Size: 0x60
struct FActorInstanceData : public FInstanceCacheDataBase {
    /* 0x0058 */ UClass* ActorClass;
};

// Size: 0x20
struct FActorInstanceHandle {
    /* 0x0000 */ TWeakObjectPtr<UObject> ReferenceObject;
};

// Size: 0x28
class IActorInstanceManagerInterface : public UInterface {
};

// Size: 0x20
struct FActorLocatorFragment {
    /* 0x0000 */ FSoftObjectPath Path;
};

// Size: 0x28
struct FActorLocatorFragmentResolveParameter {
    /* 0x0000 */ UWorld* StreamingWorld;
    /* 0x0008 */ FActorContainerID ContainerID;
    /* 0x0018 */ FTopLevelAssetPath SourceAssetPath;
};

// Size: 0x30
class UActorPartitionSubsystem : public UWorldSubsystem {
};

// Size: 0x28
struct FActorPlacementDataLayers {
    /* 0x0000 */ TArray<FName> DataLayerInstanceNames;
    /* 0x0010 */ FName ExternalDataLayerName;
    /* 0x0018 */ FName CurrentColorizedDataLayerInstanceName;
    /* 0x0020 */ int32_t ContextID;
};

// Size: 0x1
struct FActorPropertyOverride {
};

// Size: 0x28
class IActorSoundParameterInterface : public UInterface {

    void GetActorSoundParams(TArray<FAudioParameter>& Params) const;
};

// Size: 0xb8
class UActorTextureStreamingBuildDataComponent : public UActorComponent {
};

// Size: 0x30
struct FActorTickFunction : public FTickFunction {
};

// Size: 0x1c0
class UAimOffsetBlendSpace : public UBlendSpace {
};

// Size: 0x1c8
class UAimOffsetBlendSpace1D : public UBlendSpace1D {
};

// Size: 0x30
struct FAlphaBlend {
    /* 0x0000 */ UCurveFloat* CustomCurve;
    /* 0x0008 */ float BlendTime;
    /* 0x0024 */ EAlphaBlendOption BlendOption;
};

// Size: 0x10
struct FAlphaBlendArgs {
    /* 0x0000 */ UCurveFloat* CustomCurve;
    /* 0x0008 */ float BlendTime;
    /* 0x000c */ EAlphaBlendOption BlendOption;
};

// Size: 0x2b0
class AAmbientSound : public AActor {
    /* 0x02a8 */ UAudioComponent* AudioComponent;

    void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel);
    void FadeIn(float FadeInDuration, float FadeVolumeLevel);
    void FadeOut(float FadeOutDuration, float FadeVolumeLevel);
    void Play(float StartTime);
    void Stop();
};

// Size: 0x38
class UAnalysisProperties : public UObject {
    /* 0x0028 */ FString Function;
};

// Size: 0x68
struct FAngularDriveConstraint {
    /* 0x0000 */ FConstraintDrive TwistDrive;
    /* 0x0010 */ FConstraintDrive SwingDrive;
    /* 0x0020 */ FConstraintDrive SlerpDrive;
    /* 0x0030 */ FRotator OrientationTarget;
    /* 0x0048 */ FVector AngularVelocityTarget;
    /* 0x0060 */ uint8_t AngularDriveMode;
    /* 0x0061 */ bool bAccelerationMode;
};

// Size: 0x110
class UAnimBank : public UAnimationAsset {
};

// Size: 0x10
struct FAnimBankItem {
    /* 0x0000 */ UAnimBank* BankAsset;
    /* 0x0008 */ int32_t SequenceIndex;
};

// Size: 0x18
struct FAnimBankSequence {
    /* 0x0000 */ UAnimSequence* Sequence;
    /* 0x0008 */ bool bLooping;
    /* 0x0008 */ bool bAutoStart;
    /* 0x000c */ float position;
    /* 0x0010 */ float PlayRate;
    /* 0x0014 */ float BoundsScale;
};

// Size: 0xd0
class UAnimBlueprint : public UBlueprint {
    /* 0x00b0 */ USkeleton* TargetSkeleton;
    /* 0x00b8 */ TArray<FAnimGroupInfo> Groups;
    /* 0x00c8 */ bool bIsTemplate;
    /* 0x00c9 */ bool bUseMultiThreadedAnimationUpdate;
    /* 0x00ca */ bool bWarnAboutBlueprintUsage;
    /* 0x00cb */ bool bEnableLinkedAnimLayerInstanceSharing;
};

// Size: 0x28
class UAnimBlueprintClassSubsystem_PropertyAccess : public UObject {
};

// Size: 0x1
struct FAnimBlueprintConstantData {
};

// Size: 0x1
struct FAnimBlueprintDebugData {
};

// Size: 0x78
struct FAnimBlueprintFunction {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName Group;
    /* 0x0010 */ int32_t OutputPoseNodeIndex;
    /* 0x0018 */ TArray<FName> InputPoseNames;
    /* 0x0028 */ TArray<int32_t> InputPoseNodeIndices;
    /* 0x0070 */ bool bImplemented;
};

// Size: 0x5c8
class UAnimBlueprintGeneratedClass : public UBlueprintGeneratedClass {
    /* 0x0368 */ TArray<FBakedAnimationStateMachine> BakedStateMachines;
    /* 0x0378 */ USkeleton* TargetSkeleton;
    /* 0x0380 */ TArray<FAnimNotifyEvent> AnimNotifies;
    /* 0x0390 */ TMap<FName, FCachedPoseIndices> OrderedSavedPoseIndicesMap;
    /* 0x0460 */ TArray<FName> SyncGroupNames;
    /* 0x0470 */ TMap<FName, FGraphAssetPlayerInformation> GraphAssetPlayerInformation;
    /* 0x04c0 */ TMap<FName, FAnimGraphBlendOptions> GraphBlendOptions;
    /* 0x0510 */ TArray<FAnimNodeData> AnimNodeData;
    /* 0x0520 */ TMap<UScriptStruct*, FAnimNodeStructData> NodeTypeMap;
};

// Size: 0xc0
class UAnimBlueprintGeneratedStruct : public UScriptStruct {
};

// Size: 0x1
struct FAnimBlueprintMutableData {
};

// Size: 0x38
class UAnimBoneCompressionCodec : public UObject {
    /* 0x0028 */ FString Description;
};

// Size: 0x38
class UAnimBoneCompressionSettings : public UObject {
    /* 0x0028 */ TArray<UAnimBoneCompressionCodec*> Codecs;
};

// Size: 0x28
class IAnimClassInterface : public UInterface {
};

// Size: 0x10
struct FAnimComponentSpacePoseContext : public FAnimExecutionContext {
};

// Size: 0xc8
class UAnimComposite : public UAnimCompositeBase {
    /* 0x00b8 */ FAnimTrack AnimationTrack;
};

// Size: 0xb8
class UAnimCompositeBase : public UAnimSequenceBase {
    /* 0x00b0 */ FFrameRate CommonTargetFrameRate;
};

// Size: 0x40
class UAnimCompress : public UAnimBoneCompressionCodec {
    /* 0x0038 */ bool bNeedsSkeleton;
    /* 0x003c */ uint8_t TranslationCompressionFormat;
    /* 0x003d */ uint8_t RotationCompressionFormat;
    /* 0x003e */ uint8_t ScaleCompressionFormat;
};

// Size: 0x40
class UAnimCompress_BitwiseCompressOnly : public UAnimCompress {
};

// Size: 0x40
class UAnimCompress_LeastDestructive : public UAnimCompress_BitwiseCompressOnly {
};

// Size: 0xd8
class UAnimCompress_PerTrackCompression : public UAnimCompress_RemoveLinearKeys {
    /* 0x0060 */ float MaxZeroingThreshold;
    /* 0x0064 */ float MaxPosDiffBitwise;
    /* 0x0068 */ float MaxAngleDiffBitwise;
    /* 0x006c */ float MaxScaleDiffBitwise;
    /* 0x0070 */ TArray<uint8_t> AllowedRotationFormats;
    /* 0x0080 */ TArray<uint8_t> AllowedTranslationFormats;
    /* 0x0090 */ TArray<uint8_t> AllowedScaleFormats;
    /* 0x00a0 */ bool bResampleAnimation;
    /* 0x00a4 */ float ResampledFramerate;
    /* 0x00a8 */ int32_t MinKeysForResampling;
    /* 0x00ac */ bool bUseAdaptiveError;
    /* 0x00ac */ bool bUseOverrideForEndEffectors;
    /* 0x00b0 */ int32_t TrackHeightBias;
    /* 0x00b4 */ float ParentingDivisor;
    /* 0x00b8 */ float ParentingDivisorExponent;
    /* 0x00bc */ bool bUseAdaptiveError2;
    /* 0x00c0 */ float RotationErrorSourceRatio;
    /* 0x00c4 */ float TranslationErrorSourceRatio;
    /* 0x00c8 */ float ScaleErrorSourceRatio;
    /* 0x00cc */ float MaxErrorPerTrackRatio;
    /* 0x00d0 */ float PerturbationProbeSize;
};

// Size: 0x48
class UAnimCompress_RemoveEverySecondKey : public UAnimCompress {
    /* 0x0040 */ int32_t MinKeys;
    /* 0x0044 */ bool bStartAtSecondKey;
};

// Size: 0x60
class UAnimCompress_RemoveLinearKeys : public UAnimCompress {
    /* 0x0040 */ float MaxPosDiff;
    /* 0x0044 */ float MaxAngleDiff;
    /* 0x0048 */ float MaxScaleDiff;
    /* 0x004c */ float MaxEffectorDiff;
    /* 0x0050 */ float MinEffectorDiff;
    /* 0x0054 */ float EffectorDiffSocket;
    /* 0x0058 */ float ParentKeyScale;
    /* 0x005c */ bool bRetarget;
    /* 0x005c */ bool bActuallyFilterLinearKeys;
};

// Size: 0x50
class UAnimCompress_RemoveTrivialKeys : public UAnimCompress {
    /* 0x0040 */ float MaxPosDiff;
    /* 0x0044 */ float MaxAngleDiff;
    /* 0x0048 */ float MaxScaleDiff;
};

// Size: 0xc
struct FAnimCompressedCurveIndexedName {
    /* 0x0000 */ FName CurveName;
};

// Size: 0xc
struct FAnimCurveBase {
    /* 0x0000 */ FName CurveName;
    /* 0x0008 */ int32_t CurveTypeFlags;
};

// Size: 0x28
class UAnimCurveCompressionCodec : public UObject {
};

// Size: 0x28
class UAnimCurveCompressionCodec_CompressedRichCurve : public UAnimCurveCompressionCodec {
};

// Size: 0x28
class UAnimCurveCompressionCodec_UniformIndexable : public UAnimCurveCompressionCodec {
};

// Size: 0x28
class UAnimCurveCompressionCodec_UniformlySampled : public UAnimCurveCompressionCodec {
};

// Size: 0x30
class UAnimCurveCompressionSettings : public UObject {
    /* 0x0028 */ UAnimCurveCompressionCodec* Codec;
};

// Size: 0xa0
class UAnimCurveMetaData : public UAssetUserData {
    /* 0x0030 */ TMap<FName, FCurveMetaData> CurveMetaData;
};

// Size: 0xc
struct FAnimCurveParam {
    /* 0x0000 */ FName Name;
};

// Size: 0x2
struct FAnimCurveType {
    /* 0x0000 */ bool bMaterial;
    /* 0x0001 */ bool bMorphtarget;
};

// Size: 0xc8
class UAnimDataModel : public UObject {
    /* 0x0030 */ int32_t BracketCounter;
    /* 0x0038 */ FMulticastInlineDelegate ModifiedEventDynamic;
    /* 0x0060 */ TArray<FBoneAnimationTrack> BoneAnimationTracks;
    /* 0x0070 */ float PlayLength;
    /* 0x0074 */ FFrameRate FrameRate;
    /* 0x007c */ int32_t NumberOfFrames;
    /* 0x0080 */ int32_t NumberOfKeys;
    /* 0x0088 */ FAnimationCurveData CurveData;
    /* 0x00a8 */ TArray<FAnimatedBoneAttribute> AnimatedBoneAttributes;
    /* 0x00b8 */ bool bPopulated;
};

// Size: 0x10
struct FAnimDataModelNotifPayload {
};

// Size: 0x10
struct FAnimExecutionContext {
};

// Size: 0x20
struct FAnimGraphBlendOptions {
    /* 0x0000 */ float BlendInTime;
    /* 0x0008 */ UBlendProfile* BlendInProfile;
    /* 0x0010 */ float BlendOutTime;
    /* 0x0018 */ UBlendProfile* BlendOutProfile;
};

// Size: 0x18
struct FAnimGroupInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FLinearColor Color;
};

// Size: 0x78
struct FAnimGroupInstance {
};

// Size: 0x10
struct FAnimInitializationContext : public FAnimExecutionContext {
};

// Size: 0x3e0
class UAnimInstance : public UObject {
    /* 0x0028 */ USkeleton* CurrentSkeleton;
    /* 0x0030 */ uint8_t RootMotionMode;
    /* 0x0031 */ bool bUseMultiThreadedAnimationUpdate;
    /* 0x0031 */ bool bUsingCopyPoseFromMesh;
    /* 0x0031 */ bool bReceiveNotifiesFromLinkedInstances;
    /* 0x0031 */ bool bPropagateNotifiesToLinkedInstances;
    /* 0x0031 */ bool bUseMainInstanceMontageEvaluationData;
    /* 0x0033 */ bool bQueueMontageEvents;
    /* 0x0038 */ FMulticastInlineDelegate OnMontageBlendingOut;
    /* 0x0048 */ FMulticastInlineDelegate OnMontageBlendedIn;
    /* 0x0058 */ FMulticastInlineDelegate OnMontageStarted;
    /* 0x0068 */ FMulticastInlineDelegate OnMontageEnded;
    /* 0x0078 */ FMulticastInlineDelegate OnAllMontageInstancesEnded;
    /* 0x0088 */ FMulticastInlineDelegate OnMontageSectionChanged;
    /* 0x0148 */ TMap<FName, FInertializationRequest> SlotGroupInertializationRequestDataMap;
    /* 0x01e0 */ FAnimNotifyQueue NotifyQueue;
    /* 0x0250 */ TArray<FAnimNotifyEvent> ActiveAnimNotifyState;
    /* 0x0260 */ TArray<FAnimNotifyEventReference> ActiveAnimNotifyEventReference;

    void BlueprintBeginPlay();
    void BlueprintInitializeAnimation();
    void BlueprintLinkedAnimationLayersInitialized();
    void BlueprintPostEvaluateAnimation();
    void BlueprintThreadSafeUpdateAnimation(float deltaTime);
    void BlueprintUpdateAnimation(float DeltaTimeX);
    UAnimInstance* Blueprint_GetMainAnimInstance() const;
    float Blueprint_GetSlotMontageLocalWeight(FName SlotNodeName) const;
    float CalculateDirection(const FVector& Velocity, const FRotator& BaseRotation) const;
    void ClearAllTransitionEvents();
    void ClearMorphTargets();
    void ClearTransitionEvents(const FName EventName);
    bool DynamicMontage_IsPlayingFrom(const UAnimSequenceBase* Animation) const;
    void GetActiveCurveNames(EAnimCurveType CurveType, TArray<FName>& OutNames) const;
    void GetAllCurveNames(TArray<FName>& OutNames) const;
    UBlendProfile* GetBlendProfileByName(FName InBlendProfileName) const;
    UAnimMontage* GetCurrentActiveMontage() const;
    FName GetCurrentStateName(int32_t MachineIndex);
    float GetCurveValue(FName CurveName) const;
    bool GetCurveValueWithDefault(FName CurveName, float DefaultValue, float& OutValue);
    float GetDeltaSeconds() const;
    float GetInstanceAssetPlayerLength(int32_t AssetPlayerIndex);
    float GetInstanceAssetPlayerTime(int32_t AssetPlayerIndex);
    float GetInstanceAssetPlayerTimeFraction(int32_t AssetPlayerIndex);
    float GetInstanceAssetPlayerTimeFromEnd(int32_t AssetPlayerIndex);
    float GetInstanceAssetPlayerTimeFromEndFraction(int32_t AssetPlayerIndex);
    float GetInstanceCurrentStateElapsedTime(int32_t MachineIndex);
    float GetInstanceMachineWeight(int32_t MachineIndex);
    float GetInstanceStateWeight(int32_t MachineIndex, int32_t StateIndex);
    float GetInstanceTransitionCrossfadeDuration(int32_t MachineIndex, int32_t TransitionIndex);
    float GetInstanceTransitionTimeElapsed(int32_t MachineIndex, int32_t TransitionIndex);
    float GetInstanceTransitionTimeElapsedFraction(int32_t MachineIndex, int32_t TransitionIndex);
    UAnimInstance* GetLinkedAnimGraphInstanceByTag(FName InTag) const;
    void GetLinkedAnimGraphInstancesByTag(FName InTag, TArray<UAnimInstance*>& OutLinkedInstances) const;
    UAnimInstance* GetLinkedAnimLayerInstanceByClass(UClass* InClass, bool bCheckForChildClass) const;
    UAnimInstance* GetLinkedAnimLayerInstanceByGroup(FName InGroup) const;
    UAnimInstance* GetLinkedAnimLayerInstanceByGroupAndClass(FName InGroup, UClass* InClass) const;
    void GetLinkedAnimLayerInstancesByGroup(FName InGroup, TArray<UAnimInstance*>& OutLinkedInstances) const;
    AActor* GetOwningActor() const;
    USkeletalMeshComponent* GetOwningComponent() const;
    bool GetPropagateNotifiesToLinkedInstances() const;
    bool GetReceiveNotifiesFromLinkedInstances() const;
    float GetRelevantAnimLength(int32_t MachineIndex, int32_t StateIndex);
    float GetRelevantAnimTime(int32_t MachineIndex, int32_t StateIndex);
    float GetRelevantAnimTimeFraction(int32_t MachineIndex, int32_t StateIndex);
    float GetRelevantAnimTimeRemaining(int32_t MachineIndex, int32_t StateIndex);
    float GetRelevantAnimTimeRemainingFraction(int32_t MachineIndex, int32_t StateIndex);
    FMarkerSyncAnimPosition GetSyncGroupPosition(FName InSyncGroupName) const;
    bool GetTimeToClosestMarker(FName SyncGroup, FName MarkerName, float& OutMarkerTime) const;
    bool HasMarkerBeenHitThisFrame(FName SyncGroup, FName MarkerName) const;
    bool IsAnyMontagePlaying() const;
    bool IsPlayingSlotAnimation(const UAnimSequenceBase* Asset, FName SlotNodeName) const;
    bool IsSlotActive(FName SlotNodeName) const;
    bool IsSyncGroupBetweenMarkers(FName InSyncGroupName, FName PreviousMarker, FName NextMarker, bool bRespectMarkerOrder) const;
    bool IsUsingMainInstanceMontageEvaluationData() const;
    void LinkAnimClassLayers(UClass* InClass);
    void LinkAnimGraphByTag(FName InTag, UClass* InClass);
    void LockAIResources(bool bLockMovement, bool LockAILogic);
    void MontageSync_Follow(const UAnimMontage* MontageFollower, const UAnimInstance* OtherAnimInstance, const UAnimMontage* MontageLeader);
    void MontageSync_StopFollowing(const UAnimMontage* MontageFollower);
    float Montage_GetBlendTime(const UAnimMontage* Montage) const;
    FName Montage_GetCurrentSection(const UAnimMontage* Montage) const;
    float Montage_GetEffectivePlayRate(const UAnimMontage* Montage) const;
    bool Montage_GetIsStopped(const UAnimMontage* Montage) const;
    float Montage_GetPlayRate(const UAnimMontage* Montage) const;
    float Montage_GetPosition(const UAnimMontage* Montage) const;
    bool Montage_IsActive(const UAnimMontage* Montage) const;
    bool Montage_IsPlaying(const UAnimMontage* Montage) const;
    void Montage_JumpToSection(FName SectionName, const UAnimMontage* Montage);
    void Montage_JumpToSectionsEnd(FName SectionName, const UAnimMontage* Montage);
    void Montage_Pause(const UAnimMontage* Montage);
    float Montage_Play(UAnimMontage* MontageToPlay, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
    float Montage_PlayWithBlendIn(UAnimMontage* MontageToPlay, const FAlphaBlendArgs& BlendIn, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
    float Montage_PlayWithBlendSettings(UAnimMontage* MontageToPlay, const FMontageBlendSettings& BlendInSettings, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt, bool bStopAllMontages);
    void Montage_Resume(const UAnimMontage* Montage);
    void Montage_SetNextSection(FName SectionNameToChange, FName NextSection, const UAnimMontage* Montage);
    void Montage_SetPlayRate(const UAnimMontage* Montage, float NewPlayRate);
    void Montage_SetPosition(const UAnimMontage* Montage, float NewPosition);
    void Montage_Stop(float InBlendOutTime, const UAnimMontage* Montage);
    void Montage_StopGroupByName(float InBlendOutTime, FName GroupName);
    void Montage_StopWithBlendOut(const FAlphaBlendArgs& BlendOut, const UAnimMontage* Montage);
    void Montage_StopWithBlendSettings(const FMontageBlendSettings& BlendOutSettings, const UAnimMontage* Montage);
    UAnimMontage* PlaySlotAnimationAsDynamicMontage(UAnimSequenceBase* Asset, FName SlotNodeName, float BlendInTime, float BlendOutTime, float InPlayRate, int32_t LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
    UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendArgs(UAnimSequenceBase* Asset, FName SlotNodeName, const FAlphaBlendArgs& BlendIn, const FAlphaBlendArgs& BlendOut, float InPlayRate, int32_t LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
    UAnimMontage* PlaySlotAnimationAsDynamicMontage_WithBlendSettings(UAnimSequenceBase* Asset, FName SlotNodeName, const FMontageBlendSettings& BlendInSettings, const FMontageBlendSettings& BlendOutSettings, float InPlayRate, int32_t LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt);
    bool QueryAndMarkTransitionEvent(int32_t MachineIndex, int32_t TransitionIndex, FName EventName);
    bool QueryTransitionEvent(int32_t MachineIndex, int32_t TransitionIndex, FName EventName);
    void RemovePoseSnapshot(FName SnapshotName);
    void RequestSlotGroupInertialization(FName InSlotGroupName, float Duration, const UBlendProfile* BlendProfile);
    bool RequestTransitionEvent(const FName EventName, const double RequestTimeout, const ETransitionRequestQueueMode QueueMode, const ETransitionRequestOverwriteMode OverwriteMode);
    void ResetDynamics(ETeleportType InTeleportType);
    void SavePoseSnapshot(FName SnapshotName);
    void SetMorphTarget(FName MorphTargetName, float Value);
    void SetPropagateNotifiesToLinkedInstances(bool bSet);
    void SetReceiveNotifiesFromLinkedInstances(bool bSet);
    void SetRootMotionMode(uint8_t Value);
    void SetUseMainInstanceMontageEvaluationData(bool bSet);
    void SnapshotPose(FPoseSnapshot& Snapshot);
    void StopSlotAnimation(float InBlendOutTime, FName SlotNodeName);
    APawn* TryGetPawnOwner() const;
    void UnlinkAnimClassLayers(UClass* InClass);
    void UnlockAIResources(bool bUnlockMovement, bool UnlockAILogic);
    bool WasAnimNotifyNameTriggeredInAnyState(FName NotifyName);
    bool WasAnimNotifyNameTriggeredInSourceState(int32_t MachineIndex, int32_t StateIndex, FName NotifyName);
    bool WasAnimNotifyNameTriggeredInStateMachine(int32_t MachineIndex, FName NotifyName);
    bool WasAnimNotifyStateActiveInAnyState(UClass* AnimNotifyStateType);
    bool WasAnimNotifyStateActiveInSourceState(int32_t MachineIndex, int32_t StateIndex, UClass* AnimNotifyStateType);
    bool WasAnimNotifyStateActiveInStateMachine(int32_t MachineIndex, UClass* AnimNotifyStateType);
    bool WasAnimNotifyTriggeredInAnyState(UClass* AnimNotifyType);
    bool WasAnimNotifyTriggeredInSourceState(int32_t MachineIndex, int32_t StateIndex, UClass* AnimNotifyType);
    bool WasAnimNotifyTriggeredInStateMachine(int32_t MachineIndex, UClass* AnimNotifyType);
};

// Size: 0x4
struct FAnimInstanceLocatorFragment {
    /* 0x0000 */ EAnimInstanceLocatorFragmentType Type;
};

// Size: 0x7a0
struct FAnimInstanceProxy {
    /* 0x06d0 */ TMap<FName, FInertializationRequest> SlotGroupInertializationRequestDataMap;
};

// Size: 0x28
class IAnimLayerInterface : public UInterface {
};

// Size: 0x30
struct FAnimLinkableElement {
    /* 0x0008 */ UAnimMontage* LinkedMontage;
    /* 0x0010 */ int32_t SlotIndex;
    /* 0x0014 */ int32_t SegmentIndex;
    /* 0x0018 */ uint8_t LinkMethod;
    /* 0x0019 */ uint8_t CachedLinkMethod;
    /* 0x001c */ float SegmentBeginTime;
    /* 0x0020 */ float SegmentLength;
    /* 0x0024 */ float LinkValue;
    /* 0x0028 */ UAnimSequenceBase* LinkedSequence;
};

// Size: 0x28
class UAnimMetaData : public UObject {
};

// Size: 0x1e0
class UAnimMontage : public UAnimCompositeBase {
    /* 0x00b8 */ EMontageBlendMode BlendModeIn;
    /* 0x00b9 */ EMontageBlendMode BlendModeOut;
    /* 0x00c0 */ FAlphaBlend BlendIn;
    /* 0x00f0 */ FAlphaBlend BlendOut;
    /* 0x0120 */ float BlendOutTriggerTime;
    /* 0x0124 */ FName SyncGroup;
    /* 0x012c */ int32_t SyncSlotIndex;
    /* 0x0130 */ FMarkerSyncData MarkerData;
    /* 0x0150 */ TArray<FCompositeSection> CompositeSections;
    /* 0x0160 */ TArray<FSlotAnimationTrack> SlotAnimTracks;
    /* 0x0170 */ bool bEnableRootMotionTranslation;
    /* 0x0171 */ bool bEnableRootMotionRotation;
    /* 0x0172 */ bool bEnableAutoBlendOut;
    /* 0x0178 */ UBlendProfile* BlendProfileIn;
    /* 0x0180 */ UBlendProfile* BlendProfileOut;
    /* 0x0188 */ uint8_t RootMotionRootLock;
    /* 0x0190 */ TArray<FBranchingPointMarker> BranchingPointMarkers;
    /* 0x01a0 */ TArray<int32_t> BranchingPointStateNotifyIndices;
    /* 0x01b0 */ FTimeStretchCurve TimeStretchCurve;
    /* 0x01d8 */ FName TimeStretchCurveName;

    static UAnimMontage* CreateSlotAnimationAsDynamicMontage_WithBlendSettings(UAnimSequenceBase* Asset, FName SlotNodeName, const FMontageBlendSettings& BlendInSettings, const FMontageBlendSettings& BlendOutSettings, float InPlayRate, int32_t LoopCount, float InBlendOutTriggerTime);
    FAlphaBlendArgs GetBlendInArgs() const;
    FAlphaBlendArgs GetBlendOutArgs() const;
    float GetDefaultBlendInTime() const;
    float GetDefaultBlendOutTime() const;
    UAnimSequenceBase* GetFirstAnimReference() const;
    FName GetGroupName() const;
    int32_t GetNumSections() const;
    int32_t GetSectionIndex(FName InSectionName) const;
    FName GetSectionName(int32_t SectionIndex) const;
    bool IsDynamicMontage() const;
    bool IsValidAdditiveSlot(const FName& SlotNodeName) const;
    bool IsValidSectionName(FName InSectionName) const;
};

// Size: 0x1e8
struct FAnimMontageInstance {
    /* 0x0000 */ UAnimMontage* Montage;
    /* 0x0048 */ bool bPlaying;
    /* 0x004c */ float DefaultBlendTimeMultiplier;
    /* 0x0118 */ TArray<int32_t> NextSections;
    /* 0x0128 */ TArray<int32_t> PrevSections;
    /* 0x0148 */ TArray<FAnimNotifyEvent> ActiveStateBranchingPoints;
    /* 0x0158 */ float position;
    /* 0x015c */ float PlayRate;
    /* 0x0160 */ FAlphaBlend Blend;
    /* 0x01c4 */ int32_t DisableRootMotionCount;
};

// Size: 0x18
struct FAnimNodeConstantData {
    /* 0x0000 */ TScriptInterface<IAnimClassInterface> AnimClassInterface;
    /* 0x0010 */ int32_t NodeIndex;
};

// Size: 0x28
struct FAnimNodeData {
    /* 0x0000 */ TScriptInterface<IAnimClassInterface> AnimClassInterface;
    /* 0x0010 */ TArray<uint32_t> Entries;
    /* 0x0020 */ int32_t NodeIndex;
    /* 0x0024 */ uint32_t Flags;
};

// Size: 0x8
struct FAnimNodeExposedValueHandler {
};

// Size: 0x18
struct FAnimNodeExposedValueHandler_Base : public FAnimNodeExposedValueHandler {
    /* 0x0008 */ UFunction* Function;
    /* 0x0010 */ FName BoundFunction;
};

// Size: 0x30
struct FAnimNodeExposedValueHandler_PropertyAccess : public FAnimNodeExposedValueHandler_Base {
    /* 0x0018 */ TArray<FExposedValueCopyRecord> CopyRecords;
};

// Size: 0x20
struct FAnimNodeFunctionRef {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ FName FunctionName;
    /* 0x0010 */ UClass* Class;
    /* 0x0018 */ UFunction* Function;
};

// Size: 0x10
struct FAnimNodeReference {
};

// Size: 0x58
struct FAnimNodeStructData {
    /* 0x0000 */ TMap<FName, int32_t> NameToIndexMap;
    /* 0x0050 */ int32_t NumProperties;
};

// Size: 0xd0
struct FAnimNode_ApplyMeshSpaceAdditive : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink base;
    /* 0x0020 */ FPoseLink Additive;
    /* 0x0030 */ bool bRootSpaceAdditive;
    /* 0x0031 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0034 */ float Alpha;
    /* 0x0038 */ bool bAlphaBoolEnabled;
    /* 0x0040 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x0088 */ FName AlphaCurveName;
    /* 0x0090 */ FInputScaleBias AlphaScaleBias;
    /* 0x0098 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x00c8 */ int32_t LODThreshold;
};

// Size: 0x38
struct FAnimNode_AssetPlayerBase : public FAnimNode_AssetPlayerRelevancyBase {
    /* 0x0020 */ float BlendWeight;
    /* 0x0024 */ float InternalTimeAccumulator;
};

// Size: 0x10
struct FAnimNode_AssetPlayerRelevancyBase : public FAnimNode_Base {
};

// Size: 0x10
struct FAnimNode_Base {
};

// Size: 0x20
struct FAnimNode_ConvertComponentToLocalSpace : public FAnimNode_Base {
    /* 0x0010 */ FComponentSpacePoseLink ComponentPose;
};

// Size: 0x20
struct FAnimNode_ConvertLocalToComponentSpace : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink LocalPose;
};

// Size: 0x58
struct FAnimNode_CustomProperty : public FAnimNode_Base {
    /* 0x0010 */ TArray<FName> SourcePropertyNames;
    /* 0x0020 */ TArray<FName> DestPropertyNames;
    /* 0x0030 */ UObject* TargetInstance;
};

// Size: 0x690
struct FAnimNode_DeadBlending : public FAnimNode_Base {
    /* 0x0018 */ FPoseLink Source;
    /* 0x0028 */ bool bAlwaysUseDefaultBlendSettings;
    /* 0x002c */ float DefaultBlendDuration;
    /* 0x0030 */ UBlendProfile* DefaultBlendProfile;
    /* 0x0038 */ EAlphaBlendOption DefaultBlendMode;
    /* 0x0040 */ UCurveFloat* DefaultCustomBlendCurve;
    /* 0x0048 */ float BlendTimeMultiplier;
    /* 0x004c */ bool bLinearlyInterpolateScales;
    /* 0x0050 */ TArray<FName> FilteredCurves;
    /* 0x0060 */ TArray<FName> ExtrapolationFilteredCurves;
    /* 0x0070 */ TArray<FBoneReference> FilteredBones;
    /* 0x0080 */ float ExtrapolationHalfLife;
    /* 0x0084 */ float ExtrapolationHalfLifeMin;
    /* 0x0088 */ float ExtrapolationHalfLifeMax;
    /* 0x008c */ float MaximumTranslationVelocity;
    /* 0x0090 */ float MaximumRotationVelocity;
    /* 0x0094 */ float MaximumScaleVelocity;
    /* 0x0098 */ float MaximumCurveVelocity;
    /* 0x009c */ bool bResetOnBecomingRelevant;
    /* 0x009d */ bool bForwardRequestsThroughSkippedCachedPoseNodes;
    /* 0x00a0 */ FName Tag;
    /* 0x03c0 */ TArray<FInertializationRequest> RequestQueue;
    /* 0x0660 */ UCurveFloat* InertializationCustomBlendCurve;
    /* 0x0680 */ UObject* InertializationRequestAnimInstance;
};

// Size: 0x550
struct FAnimNode_Inertialization : public FAnimNode_Base {
    /* 0x0018 */ FPoseLink Source;
    /* 0x0028 */ UBlendProfile* DefaultBlendProfile;
    /* 0x0030 */ TArray<FName> FilteredCurves;
    /* 0x0040 */ TArray<FBoneReference> FilteredBones;
    /* 0x0050 */ bool bResetOnBecomingRelevant;
    /* 0x0051 */ bool bForwardRequestsThroughSkippedCachedPoseNodes;
    /* 0x0054 */ FName Tag;
    /* 0x0308 */ TArray<FInertializationRequest> RequestQueue;
    /* 0x0548 */ UObject* InertializationRequestAnimInstance;
};

// Size: 0xb8
struct FAnimNode_LinkedAnimGraph : public FAnimNode_CustomProperty {
    /* 0x0058 */ TArray<FPoseLink> InputPoses;
    /* 0x0068 */ TArray<FName> InputPoseNames;
    /* 0x0078 */ UClass* InstanceClass;
    /* 0x0098 */ UBlendProfile* PendingBlendOutProfile;
    /* 0x00a8 */ UBlendProfile* PendingBlendInProfile;
    /* 0x00b0 */ bool bReceiveNotifiesFromLinkedInstances;
    /* 0x00b0 */ bool bPropagateNotifiesToLinkedInstances;
};

// Size: 0xc8
struct FAnimNode_LinkedAnimLayer : public FAnimNode_LinkedAnimGraph {
    /* 0x00b8 */ UClass* Interface;
    /* 0x00c0 */ FName Layer;
};

// Size: 0xb8
struct FAnimNode_LinkedInputPose : public FAnimNode_Base {
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FName Graph;
    /* 0x0020 */ FPoseLink InputPose;
    /* 0x00a8 */ bool bIsOutputLinked;
};

// Size: 0x20
struct FAnimNode_Root : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Result;
};

// Size: 0x80
struct FAnimNode_SaveCachedPose : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Pose;
    /* 0x0020 */ FName CachePoseName;
};

// Size: 0x48
struct FAnimNode_SequencePlayer : public FAnimNode_SequencePlayerBase {
    /* 0x0040 */ UAnimSequenceBase* Sequence;
};

// Size: 0x40
struct FAnimNode_SequencePlayerBase : public FAnimNode_AssetPlayerBase {
    /* 0x0038 */ FInputScaleBiasClampState PlayRateScaleBiasClampState;
};

// Size: 0x98
struct FAnimNode_SequencePlayer_Standalone : public FAnimNode_SequencePlayerBase {
    /* 0x0040 */ FName GroupName;
    /* 0x0048 */ uint8_t GroupRole;
    /* 0x0049 */ bool bOverridePositionWhenJoiningSyncGroupAsLeader;
    /* 0x004a */ EAnimSyncMethod Method;
    /* 0x004b */ bool bIgnoreForRelevancyTest;
    /* 0x0050 */ UAnimSequenceBase* Sequence;
    /* 0x0058 */ float PlayRateBasis;
    /* 0x005c */ float PlayRate;
    /* 0x0060 */ FInputScaleBiasClampConstants PlayRateScaleBiasClampConstants;
    /* 0x008c */ float StartPosition;
    /* 0x0090 */ bool bLoopAnimation;
    /* 0x0091 */ bool bStartFromMatchingPose;
};

// Size: 0x30
struct FAnimNode_SingleNode : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink SourcePose;
};

// Size: 0xc8
struct FAnimNode_StateMachine : public FAnimNode_Base {
    /* 0x0010 */ int32_t StateMachineIndexInClass;
    /* 0x0014 */ int32_t MaxTransitionsPerFrame;
    /* 0x0018 */ int32_t MaxTransitionsRequests;
    /* 0x001c */ bool bSkipFirstUpdateTransition;
    /* 0x001d */ bool bReinitializeOnBecomingRelevant;
    /* 0x001e */ bool bCreateNotifyMetaData;
    /* 0x001f */ bool bAllowConduitEntryStates;
};

// Size: 0x20
struct FAnimNode_StateResult : public FAnimNode_Root {
};

// Size: 0xa8
struct FAnimNode_TransitionPoseEvaluator : public FAnimNode_Base {
    /* 0x0088 */ int32_t FramesToCachePose;
    /* 0x0090 */ uint8_t DataSource;
    /* 0x0091 */ uint8_t EvaluatorMode;
};

// Size: 0x28
struct FAnimNode_TransitionResult : public FAnimNode_Base {
    /* 0x0010 */ bool bCanEnterTransition;
};

// Size: 0x28
struct FAnimNode_UseCachedPose : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink LinkToCachingNode;
    /* 0x0020 */ FName CachePoseName;
};

// Size: 0x38
class UAnimNotify : public UObject {

    float GetDefaultTriggerWeightThreshold() const;
    FString GetNotifyName() const;
    bool Received_Notify(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) const;
};

// Size: 0x10
struct FAnimNotifyArray {
    /* 0x0000 */ TArray<FAnimNotifyEventReference> Notifies;
};

// Size: 0x18
struct FAnimNotifyContext {
};

// Size: 0xb8
struct FAnimNotifyEvent : public FAnimLinkableElement {
    /* 0x0030 */ float TriggerTimeOffset;
    /* 0x0034 */ float EndTriggerTimeOffset;
    /* 0x0038 */ float TriggerWeightThreshold;
    /* 0x003c */ FName NotifyName;
    /* 0x0048 */ UAnimNotify* Notify;
    /* 0x0050 */ UAnimNotifyState* NotifyStateClass;
    /* 0x0058 */ float Duration;
    /* 0x0060 */ FAnimLinkableElement EndLink;
    /* 0x0090 */ bool bConvertedFromBranchingPoint;
    /* 0x0091 */ uint8_t MontageTickType;
    /* 0x0094 */ float NotifyTriggerChance;
    /* 0x0098 */ uint8_t NotifyFilterType;
    /* 0x009c */ int32_t NotifyFilterLOD;
    /* 0x00a0 */ bool bCanBeFilteredViaRequest;
    /* 0x00a1 */ bool bTriggerOnDedicatedServer;
    /* 0x00a2 */ bool bTriggerOnFollower;
    /* 0x00a4 */ int32_t TrackIndex;
};

// Size: 0x30
struct FAnimNotifyEventReference {
    /* 0x0018 */ UMirrorDataTable* MirrorTable;
    /* 0x0020 */ UObject* NotifySource;
};

// Size: 0x28
class UAnimNotifyLibrary : public UBlueprintFunctionLibrary {

    static float GetCurrentAnimationNotifyStateTime(const FAnimNotifyEventReference& EventReference);
    static float GetCurrentAnimationNotifyStateTimeRatio(const FAnimNotifyEventReference& EventReference);
    static float GetCurrentAnimationTime(const FAnimNotifyEventReference& EventReference);
    static float GetCurrentAnimationTimeRatio(const FAnimNotifyEventReference& EventReference);
    static bool IsBlendingOut(const FAnimNotifyEventReference& EventReference);
    static bool NotifyStateReachedEnd(const FAnimNotifyEventReference& EventReference);
};

// Size: 0x28
class UAnimNotifyMirrorInspectionLibrary : public UBlueprintFunctionLibrary {

    static UMirrorDataTable* GetMirrorDataTable(const FAnimNotifyEventReference& EventReference);
    static bool IsTriggeredByMirroredAnimation(const FAnimNotifyEventReference& EventReference);
};

// Size: 0x70
struct FAnimNotifyQueue {
    /* 0x0010 */ TArray<FAnimNotifyEventReference> AnimNotifies;
    /* 0x0020 */ TMap<FName, FAnimNotifyArray> UnfilteredMontageAnimNotifies;
};

// Size: 0x30
class UAnimNotifyState : public UObject {

    float GetDefaultTriggerWeightThreshold() const;
    FString GetNotifyName() const;
    bool Received_NotifyBegin(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float TotalDuration, const FAnimNotifyEventReference& EventReference) const;
    bool Received_NotifyEnd(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, const FAnimNotifyEventReference& EventReference) const;
    bool Received_NotifyTick(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float FrameDeltaTime, const FAnimNotifyEventReference& EventReference) const;
};

// Size: 0x28
class UAnimNotifyStateMachineInspectionLibrary : public UBlueprintFunctionLibrary {

    static bool IsTriggeredByState(const FAnimNotifyEventReference& EventReference, UAnimInstance* AnimInstance, FName StateName);
    static bool IsTriggeredByStateInStateMachine(const FAnimNotifyEventReference& EventReference, UAnimInstance* AnimInstance, FName StateMachineName, FName StateName);
    static bool IsTriggeredByStateMachine(const FAnimNotifyEventReference& EventReference, UAnimInstance* AnimInstance, FName StateMachineName);
};

// Size: 0x30
class UAnimNotifyState_DisableRootMotion : public UAnimNotifyState {
};

// Size: 0x78
class UAnimNotifyState_TimedParticleEffect : public UAnimNotifyState {
    /* 0x0030 */ UParticleSystem* PSTemplate;
    /* 0x0038 */ FName SocketName;
    /* 0x0040 */ FVector LocationOffset;
    /* 0x0058 */ FRotator RotationOffset;
    /* 0x0070 */ bool bDestroyAtEnd;
};

// Size: 0x58
class UAnimNotifyState_Trail : public UAnimNotifyState {
    /* 0x0030 */ UParticleSystem* PSTemplate;
    /* 0x0038 */ FName FirstSocketName;
    /* 0x0040 */ FName SecondSocketName;
    /* 0x0048 */ uint8_t WidthScaleMode;
    /* 0x004c */ FName WidthScaleCurve;
    /* 0x0054 */ bool bRecycleSpawnedSystems;

    UParticleSystem* OverridePSTemplate(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation) const;
};

// Size: 0x38
struct FAnimNotifyTrack {
    /* 0x0000 */ FName TrackName;
    /* 0x0008 */ FLinearColor TrackColor;
};

// Size: 0x38
class UAnimNotify_PauseClothingSimulation : public UAnimNotify {
};

// Size: 0xc0
class UAnimNotify_PlayParticleEffect : public UAnimNotify {
    /* 0x0038 */ UParticleSystem* PSTemplate;
    /* 0x0040 */ FVector LocationOffset;
    /* 0x0058 */ FRotator RotationOffset;
    /* 0x0070 */ FVector Scale;
    /* 0x00b0 */ bool Attached;
    /* 0x00b4 */ FName SocketName;
};

// Size: 0x58
class UAnimNotify_PlaySound : public UAnimNotify {
    /* 0x0038 */ USoundBase* Sound;
    /* 0x0040 */ float VolumeMultiplier;
    /* 0x0044 */ float PitchMultiplier;
    /* 0x0048 */ bool bFollow;
    /* 0x004c */ FName AttachName;
};

// Size: 0x38
class UAnimNotify_ResetClothingSimulation : public UAnimNotify {
};

// Size: 0x38
class UAnimNotify_ResetDynamics : public UAnimNotify {
};

// Size: 0x38
class UAnimNotify_ResumeClothingSimulation : public UAnimNotify {
};

// Size: 0x18
struct FAnimParentNodeAssetOverride {
    /* 0x0000 */ UAnimationAsset* NewAsset;
    /* 0x0008 */ FGuid ParentNodeGuid;
};

enum class AnimPhysCollisionType {
    CoM = 0,
    CustomSphere = 1,
    InnerSphere = 2,
    OuterSphere = 3,
    AnimPhysCollisionType_MAX = 4,
};

enum class AnimPhysTwistAxis {
    AxisX = 0,
    AxisY = 1,
    AxisZ = 2,
    AnimPhysTwistAxis_MAX = 3,
};

// Size: 0x10
struct FAnimPoseContext : public FAnimExecutionContext {
};

// Size: 0x20
struct FAnimSegment {
    /* 0x0000 */ UAnimSequenceBase* AnimReference;
    /* 0x0008 */ float StartPos;
    /* 0x000c */ float AnimStartTime;
    /* 0x0010 */ float AnimEndTime;
    /* 0x0014 */ float AnimPlayRate;
    /* 0x0018 */ int32_t LoopingCount;
};

// Size: 0x1f0
class UAnimSequence : public UAnimSequenceBase {
    /* 0x00b0 */ UAnimBoneCompressionSettings* BoneCompressionSettings;
    /* 0x00b8 */ UAnimCurveCompressionSettings* CurveCompressionSettings;
    /* 0x0140 */ UVariableFrameStrippingSettings* VariableFrameStrippingSettings;
    /* 0x0148 */ uint8_t AdditiveAnimType;
    /* 0x0149 */ uint8_t RefPoseType;
    /* 0x014c */ int32_t RefFrameIndex;
    /* 0x0150 */ UAnimSequence* RefPoseSeq;
    /* 0x0158 */ FName RetargetSource;
    /* 0x0160 */ TArray<FTransform> RetargetSourceAssetReferencePose;
    /* 0x0170 */ EAnimInterpolationType Interpolation;
    /* 0x0171 */ bool bEnableRootMotion;
    /* 0x0172 */ uint8_t RootMotionRootLock;
    /* 0x0173 */ bool bForceRootLock;
    /* 0x0174 */ bool bUseNormalizedRootMotionScale;
    /* 0x0175 */ bool bRootMotionSettingsCopiedFromMontage;
    /* 0x0176 */ EStripAnimDataOnDedicatedServerSettings StripAnimDataOnDedicatedServer;
    /* 0x0178 */ TArray<FAnimSyncMarker> AuthoredSyncMarkers;
    /* 0x0198 */ FPerPlatformFrameRate PlatformTargetFrameRate;
    /* 0x01a0 */ TMap<FAnimationAttributeIdentifier, FAttributeCurve> AttributeCurves;
};

// Size: 0xb0
class UAnimSequenceBase : public UAnimationAsset {
    /* 0x0080 */ TArray<FAnimNotifyEvent> Notifies;
    /* 0x0090 */ float SequenceLength;
    /* 0x0098 */ FRawCurveTracks RawCurveData;
    /* 0x00a8 */ float RateScale;
    /* 0x00ac */ bool bLoop;
};

// Size: 0x20
struct FAnimSequenceTrackContainer {
    /* 0x0000 */ TArray<FRawAnimSequenceTrack> AnimationTracks;
    /* 0x0010 */ TArray<FName> TrackNames;
};

// Size: 0xf0
class UAnimSet : public UObject {
    /* 0x0028 */ bool bAnimRotationOnly;
    /* 0x0030 */ TArray<FName> TrackBoneNames;
    /* 0x0040 */ TArray<FAnimSetMeshLinkup> LinkupCache;
    /* 0x0050 */ TArray<uint8_t> BoneUseAnimTranslation;
    /* 0x0060 */ TArray<uint8_t> ForceUseMeshTranslation;
    /* 0x0070 */ TArray<FName> UseTranslationBoneNames;
    /* 0x0080 */ TArray<FName> ForceMeshTranslationBoneNames;
    /* 0x0090 */ FName PreviewSkelMeshName;
    /* 0x0098 */ FName BestRatioSkelMeshName;
};

// Size: 0x10
struct FAnimSetMeshLinkup {
    /* 0x0000 */ TArray<int32_t> BoneToTrackTable;
};

// Size: 0x3f0
class UAnimSingleNodeInstance : public UAnimInstance {
    /* 0x03d8 */ UAnimationAsset* CurrentAsset;
    /* 0x03e0 */ FDelegate PostEvaluateAnimEvent;

    UAnimationAsset* GetAnimationAsset() const;
    float GetLength();
    UMirrorDataTable* GetMirrorDataTable();
    void PlayAnim(bool bIsLooping, float InPlayRate, float InStartPosition);
    void SetAnimationAsset(UAnimationAsset* NewAsset, bool bIsLooping, float InPlayRate);
    void SetBlendSpacePosition(const FVector& InPosition);
    void SetLooping(bool bIsLooping);
    void SetMirrorDataTable(const UMirrorDataTable* MirrorDataTable);
    void SetPlayRate(float InPlayRate);
    void SetPlaying(bool bIsPlaying);
    void SetPosition(float InPosition, bool bFireNotifies);
    void SetPositionWithPreviousTime(float InPosition, float InPreviousTime, bool bFireNotifies);
    void SetPreviewCurveOverride(const FName& PoseName, float Value, bool bRemoveIfZero);
    void SetReverse(bool bInReverse);
    void StopAnim();
};

// Size: 0x8a0
struct FAnimSingleNodeInstanceProxy : public FAnimInstanceProxy {
};

// Size: 0xc
struct FAnimSlotDesc {
    /* 0x0000 */ FName SlotName;
    /* 0x0008 */ int32_t NumChannels;
};

// Size: 0x18
struct FAnimSlotGroup {
    /* 0x0000 */ FName GroupName;
    /* 0x0008 */ TArray<FName> SlotNames;
};

// Size: 0x28
class UAnimStateMachineTypes : public UObject {
};

// Size: 0xf8
class UAnimStreamable : public UAnimSequenceBase {
    /* 0x00b0 */ int32_t NumberOfKeys;
    /* 0x00b4 */ EAnimInterpolationType Interpolation;
    /* 0x00b8 */ FName RetargetSource;
    /* 0x00c0 */ FFrameRate SamplingFrameRate;
    /* 0x00d8 */ UAnimBoneCompressionSettings* BoneCompressionSettings;
    /* 0x00e0 */ UAnimCurveCompressionSettings* CurveCompressionSettings;
    /* 0x00e8 */ UVariableFrameStrippingSettings* VariableFrameStrippingSettings;
    /* 0x00f0 */ bool bEnableRootMotion;
    /* 0x00f1 */ uint8_t RootMotionRootLock;
    /* 0x00f2 */ bool bForceRootLock;
    /* 0x00f3 */ bool bUseNormalizedRootMotionScale;
};

// Size: 0x8
struct FAnimSubsystem {
};

// Size: 0x8
struct FAnimSubsystemInstance {
};

// Size: 0xa8
struct FAnimSubsystemInstance_NodeRelevancy : public FAnimSubsystemInstance {
};

// Size: 0x40
struct FAnimSubsystem_Base : public FAnimSubsystem {
};

// Size: 0x18
struct FAnimSubsystem_BlendSpaceGraph : public FAnimSubsystem {
    /* 0x0008 */ TArray<UBlendSpace*> BlendSpaces;
};

// Size: 0x80
struct FAnimSubsystem_PropertyAccess : public FAnimSubsystem {
    /* 0x0008 */ FPropertyAccessLibrary Library;
};

// Size: 0x28
struct FAnimSubsystem_SharedLinkedAnimLayers : public FAnimSubsystemInstance {
    /* 0x0008 */ TArray<FLinkedAnimLayerClassData> ClassesData;
    /* 0x0018 */ TArray<UClass*> PersistentClasses;
};

// Size: 0x60
struct FAnimSubsystem_Tag : public FAnimSubsystem {
    /* 0x0008 */ TMap<FName, int32_t> NodeIndices;
};

// Size: 0xc
struct FAnimSyncMarker {
    /* 0x0000 */ FName MarkerName;
    /* 0x0008 */ float Time;
};

// Size: 0x78
struct FAnimTickRecord {
    /* 0x0000 */ UAnimationAsset* SourceAsset;
};

// Size: 0x10
struct FAnimTrack {
    /* 0x0000 */ TArray<FAnimSegment> AnimSegments;
};

// Size: 0x10
struct FAnimUpdateContext : public FAnimExecutionContext {
};

// Size: 0x88
struct FAnimUpdateRateParameters {
    /* 0x0001 */ EUpdateRateShiftBucket ShiftBucket;
    /* 0x0002 */ bool bInterpolateSkippedFrames;
    /* 0x0002 */ bool bShouldUseLodMap;
    /* 0x0002 */ bool bShouldUseMinLod;
    /* 0x0002 */ bool bSkipUpdate;
    /* 0x0002 */ bool bSkipEvaluation;
    /* 0x0004 */ int32_t UpdateRate;
    /* 0x0008 */ int32_t EvaluationRate;
    /* 0x000c */ float TickedPoseOffestTime;
    /* 0x0010 */ float AdditionalTime;
    /* 0x0018 */ int32_t BaseNonRenderedUpdateRate;
    /* 0x001c */ int32_t MaxEvalRateForInterpolation;
    /* 0x0020 */ TArray<float> BaseVisibleDistanceFactorThesholds;
    /* 0x0030 */ TMap<int32_t, int32_t> LODToFrameSkipMap;
    /* 0x0080 */ int32_t SkippedUpdateFrames;
    /* 0x0084 */ int32_t SkippedEvalFrames;
};

// Size: 0xf0
struct FAnimatedBoneAttribute {
    /* 0x0000 */ FAnimationAttributeIdentifier Identifier;
    /* 0x0040 */ FAttributeCurve Curve;
};

// Size: 0xb0
class UAnimatedSparseVolumeTexture : public UStreamableSparseVolumeTexture {
};

// Size: 0x48
class UAnimatedSparseVolumeTextureController : public UObject {
    /* 0x0028 */ USparseVolumeTexture* SparseVolumeTexture;
    /* 0x0030 */ float Time;
    /* 0x0034 */ bool bIsPlaying;
    /* 0x0038 */ float FrameRate;
    /* 0x003c */ int32_t MipLevel;
    /* 0x0040 */ bool bBlockingStreamingRequests;

    USparseVolumeTextureFrame* GetCurrentFrame();
    void GetCurrentFramesForInterpolation(USparseVolumeTextureFrame*& Frame0, USparseVolumeTextureFrame*& Frame1, float& LerpAlpha);
    float GetDuration();
    float GetFractionalFrameIndex();
    USparseVolumeTextureFrame* GetFrameByIndex(int32_t FrameIndex);
    void Pause();
    void Play();
    void Stop();
    void Update(float deltaTime);
};

// Size: 0xc8
struct FAnimationActiveTransitionEntry {
    /* 0x00b8 */ UBlendProfile* BlendProfile;
};

// Size: 0x80
class UAnimationAsset : public UObject {
    /* 0x0038 */ USkeleton* Skeleton;
    /* 0x0060 */ TArray<UAnimMetaData*> MetaData;
    /* 0x0070 */ TArray<UAssetUserData*> AssetUserData;

    UAnimMetaData* FindMetaDataByClass(const UClass* MetaDataClass) const;
    float GetPlayLength() const;
};

// Size: 0x28
class UAnimationAssetExtensions : public UBlueprintFunctionLibrary {
};

// Size: 0x40
struct FAnimationAttributeIdentifier {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName BoneName;
    /* 0x0010 */ int32_t BoneIndex;
    /* 0x0018 */ UScriptStruct* ScriptStruct;
    /* 0x0020 */ FSoftObjectPath ScriptStructPath;
};

// Size: 0x28
class UAnimationAttributeIdentifierExtensions : public UBlueprintFunctionLibrary {

    static bool IsValid(FAnimationAttributeIdentifier& Identifier);
};

enum class AnimationCompressionFormat {
    ACF_None = 0,
    ACF_Float96NoW = 1,
    ACF_Fixed48NoW = 2,
    ACF_IntervalFixed32NoW = 3,
    ACF_Fixed32NoW = 4,
    ACF_Float32NoW = 5,
    ACF_Identity = 6,
    ACF_MAX = 7,
};

// Size: 0x20
struct FAnimationCurveData {
    /* 0x0000 */ TArray<FFloatCurve> FloatCurves;
    /* 0x0010 */ TArray<FTransformCurve> TransformCurves;
};

// Size: 0xc
struct FAnimationCurveIdentifier {
    /* 0x0000 */ FName CurveName;
    /* 0x0008 */ ERawCurveTrackTypes CurveType;
    /* 0x0009 */ ETransformCurveChannel Channel;
    /* 0x000a */ EVectorCurveChannel Axis;
};

// Size: 0x28
class UAnimationCurveIdentifierExtensions : public UBlueprintFunctionLibrary {

    static FName GetName(FAnimationCurveIdentifier& Identifier);
    static ERawCurveTrackTypes GetType(FAnimationCurveIdentifier& Identifier);
    static bool IsValid(FAnimationCurveIdentifier& Identifier);
};

// Size: 0x28
class IAnimationDataController : public UInterface {

    bool AddAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact);
    bool AddBoneCurve(FName BoneName, bool bShouldTransact);
    int32_t AddBoneTrack(FName BoneName, bool bShouldTransact);
    bool AddCurve(const FAnimationCurveIdentifier& CurveId, int32_t CurveFlags, bool bShouldTransact);
    void CloseBracket(bool bShouldTransact);
    bool DuplicateAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, const FAnimationAttributeIdentifier& NewAttributeIdentifier, bool bShouldTransact);
    bool DuplicateCurve(const FAnimationCurveIdentifier& CopyCurveId, const FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact);
    void FindOrAddCurveNamesOnSkeleton(USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);
    TScriptInterface<IAnimationDataModel> GetModelInterface() const;
    int32_t InsertBoneTrack(FName BoneName, int32_t DesiredIndex, bool bShouldTransact);
    void OpenBracket(const FText& InTitle, bool bShouldTransact);
    int32_t RemoveAllAttributes(bool bShouldTransact);
    int32_t RemoveAllAttributesForBone(const FName& BoneName, bool bShouldTransact);
    void RemoveAllBoneTracks(bool bShouldTransact);
    void RemoveAllCurvesOfType(ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);
    bool RemoveAttribute(const FAnimationAttributeIdentifier& AttributeIdentifier, bool bShouldTransact);
    bool RemoveAttributeKey(const FAnimationAttributeIdentifier& AttributeIdentifier, float Time, bool bShouldTransact);
    bool RemoveBoneTrack(FName BoneName, bool bShouldTransact);
    bool RemoveCurve(const FAnimationCurveIdentifier& CurveId, bool bShouldTransact);
    bool RemoveCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact);
    bool RemoveTransformCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, bool bShouldTransact);
    bool RenameCurve(const FAnimationCurveIdentifier& CurveToRenameId, const FAnimationCurveIdentifier& NewCurveId, bool bShouldTransact);
    void Resize(float Length, float T0, float T1, bool bShouldTransact);
    void ResizeInFrames(FFrameNumber NewLengthInFrames, FFrameNumber T0, FFrameNumber T1, bool bShouldTransact);
    void ResizeNumberOfFrames(FFrameNumber NewLengthInFrames, FFrameNumber T0, FFrameNumber T1, bool bShouldTransact);
    void ResizePlayLength(float NewLength, float T0, float T1, bool bShouldTransact);
    bool ScaleCurve(const FAnimationCurveIdentifier& CurveId, float Origin, float Factor, bool bShouldTransact);
    bool SetBoneTrackKeys(FName BoneName, const TArray<FVector>& PositionalKeys, const TArray<FQuat>& RotationalKeys, const TArray<FVector>& ScalingKeys, bool bShouldTransact);
    bool SetCurveColor(const FAnimationCurveIdentifier& CurveId, FLinearColor Color, bool bShouldTransact);
    bool SetCurveComment(const FAnimationCurveIdentifier& CurveId, FString Comment, bool bShouldTransact);
    bool SetCurveFlag(const FAnimationCurveIdentifier& CurveId, uint8_t Flag, bool bState, bool bShouldTransact);
    bool SetCurveFlags(const FAnimationCurveIdentifier& CurveId, int32_t Flags, bool bShouldTransact);
    bool SetCurveKey(const FAnimationCurveIdentifier& CurveId, const FRichCurveKey& Key, bool bShouldTransact);
    bool SetCurveKeys(const FAnimationCurveIdentifier& CurveId, const TArray<FRichCurveKey>& CurveKeys, bool bShouldTransact);
    void SetFrameRate(FFrameRate FrameRate, bool bShouldTransact);
    void SetModel(TScriptInterface<IAnimationDataModel> InModel);
    void SetNumberOfFrames(FFrameNumber NewLengthInFrames, bool bShouldTransact);
    void SetPlayLength(float Length, bool bShouldTransact);
    bool SetTransformCurveKey(const FAnimationCurveIdentifier& CurveId, float Time, const FTransform& Value, bool bShouldTransact);
    bool SetTransformCurveKeys(const FAnimationCurveIdentifier& CurveId, const TArray<FTransform>& TransformValues, const TArray<float>& TimeKeys, bool bShouldTransact);
    void UpdateCurveNamesFromSkeleton(const USkeleton* Skeleton, ERawCurveTrackTypes SupportedCurveType, bool bShouldTransact);
};

// Size: 0x28
class IAnimationDataModel : public UInterface {

    UAnimSequence* GetAnimationSequence() const;
    TArray<FBoneAnimationTrack> GetBoneAnimationTracks() const;
    FBoneAnimationTrack GetBoneTrackByIndex(int32_t TrackIndex) const;
    FBoneAnimationTrack GetBoneTrackByName(FName TrackName) const;
    int32_t GetBoneTrackIndex(const FBoneAnimationTrack& Track) const;
    int32_t GetBoneTrackIndexByName(FName TrackName) const;
    void GetBoneTrackNames(TArray<FName>& OutNames) const;
    FFrameRate GetFrameRate() const;
    int32_t GetNumBoneTracks() const;
    int32_t GetNumberOfFloatCurves() const;
    int32_t GetNumberOfFrames() const;
    int32_t GetNumberOfKeys() const;
    int32_t GetNumberOfTransformCurves() const;
    double GetPlayLength() const;
    bool IsValidBoneTrackIndex(int32_t TrackIndex) const;
    bool IsValidBoneTrackName(const FName& TrackName) const;
};

// Size: 0x28
class UAnimationDataModelNotifiesExtensions : public UBlueprintFunctionLibrary {
};

// Size: 0x10
struct FAnimationErrorStats {
};

// Size: 0x1
struct FAnimationFrameSnapshot {
};

// Size: 0x10
struct FAnimationGroupReference {
    /* 0x0000 */ EAnimSyncMethod Method;
    /* 0x0004 */ FName GroupName;
    /* 0x000c */ uint8_t GroupRole;
};

enum class AnimationKeyFormat {
    AKF_ConstantKeyLerp = 0,
    AKF_VariableKeyLerp = 1,
    AKF_PerTrackCompression = 2,
    AKF_MAX = 3,
};

// Size: 0x30
struct FAnimationPotentialTransition {
};

// Size: 0x40
struct FAnimationRecordingSettings {
    /* 0x0000 */ bool bRecordInWorldSpace;
    /* 0x0001 */ bool bRemoveRootAnimation;
    /* 0x0002 */ bool bAutoSaveAsset;
    /* 0x0004 */ FFrameRate SampleFrameRate;
    /* 0x000c */ float Length;
    /* 0x0010 */ EAnimInterpolationType Interpolation;
    /* 0x0011 */ uint8_t InterpMode;
    /* 0x0012 */ uint8_t TangentMode;
    /* 0x0014 */ bool bRecordTransforms;
    /* 0x0015 */ bool bRecordMorphTargets;
    /* 0x0016 */ bool bRecordAttributeCurves;
    /* 0x0017 */ bool bRecordMaterialCurves;
    /* 0x0018 */ bool bTransactRecording;
    /* 0x0020 */ TArray<FString> IncludeAnimationNames;
    /* 0x0030 */ TArray<FString> ExcludeAnimationNames;
};

// Size: 0x148
class UAnimationSettings : public UDeveloperSettings {
    /* 0x0038 */ int32_t CompressCommandletVersion;
    /* 0x0040 */ TArray<FString> KeyEndEffectorsMatchNameArray;
    /* 0x0050 */ bool ForceRecompression;
    /* 0x0051 */ bool bForceBelowThreshold;
    /* 0x0052 */ bool bFirstRecompressUsingCurrentOrDefault;
    /* 0x0053 */ bool bRaiseMaxErrorToExisting;
    /* 0x0054 */ bool bEnablePerformanceLog;
    /* 0x0055 */ bool bStripAnimationDataOnDedicatedServer;
    /* 0x0056 */ bool bTickAnimationOnSkeletalMeshInit;
    /* 0x0058 */ FTimecodeCustomAttributeNameSettings BoneTimecodeCustomAttributeNameSettings;
    /* 0x0090 */ TArray<FCustomAttributeSetting> BoneCustomAttributesNames;
    /* 0x00a0 */ TArray<FString> BoneNamesWithCustomAttributes;
    /* 0x00b0 */ TMap<FName, ECustomAttributeBlendType> AttributeBlendModes;
    /* 0x0100 */ ECustomAttributeBlendType DefaultAttributeBlendMode;
    /* 0x0108 */ TArray<FString> TransformAttributeNames;
    /* 0x0118 */ TArray<TSoftObjectPtr<UUserDefinedStruct>> UserDefinedStructAttributes;
    /* 0x0128 */ TArray<FMirrorFindReplaceExpression> MirrorFindReplaceExpressions;
    /* 0x0138 */ FFrameRate DefaultFrameRate;
    /* 0x0140 */ bool bEnforceSupportedFrameRates;

    TArray<FString> GetBoneCustomAttributeNamesToImport() const;
};

// Size: 0x28
struct FAnimationState : public FAnimationStateBase {
    /* 0x0008 */ TArray<FAnimationTransitionRule> Transitions;
    /* 0x0018 */ int32_t StateRootNodeIndex;
    /* 0x001c */ int32_t StartNotify;
    /* 0x0020 */ int32_t EndNotify;
    /* 0x0024 */ int32_t FullyBlendedNotify;
};

// Size: 0x8
struct FAnimationStateBase {
    /* 0x0000 */ FName StateName;
};

// Size: 0xc
struct FAnimationTrackAddedPayload : public FAnimationTrackPayload {
    /* 0x0008 */ int32_t TrackIndex;
};

// Size: 0x8
struct FAnimationTrackPayload : public FEmptyPayload {
    /* 0x0000 */ FName Name;
};

// Size: 0x40
struct FAnimationTransitionBetweenStates : public FAnimationStateBase {
    /* 0x0008 */ int32_t PreviousState;
    /* 0x000c */ int32_t NextState;
    /* 0x0010 */ float CrossfadeDuration;
    /* 0x0014 */ int32_t StartNotify;
    /* 0x0018 */ int32_t EndNotify;
    /* 0x001c */ int32_t InterruptNotify;
    /* 0x0020 */ EAlphaBlendOption BlendMode;
    /* 0x0028 */ UCurveFloat* CustomCurve;
    /* 0x0030 */ UBlendProfile* BlendProfile;
    /* 0x0038 */ uint8_t LogicType;
};

// Size: 0x10
struct FAnimationTransitionRule {
    /* 0x0000 */ FName RuleToExecute;
    /* 0x0008 */ bool TransitionReturnVal;
    /* 0x000c */ int32_t TransitionIndex;
};

// Size: 0x148
class UApplicationLifecycleComponent : public UActorComponent {
    /* 0x00b8 */ FMulticastInlineDelegate ApplicationWillDeactivateDelegate;
    /* 0x00c8 */ FMulticastInlineDelegate ApplicationHasReactivatedDelegate;
    /* 0x00d8 */ FMulticastInlineDelegate ApplicationWillEnterBackgroundDelegate;
    /* 0x00e8 */ FMulticastInlineDelegate ApplicationHasEnteredForegroundDelegate;
    /* 0x00f8 */ FMulticastInlineDelegate ApplicationWillTerminateDelegate;
    /* 0x0108 */ FMulticastInlineDelegate ApplicationShouldUnloadResourcesDelegate;
    /* 0x0118 */ FMulticastInlineDelegate ApplicationReceivedStartupArgumentsDelegate;
    /* 0x0128 */ FMulticastInlineDelegate OnTemperatureChangeDelegate;
    /* 0x0138 */ FMulticastInlineDelegate OnLowPowerModeDelegate;

    void ApplicationLifetimeDelegate__DelegateSignature();
    void ApplicationStartupArgumentsDelegate__DelegateSignature(const TArray<FString>& StartupArguments);
    void OnLowPowerModeDelegate__DelegateSignature(bool bInLowPowerMode);
    void OnTemperatureChangeDelegate__DelegateSignature(ETemperatureSeverityType Severity);
};

// Size: 0x540
class UArrowComponent : public UPrimitiveComponent {
    /* 0x0520 */ FColor ArrowColor;
    /* 0x0524 */ float ArrowSize;
    /* 0x0528 */ float ArrowLength;
    /* 0x052c */ float ScreenSize;
    /* 0x0530 */ bool bIsScreenSizeScaled;
    /* 0x0530 */ bool bTreatAsASprite;

    void SetArrowColor(FLinearColor NewColor);
    void SetArrowFColor(FColor NewColor);
    void SetArrowLength(float NewLength);
    void SetArrowSize(float NewSize);
    void SetIsScreenSizeScaled(bool bNewValue);
    void SetScreenSize(float NewScreenSize);
    void SetTreatAsASprite(bool bNewValue);
    void SetUseInEditorScaling(bool bNewValue);
};

// Size: 0x8
struct FAssetCompileData {
    /* 0x0000 */ TWeakObjectPtr<UObject> Asset;
};

// Size: 0x50
struct FAssetEditorOrbitCameraPosition {
    /* 0x0000 */ bool bIsSet;
    /* 0x0008 */ FVector CamOrbitPoint;
    /* 0x0020 */ FVector CamOrbitZoom;
    /* 0x0038 */ FRotator CamOrbitRotation;
};

// Size: 0x78
class UAssetExportTask : public UObject {
    /* 0x0028 */ UObject* Object;
    /* 0x0030 */ UExporter* Exporter;
    /* 0x0038 */ FString Filename;
    /* 0x0048 */ bool bSelected;
    /* 0x0049 */ bool bReplaceIdentical;
    /* 0x004a */ bool bPrompt;
    /* 0x004b */ bool bAutomated;
    /* 0x004c */ bool bUseFileArchive;
    /* 0x004d */ bool bWriteEmptyFiles;
    /* 0x0050 */ TArray<UObject*> IgnoreObjectList;
    /* 0x0060 */ UObject* Options;
    /* 0x0068 */ TArray<FString> Errors;
};

// Size: 0x28
class UAssetImportData : public UObject {
};

// Size: 0x1
struct FAssetImportInfo {
};

// Size: 0x10
struct FAssetLocatorFragment {
    /* 0x0000 */ FTopLevelAssetPath Path;
};

// Size: 0x4d0
class UAssetManager : public UObject {
    /* 0x0330 */ TArray<UObject*> ObjectReferenceList;
    /* 0x0340 */ bool bIsGlobalAsyncScanEnvironment;
    /* 0x0341 */ bool bShouldGuessTypeAndName;
    /* 0x0342 */ bool bShouldUseSynchronousLoad;
    /* 0x0343 */ bool bIsLoadingFromPakFiles;
    /* 0x0344 */ bool bShouldAcquireMissingChunksOnLoad;
    /* 0x0345 */ bool bOnlyCookProductionAssets;
    /* 0x0348 */ int32_t NumBulkScanRequests;
    /* 0x034c */ bool bIsPrimaryAssetDirectoryCurrent;
    /* 0x034d */ bool bIsManagementDatabaseCurrent;
    /* 0x034e */ bool bUpdateManagementDatabaseAfterScan;
    /* 0x034f */ bool bIncludeOnlyOnDiskAssets;
    /* 0x0350 */ bool bHasCompletedInitialScan;
    /* 0x0354 */ int32_t NumberOfSpawnedNotifications;
};

// Size: 0x20
struct FAssetManagerRedirect {
    /* 0x0000 */ FString Old;
    /* 0x0010 */ FString New;
};

// Size: 0x50
struct FAssetManagerSearchRules {
    /* 0x0000 */ TArray<FString> AssetScanPaths;
    /* 0x0010 */ TArray<FString> IncludePatterns;
    /* 0x0020 */ TArray<FString> ExcludePatterns;
    /* 0x0030 */ UClass* AssetBaseClass;
    /* 0x0038 */ bool bHasBlueprintClasses;
    /* 0x0039 */ bool bForceSynchronousScan;
    /* 0x003a */ bool bSkipVirtualPathExpansion;
    /* 0x003b */ bool bSkipManagerIncludeCheck;
};

// Size: 0x100
class UAssetManagerSettings : public UDeveloperSettings {
    /* 0x0038 */ TArray<FPrimaryAssetTypeInfo> PrimaryAssetTypesToScan;
    /* 0x0048 */ TArray<FDirectoryPath> DirectoriesToExclude;
    /* 0x0058 */ TArray<FPrimaryAssetRulesOverride> PrimaryAssetRules;
    /* 0x0068 */ TArray<FPrimaryAssetRulesCustomOverride> CustomPrimaryAssetRules;
    /* 0x0078 */ bool bOnlyCookProductionAssets;
    /* 0x0079 */ bool bShouldManagerDetermineTypeAndName;
    /* 0x007a */ bool bShouldGuessTypeAndNameInEditor;
    /* 0x007b */ bool bShouldAcquireMissingChunksOnLoad;
    /* 0x007c */ bool bShouldWarnAboutInvalidAssets;
    /* 0x0080 */ TArray<FAssetManagerRedirect> PrimaryAssetIdRedirects;
    /* 0x0090 */ TArray<FAssetManagerRedirect> PrimaryAssetTypeRedirects;
    /* 0x00a0 */ TArray<FAssetManagerRedirect> AssetPathRedirects;
    /* 0x00b0 */ TSet<FName> MetaDataTagsForAssetRegistry;
};

// Size: 0x10
struct FAssetMapping {
    /* 0x0000 */ UAnimationAsset* SourceAsset;
    /* 0x0008 */ UAnimationAsset* TargetAsset;
};

// Size: 0x38
class UAssetMappingTable : public UObject {
    /* 0x0028 */ TArray<FAssetMapping> MappedAssets;
};

// Size: 0x28
class IAssetRegistryTagProviderInterface : public UInterface {
};

// Size: 0x28
class UAssetUserData : public UObject {
};

// Size: 0x88
class UAsyncActionChangePrimaryAssetBundles : public UAsyncActionLoadPrimaryAssetBase {
    /* 0x0078 */ FMulticastInlineDelegate completed;

    static UAsyncActionChangePrimaryAssetBundles* AsyncChangeBundleStateForMatchingPrimaryAssets(UObject* WorldContextObject, const TArray<FName>& NewBundles, const TArray<FName>& OldBundles);
    static UAsyncActionChangePrimaryAssetBundles* AsyncChangeBundleStateForPrimaryAssetList(UObject* WorldContextObject, const TArray<FPrimaryAssetId>& PrimaryAssetList, const TArray<FName>& AddBundles, const TArray<FName>& RemoveBundles);
};

// Size: 0x68
class UAsyncActionHandleSaveGame : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate completed;
    /* 0x0060 */ USaveGame* SaveGameObject;

    static UAsyncActionHandleSaveGame* AsyncLoadGameFromSlot(UObject* WorldContextObject, FString SlotName, const int32_t UserIndex);
    static UAsyncActionHandleSaveGame* AsyncSaveGameToSlot(UObject* WorldContextObject, USaveGame* SaveGameObject, FString SlotName, const int32_t UserIndex);
};

// Size: 0x88
class UAsyncActionLoadPrimaryAsset : public UAsyncActionLoadPrimaryAssetBase {
    /* 0x0078 */ FMulticastInlineDelegate completed;

    static UAsyncActionLoadPrimaryAsset* AsyncLoadPrimaryAsset(UObject* WorldContextObject, FPrimaryAssetId PrimaryAsset, const TArray<FName>& LoadBundles);
};

// Size: 0x78
class UAsyncActionLoadPrimaryAssetBase : public UBlueprintAsyncActionBase {
};

// Size: 0x88
class UAsyncActionLoadPrimaryAssetClass : public UAsyncActionLoadPrimaryAssetBase {
    /* 0x0078 */ FMulticastInlineDelegate completed;

    static UAsyncActionLoadPrimaryAssetClass* AsyncLoadPrimaryAssetClass(UObject* WorldContextObject, FPrimaryAssetId PrimaryAsset, const TArray<FName>& LoadBundles);
};

// Size: 0x88
class UAsyncActionLoadPrimaryAssetClassList : public UAsyncActionLoadPrimaryAssetBase {
    /* 0x0078 */ FMulticastInlineDelegate completed;

    static UAsyncActionLoadPrimaryAssetClassList* AsyncLoadPrimaryAssetClassList(UObject* WorldContextObject, const TArray<FPrimaryAssetId>& PrimaryAssetList, const TArray<FName>& LoadBundles);
};

// Size: 0x88
class UAsyncActionLoadPrimaryAssetList : public UAsyncActionLoadPrimaryAssetBase {
    /* 0x0078 */ FMulticastInlineDelegate completed;

    static UAsyncActionLoadPrimaryAssetList* AsyncLoadPrimaryAssetList(UObject* WorldContextObject, const TArray<FPrimaryAssetId>& PrimaryAssetList, const TArray<FName>& LoadBundles);
};

// Size: 0x50
class UAsyncLoadingTests_ConvertFromType_V1 : public UObject {
    /* 0x0028 */ TSoftObjectPtr<UObject> Reference;
};

// Size: 0x30
class UAsyncLoadingTests_ConvertFromType_V2 : public UObject {
    /* 0x0028 */ UObject* Reference;
};

// Size: 0x58
class UAsyncLoadingTests_Shared : public UObject {
    /* 0x0028 */ TSoftObjectPtr<UObject> SoftReference;
    /* 0x0050 */ UObject* HardReference;
};

// Size: 0x30
class UAsyncPhysicsData : public UObject {
    /* 0x0028 */ int32_t ServerFrame;
    /* 0x002c */ int32_t ReplicationRedundancy;
};

// Size: 0xe0
class UAsyncPhysicsInputComponent : public UActorComponent {
    /* 0x00b8 */ UClass* DataClass;
    /* 0x00c0 */ TArray<UAsyncPhysicsData*> BufferedData;
    /* 0x00d0 */ UAsyncPhysicsData* DataToConsume;
    /* 0x00d8 */ UAsyncPhysicsData* DataToWrite;

    UAsyncPhysicsData* GetDataToConsume() const;
    UAsyncPhysicsData* GetDataToWrite() const;
    void ServerRPCBufferInput(UAsyncPhysicsData* AsyncPhysicsData);
};

// Size: 0x8
struct FAsyncPhysicsTimestamp {
    /* 0x0000 */ int32_t ServerFrame;
    /* 0x0004 */ int32_t LocalFrame;
};

// Size: 0x2b0
class AAtmosphericFog : public AInfo {
    /* 0x02a8 */ UAtmosphericFogComponent* AtmosphericFogComponent;
};

// Size: 0x350
class UAtmosphericFogComponent : public USkyAtmosphereComponent {

    void DisableGroundScattering(bool NewGroundScattering);
    void DisableSunDisk(bool NewSunDisk);
    void SetAltitudeScale(float NewAltitudeScale);
    void SetDefaultBrightness(float NewBrightness);
    void SetDefaultLightColor(FLinearColor NewLightColor);
    void SetDensityMultiplier(float NewDensityMultiplier);
    void SetDensityOffset(float NewDensityOffset);
    void SetDistanceOffset(float NewDistanceOffset);
    void SetDistanceScale(float NewDistanceScale);
    void SetFogMultiplier(float NewFogMultiplier);
    void SetPrecomputeParams(float DensityHeight, int32_t MaxScatteringOrder, int32_t InscatterAltitudeSampleNum);
    void SetStartDistance(float NewStartDistance);
    void SetSunMultiplier(float NewSunMultiplier);
};

// Size: 0xb0
struct FAttenuationSubmixSendSettings : public FSoundSubmixSendInfoBase {
};

// Size: 0xb0
struct FAttributeCurve : public FIndexedCurve {
    /* 0x0068 */ TArray<FAttributeKey> Keys;
    /* 0x0078 */ FSoftObjectPath ScriptStructPath;
    /* 0x0098 */ UScriptStruct* ScriptStruct;
    /* 0x00a0 */ bool bShouldInterpolate;
};

// Size: 0x18
struct FAttributeKey {
    /* 0x0000 */ float Time;
};

// Size: 0x40
struct FAttributePayload : public FEmptyPayload {
    /* 0x0000 */ FAnimationAttributeIdentifier Identifier;
};

// Size: 0x8
struct FAudioBasedVibrationData {
    /* 0x0000 */ USoundBase* Sound;
};

// Size: 0x38
class UAudioBus : public UObject {
    /* 0x0030 */ EAudioBusChannels AudioBusChannels;
};

// Size: 0xc30
class UAudioComponent : public USceneComponent {
    /* 0x03f8 */ USoundBase* Sound;
    /* 0x0400 */ TArray<FAudioParameter> DefaultParameters;
    /* 0x0410 */ TArray<FAudioParameter> InstanceParameters;
    /* 0x0420 */ USoundClass* SoundClassOverride;
    /* 0x0428 */ bool bAutoDestroy;
    /* 0x0428 */ bool bStopWhenOwnerDestroyed;
    /* 0x0428 */ bool bShouldRemainActiveIfDropped;
    /* 0x0428 */ bool bAllowSpatialization;
    /* 0x0428 */ bool bOverrideAttenuation;
    /* 0x0428 */ bool bOverrideSubtitlePriority;
    /* 0x0428 */ bool bIsUISound;
    /* 0x0428 */ bool bEnableLowPassFilter;
    /* 0x0429 */ bool bEnableHighPassFilter;
    /* 0x0429 */ bool bOverridePriority;
    /* 0x0429 */ bool bSuppressSubtitles;
    /* 0x0429 */ bool bCanPlayMultipleInstances;
    /* 0x0429 */ bool bDisableParameterUpdatesWhilePlaying;
    /* 0x042a */ bool bAutoManageAttachment;
    /* 0x0430 */ FName AudioComponentUserID;
    /* 0x0438 */ float PitchModulationMin;
    /* 0x043c */ float PitchModulationMax;
    /* 0x0440 */ float VolumeModulationMin;
    /* 0x0444 */ float VolumeModulationMax;
    /* 0x0448 */ float VolumeMultiplier;
    /* 0x044c */ int32_t EnvelopeFollowerAttackTime;
    /* 0x0450 */ int32_t EnvelopeFollowerReleaseTime;
    /* 0x0454 */ float Priority;
    /* 0x0458 */ float SubtitlePriority;
    /* 0x0460 */ USoundEffectSourcePresetChain* SourceEffectChain;
    /* 0x0468 */ float PitchMultiplier;
    /* 0x046c */ float LowPassFilterFrequency;
    /* 0x0470 */ float HighPassFilterFrequency;
    /* 0x0478 */ USoundAttenuation* AttenuationSettings;
    /* 0x0480 */ FSoundAttenuationSettings AttenuationOverrides;
    /* 0x0850 */ USoundConcurrency* ConcurrencySettings;
    /* 0x0858 */ TSet<USoundConcurrency*> ConcurrencySet;
    /* 0x08a8 */ float OcclusionCheckInterval;
    /* 0x08b4 */ EAttachmentRule AutoAttachLocationRule;
    /* 0x08b5 */ EAttachmentRule AutoAttachRotationRule;
    /* 0x08b6 */ EAttachmentRule AutoAttachScaleRule;
    /* 0x08b8 */ FSoundModulationDefaultRoutingSettings ModulationRouting;
    /* 0x0a20 */ FMulticastInlineDelegate OnAudioPlayStateChanged;
    /* 0x0a48 */ FMulticastInlineDelegate OnAudioVirtualizationChanged;
    /* 0x0a70 */ FMulticastInlineDelegate OnAudioFinished;
    /* 0x0a98 */ FMulticastInlineDelegate OnAudioPlaybackPercent;
    /* 0x0ac0 */ FMulticastInlineDelegate OnAudioSingleEnvelopeValue;
    /* 0x0ae8 */ FMulticastInlineDelegate OnAudioMultiEnvelopeValue;
    /* 0x0b10 */ FDelegate OnQueueSubtitles;
    /* 0x0b30 */ TWeakObjectPtr<USceneComponent> AutoAttachParent;
    /* 0x0b38 */ FName AutoAttachSocketName;

    void AddModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination destination);
    void AdjustAttenuation(const FSoundAttenuationSettings& InAttenuationSettings);
    void AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel, const EAudioFaderCurve FadeCurve);
    bool BP_GetAttenuationSettingsToApply(FSoundAttenuationSettings& OutAttenuationSettings);
    void FadeIn(float FadeInDuration, float FadeVolumeLevel, float StartTime, const EAudioFaderCurve FadeCurve);
    void FadeOut(float FadeOutDuration, float FadeVolumeLevel, const EAudioFaderCurve FadeCurve);
    bool GetCookedEnvelopeData(float& OutEnvelopeData);
    bool GetCookedEnvelopeDataForAllPlayingSounds(TArray<FSoundWaveEnvelopeDataPerSound>& OutEnvelopeData);
    bool GetCookedFFTData(const TArray<float>& FrequenciesToGet, TArray<FSoundWaveSpectralData>& OutSoundWaveSpectralData);
    bool GetCookedFFTDataForAllPlayingSounds(TArray<FSoundWaveSpectralDataPerSound>& OutSoundWaveSpectralData);
    TSet<USoundModulatorBase*> GetModulators(const EModulationDestination destination);
    EAudioComponentPlayState GetPlayState() const;
    bool HasCookedAmplitudeEnvelopeData() const;
    bool HasCookedFFTData() const;
    bool IsPlaying() const;
    bool IsVirtualized() const;
    void Play(float StartTime);
    void PlayQuantized(const UObject* WorldContextObject, UQuartzClockHandle*& InClockHandle, FQuartzQuantizationBoundary& InQuantizationBoundary, const FDelegate& InDelegate, float InStartTime, float InFadeInDuration, float InFadeVolumeLevel, EAudioFaderCurve InFadeCurve);
    void RemoveModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination destination);
    void SetAttenuationOverrides(const FSoundAttenuationSettings& InAttenuationOverrides);
    void SetAttenuationSettings(USoundAttenuation* InAttenuationSettings);
    void SetAudioBusSendPostEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
    void SetAudioBusSendPreEffect(UAudioBus* AudioBus, float AudioBusSendLevel);
    void SetBoolParameter(FName InName, bool InBool);
    void SetFloatParameter(FName InName, float InFloat);
    void SetHighPassFilterEnabled(bool InHighPassFilterEnabled);
    void SetHighPassFilterFrequency(float InHighPassFilterFrequency);
    void SetIntParameter(FName InName, int32_t inInt);
    void SetLowPassFilterEnabled(bool InLowPassFilterEnabled);
    void SetLowPassFilterFrequency(float InLowPassFilterFrequency);
    void SetModulationRouting(const TSet<USoundModulatorBase*>& Modulators, const EModulationDestination destination, const EModulationRouting RoutingMethod);
    void SetOutputToBusOnly(bool bInOutputToBusOnly);
    void SetOverrideAttenuation(bool bInOverrideAttenuation);
    void SetPaused(bool bPause);
    void SetPitchMultiplier(float NewPitchMultiplier);
    void SetSound(USoundBase* NewSound);
    void SetSourceBusSendPostEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
    void SetSourceBusSendPreEffect(USoundSourceBus* SoundSourceBus, float SourceBusSendLevel);
    void SetSubmixSend(USoundSubmixBase* Submix, float SendLevel);
    void SetUISound(bool bInUISound);
    void SetVolumeMultiplier(float NewVolumeMultiplier);
    void SetWaveParameter(FName InName, USoundWave* InWave);
    void Stop();
    void StopDelayed(float DelayTime);
};

// Size: 0xa8
struct FAudioComponentParam : public FAudioParameter {
    /* 0x00a0 */ USoundWave* SoundWaveParam;
};

// Size: 0x28
struct FAudioCookOutputs {
    /* 0x0000 */ uint32_t ID;
    /* 0x0004 */ int32_t Version;
    /* 0x0008 */ int32_t NumChannels;
    /* 0x000c */ int32_t SampleRate;
    /* 0x0010 */ uint32_t NumFrames;
    /* 0x0018 */ TArray<uint8_t> EncodedData;
};

// Size: 0x40
struct FAudioEQEffect : public FAudioEffectParameters {
    /* 0x0010 */ float FrequencyCenter0;
    /* 0x0014 */ float Gain0;
    /* 0x0018 */ float Bandwidth0;
    /* 0x001c */ float FrequencyCenter1;
    /* 0x0020 */ float Gain1;
    /* 0x0024 */ float Bandwidth1;
    /* 0x0028 */ float FrequencyCenter2;
    /* 0x002c */ float Gain2;
    /* 0x0030 */ float Bandwidth2;
    /* 0x0034 */ float FrequencyCenter3;
    /* 0x0038 */ float Gain3;
    /* 0x003c */ float Bandwidth3;
};

// Size: 0x8
struct FAudioEffectParameters {
};

// Size: 0x30
class UAudioEngineSubsystem : public UDynamicSubsystem {
};

// Size: 0x28
class IAudioPanelWidgetInterface : public UInterface {

    FText GetEditorName();
    FName GetIconBrushName();
};

// Size: 0x28
class UAudioParameterConversionStatics : public UBlueprintFunctionLibrary {

    static FAudioParameter BooleanArrayToAudioParameter(FName Name, TArray<bool> Bools);
    static FAudioParameter BooleanToAudioParameter(FName Name, bool bool);
    static FAudioParameter FloatArrayToAudioParameter(FName Name, TArray<float> Floats);
    static FAudioParameter FloatToAudioParameter(FName Name, float float);
    static FAudioParameter IntegerArrayToAudioParameter(FName Name, TArray<int32_t> Integers);
    static FAudioParameter IntegerToAudioParameter(FName Name, int32_t Integer);
    static FAudioParameter ObjectArrayToAudioParameter(FName Name, TArray<UObject*> Objects);
    static FAudioParameter ObjectToAudioParameter(FName Name, UObject* Object);
    static FAudioParameter StringArrayToAudioParameter(FName Name, TArray<FString> Strings);
    static FAudioParameter StringToAudioParameter(FName Name, FString String);
};

// Size: 0x18
struct FAudioQualitySettings {
    /* 0x0000 */ FText DisplayName;
    /* 0x0010 */ int32_t MaxChannels;
};

// Size: 0x48
struct FAudioReverbEffect : public FAudioEffectParameters {
};

// Size: 0x1e8
class UAudioSettings : public UDeveloperSettings {
    /* 0x0038 */ FSoftObjectPath DefaultSoundClassName;
    /* 0x0058 */ FSoftObjectPath DefaultMediaSoundClassName;
    /* 0x0078 */ FSoftObjectPath DefaultSoundConcurrencyName;
    /* 0x0098 */ FSoftObjectPath DefaultBaseSoundMix;
    /* 0x00b8 */ FSoftObjectPath VoiPSoundClass;
    /* 0x00d8 */ FSoftObjectPath MasterSubmix;
    /* 0x00f8 */ FSoftObjectPath BaseDefaultSubmix;
    /* 0x0118 */ FSoftObjectPath ReverbSubmix;
    /* 0x0138 */ FSoftObjectPath EQSubmix;
    /* 0x0158 */ EVoiceSampleRate VoiPSampleRate;
    /* 0x015c */ EDefaultAudioCompressionType DefaultAudioCompressionType;
    /* 0x0160 */ FPerPlatformFloat DefaultOcclusionCheckInterval;
    /* 0x0164 */ int32_t DefaultCompressionQuality;
    /* 0x0168 */ float DefaultReverbSendLevel;
    /* 0x016c */ int32_t MaximumConcurrentStreams;
    /* 0x0170 */ float GlobalMinPitchScale;
    /* 0x0174 */ float GlobalMaxPitchScale;
    /* 0x0178 */ TArray<FAudioQualitySettings> QualityLevels;
    /* 0x0188 */ bool bAllowPlayWhenSilent;
    /* 0x0188 */ bool bDisableMasterEQ;
    /* 0x0188 */ bool bAllowCenterChannel3DPanning;
    /* 0x018c */ uint32_t NumStoppingSources;
    /* 0x0190 */ EPanningMethod PanningMethod;
    /* 0x0191 */ EMonoChannelUpmixMethod MonoChannelUpmixMethod;
    /* 0x0198 */ FString DialogueFilenameFormat;
    /* 0x01a8 */ TArray<FSoundDebugEntry> DebugSounds;
    /* 0x01b8 */ TArray<FDefaultAudioBusSettings> DefaultAudioBuses;
    /* 0x01c8 */ USoundClass* DefaultSoundClass;
    /* 0x01d0 */ USoundClass* DefaultMediaSoundClass;
    /* 0x01d8 */ USoundConcurrency* DefaultSoundConcurrency;
};

// Size: 0x30
class UAudioSubsystemCollectionRoot : public UObject {
};

// Size: 0x350
class AAudioVolume : public AVolume {
    /* 0x02e0 */ float Priority;
    /* 0x02e4 */ bool bEnabled;
    /* 0x02e8 */ FReverbSettings Settings;
    /* 0x0308 */ FInteriorSettings AmbientZoneSettings;
    /* 0x0330 */ TArray<FAudioVolumeSubmixSendSettings> SubmixSendSettings;
    /* 0x0340 */ TArray<FAudioVolumeSubmixOverrideSettings> SubmixOverrideSettings;

    void OnRep_bEnabled();
    void SetEnabled(bool bNewEnabled);
    void SetInteriorSettings(const FInteriorSettings& NewInteriorSettings);
    void SetPriority(float NewPriority);
    void SetReverbSettings(const FReverbSettings& NewReverbSettings);
    void SetSubmixOverrideSettings(const TArray<FAudioVolumeSubmixOverrideSettings>& NewSubmixOverrideSettings);
    void SetSubmixSendSettings(const TArray<FAudioVolumeSubmixSendSettings>& NewSubmixSendSettings);
};

// Size: 0x20
struct FAudioVolumeSubmixOverrideSettings {
    /* 0x0000 */ USoundSubmix* Submix;
    /* 0x0008 */ TArray<USoundEffectSubmixPreset*> SubmixEffectChain;
    /* 0x0018 */ float CrossfadeTime;
};

// Size: 0x18
struct FAudioVolumeSubmixSendSettings {
    /* 0x0000 */ EAudioVolumeLocationState ListenerLocationState;
    /* 0x0001 */ EAudioVolumeLocationState SourceLocationState;
    /* 0x0008 */ TArray<FSoundSubmixSendInfo> SubmixSends;
};

// Size: 0x30
class UAudioWidgetSubsystem : public UEngineSubsystem {
};

// Size: 0x28
struct FAutoCompleteNode {
    /* 0x0000 */ int32_t IndexChar;
    /* 0x0008 */ TArray<int32_t> AutoCompleteListIndices;
};

// Size: 0x50
class UAutoDestroySubsystem : public UTickableWorldSubsystem {
    /* 0x0040 */ TArray<AActor*> ActorsToPoll;

    void OnActorEndPlay(AActor* Actor, uint8_t EndPlayReason);
};

// Size: 0x2e0
class AAutoRTFMTestActor : public AActor {
    /* 0x02ac */ int32_t MyProperty;
};

// Size: 0x2b0
class AAutoRTFMTestAnotherActor : public AActor {
};

// Size: 0x330
class UAutoRTFMTestBodySetup : public UBodySetup {
};

// Size: 0xe0
class UAutoRTFMTestCameraShake : public UCameraShakeBase {
};

// Size: 0x290
class UAutoRTFMTestChildActorComponent : public UChildActorComponent {
};

// Size: 0x3e0
class UAutoRTFMTestLevel : public ULevel {
};

// Size: 0x30
class UAutoRTFMTestObject : public UObject {

    void OnComponentPhysicsStateChanged(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
};

// Size: 0x560
class UAutoRTFMTestPrimitiveComponent : public UPrimitiveComponent {
};

// Size: 0x358
class UAutomationTestSettings : public UObject {
    /* 0x0028 */ TArray<FString> EngineTestModules;
    /* 0x0038 */ TArray<FString> EditorTestModules;
    /* 0x0048 */ FSoftObjectPath AutomationTestmap;
    /* 0x0068 */ TArray<FEditorMapPerformanceTestDefinition> EditorPerformanceTestMaps;
    /* 0x0078 */ TArray<FString> AssetsToOpen;
    /* 0x0088 */ TArray<FString> MapsToPIETest;
    /* 0x0098 */ bool bUseAllProjectMapsToPlayInPIE;
    /* 0x00a0 */ FBuildPromotionTestSettings BuildPromotionTest;
    /* 0x0290 */ FMaterialEditorPromotionSettings MaterialEditorPromotionTest;
    /* 0x02c0 */ FParticleEditorPromotionSettings ParticleEditorPromotionTest;
    /* 0x02d0 */ FBlueprintEditorPromotionSettings BlueprintEditorPromotionTest;
    /* 0x0300 */ TArray<FString> TestLevelFolders;
    /* 0x0310 */ TArray<FExternalToolDefinition> ExternalTools;
    /* 0x0320 */ TArray<FEditorImportExportTestDefinition> ImportExportTestDefinitions;
    /* 0x0330 */ TArray<FLaunchOnTestSettings> LaunchOnSettings;
    /* 0x0340 */ FIntPoint DefaultScreenshotResolution;
    /* 0x0348 */ float PIETestDuration;
    /* 0x034c */ float DefaultInteractiveFramerate;
    /* 0x0350 */ float DefaultInteractiveFramerateWaitTime;
    /* 0x0354 */ float DefaultInteractiveFramerateDuration;
};

// Size: 0xe0
class UAvoidanceManager : public UObject {
    /* 0x0030 */ float DefaultTimeToLive;
    /* 0x0034 */ float LockTimeAfterAvoid;
    /* 0x0038 */ float LockTimeAfterClean;
    /* 0x003c */ float DeltaTimeToPredict;
    /* 0x0040 */ float ArtificialRadiusExpansion;
    /* 0x0044 */ float TestHeightDifference;
    /* 0x0048 */ float HeightCheckMargin;

    FVector GetAvoidanceVelocityForComponent(UMovementComponent* MovementComp);
    int32_t GetNewAvoidanceUID();
    int32_t GetObjectCount();
    bool RegisterMovementComponent(UMovementComponent* MovementComp, float AvoidanceWeight);
};

// Size: 0x10
struct FBPComponentClassOverride {
    /* 0x0000 */ FName ComponentName;
    /* 0x0008 */ UClass* ComponentClass;
};

// Size: 0x30
struct FBPEditorBookmarkNode {
    /* 0x0000 */ FGuid NodeGuid;
    /* 0x0010 */ FGuid ParentGuid;
    /* 0x0020 */ FText DisplayName;
};

// Size: 0x18
struct FBPInterfaceDescription {
    /* 0x0000 */ UClass* Interface;
    /* 0x0008 */ TArray<UEdGraph*> Graphs;
};

// Size: 0xc8
struct FBPVariableDescription {
    /* 0x0000 */ FName VarName;
    /* 0x0008 */ FGuid VarGuid;
    /* 0x0018 */ FEdGraphPinType VarType;
    /* 0x0070 */ FString FriendlyName;
    /* 0x0080 */ FText Category;
    /* 0x0090 */ uint64_t PropertyFlags;
    /* 0x0098 */ FName RepNotifyFunc;
    /* 0x00a0 */ uint8_t ReplicationCondition;
    /* 0x00a8 */ TArray<FBPVariableMetaDataEntry> MetaDataArray;
    /* 0x00b8 */ FString DefaultValue;
};

// Size: 0x18
struct FBPVariableMetaDataEntry {
    /* 0x0000 */ FName DataKey;
    /* 0x0008 */ FString DataValue;
};

// Size: 0x58
struct FBakedAnimationState {
    /* 0x0000 */ FName StateName;
    /* 0x0008 */ TArray<FBakedStateExitTransition> Transitions;
    /* 0x0018 */ int32_t StateRootNodeIndex;
    /* 0x001c */ int32_t StartNotify;
    /* 0x0020 */ int32_t EndNotify;
    /* 0x0024 */ int32_t FullyBlendedNotify;
    /* 0x0028 */ bool bIsAConduit;
    /* 0x002c */ int32_t EntryRuleNodeIndex;
    /* 0x0030 */ TArray<int32_t> PlayerNodeIndices;
    /* 0x0040 */ TArray<int32_t> LayerNodeIndices;
    /* 0x0050 */ bool bAlwaysResetOnEntry;
};

// Size: 0x30
struct FBakedAnimationStateMachine {
    /* 0x0000 */ FName MachineName;
    /* 0x0008 */ int32_t InitialState;
    /* 0x0010 */ TArray<FBakedAnimationState> States;
    /* 0x0020 */ TArray<FAnimationTransitionBetweenStates> Transitions;
};

// Size: 0x1
struct FBakedCustomAttributePerBoneData {
};

// Size: 0x1
struct FBakedFloatCustomAttribute {
};

// Size: 0x1
struct FBakedIntegerCustomAttribute {
};

// Size: 0x30
struct FBakedStateExitTransition {
    /* 0x0000 */ int32_t CanTakeDelegateIndex;
    /* 0x0004 */ int32_t CustomResultNodeIndex;
    /* 0x0008 */ int32_t TransitionIndex;
    /* 0x000c */ bool bDesiredTransitionReturnValue;
    /* 0x000d */ bool bAutomaticRemainingTimeRule;
    /* 0x0010 */ float AutomaticRuleTriggerTime;
    /* 0x0014 */ FName SyncGroupNameToRequireValidMarkersRule;
    /* 0x0020 */ TArray<int32_t> PoseEvaluatorLinks;
};

// Size: 0x1
struct FBakedStringCustomAttribute {
};

// Size: 0x2c8
class ABandwidthTestActor : public AActor {
    /* 0x02a8 */ FBandwidthTestGenerator BandwidthGenerator;
};

// Size: 0x20
struct FBandwidthTestGenerator {
    /* 0x0000 */ TArray<FBandwidthTestItem> ReplicatedBuffers;
};

// Size: 0x10
struct FBandwidthTestItem {
    /* 0x0000 */ TArray<uint8_t> Kilobyte;
};

// Size: 0xc0
struct FBaseAttenuationSettings {
    /* 0x0008 */ EAttenuationDistanceModel DistanceAlgorithm;
    /* 0x0009 */ uint8_t AttenuationShape;
    /* 0x000a */ ENaturalSoundFalloffMode FalloffMode;
    /* 0x000c */ float dBAttenuationAtMax;
    /* 0x0010 */ FVector AttenuationShapeExtents;
    /* 0x0028 */ float ConeOffset;
    /* 0x002c */ float FalloffDistance;
    /* 0x0030 */ float ConeSphereRadius;
    /* 0x0034 */ float ConeSphereFalloffDistance;
    /* 0x0038 */ FRuntimeFloatCurve CustomAttenuationCurve;
};

// Size: 0x20
struct FBaseComponentReference {
    /* 0x0000 */ FName ComponentProperty;
    /* 0x0008 */ FString PathToComponent;
};

// Size: 0x48
struct FBasedMovementInfo {
    /* 0x0000 */ uint16_t BaseID;
    /* 0x0002 */ bool bServerHasBaseComponent;
    /* 0x0002 */ bool bRelativeRotation;
    /* 0x0002 */ bool bServerHasVelocity;
    /* 0x0004 */ FName BoneName;
    /* 0x0010 */ UPrimitiveComponent* MovementBase;
    /* 0x0018 */ FVector_NetQuantize100 Location;
    /* 0x0030 */ FRotator Rotation;
};

// Size: 0x68
struct FBasedPosition {
    /* 0x0000 */ AActor* base;
    /* 0x0008 */ FVector position;
    /* 0x0020 */ FVector CachedBaseLocation;
    /* 0x0038 */ FRotator CachedBaseRotation;
    /* 0x0050 */ FVector CachedTransPosition;
};

// Size: 0x50
struct FBatchedLine {
    /* 0x0000 */ FVector Start;
    /* 0x0018 */ FVector End;
    /* 0x0030 */ FLinearColor Color;
    /* 0x0040 */ float Thickness;
    /* 0x0044 */ float RemainingLifeTime;
    /* 0x0048 */ uint8_t DepthPriority;
    /* 0x004c */ uint32_t BatchID;
};

// Size: 0x38
struct FBatchedPoint {
    /* 0x0000 */ FVector position;
    /* 0x0018 */ FLinearColor Color;
    /* 0x0028 */ float PointSize;
    /* 0x002c */ float RemainingLifeTime;
    /* 0x0030 */ uint8_t DepthPriority;
    /* 0x0034 */ uint32_t BatchID;
};

enum class Beam2SourceTargetMethod {
    PEB2STM_Default = 0,
    PEB2STM_UserSet = 1,
    PEB2STM_Emitter = 2,
    PEB2STM_Particle = 3,
    PEB2STM_Actor = 4,
    PEB2STM_MAX = 5,
};

enum class Beam2SourceTargetTangentMethod {
    PEB2STTM_Direct = 0,
    PEB2STTM_UserSet = 1,
    PEB2STTM_Distribution = 2,
    PEB2STTM_Emitter = 3,
    PEB2STTM_MAX = 4,
};

// Size: 0x4
struct FBeamModifierOptions {
    /* 0x0000 */ bool bModify;
    /* 0x0000 */ bool bScale;
    /* 0x0000 */ bool bLock;
};

enum class BeamModifierType {
    PEB2MT_Source = 0,
    PEB2MT_Target = 1,
    PEB2MT_MAX = 2,
};

// Size: 0xc
struct FBeamTargetData {
    /* 0x0000 */ FName TargetName;
    /* 0x0008 */ float TargetPercentage;
};

// Size: 0x550
class UBillboardComponent : public UPrimitiveComponent {
    /* 0x0520 */ UTexture2D* Sprite;
    /* 0x0528 */ bool bIsScreenSizeScaled;
    /* 0x052c */ float ScreenSize;
    /* 0x0530 */ float U;
    /* 0x0534 */ float UL;
    /* 0x0538 */ float V;
    /* 0x053c */ float VL;
    /* 0x0540 */ float OpacityMaskRefVal;

    void SetOpacityMaskRefVal(float RefVal);
    void SetSprite(UTexture2D* NewSprite);
    void SetSpriteAndUV(UTexture2D* NewSprite, int32_t NewU, int32_t NewUL, int32_t NewV, int32_t NewVL);
    void SetUV(int32_t NewU, int32_t NewUL, int32_t NewV, int32_t NewVL);
};

// Size: 0x10
struct FBlendFilter {
};

// Size: 0x20
struct FBlendParameter {
    /* 0x0000 */ FString DisplayName;
    /* 0x0010 */ float min;
    /* 0x0014 */ float max;
    /* 0x0018 */ int32_t GridNum;
    /* 0x001c */ bool bSnapToGrid;
    /* 0x001d */ bool bWrapInput;
};

// Size: 0x50
class UBlendProfile : public UObject {
    /* 0x0030 */ USkeleton* OwningSkeleton;
    /* 0x0038 */ TArray<FBlendProfileBoneEntry> ProfileEntries;
    /* 0x0048 */ EBlendProfileMode Mode;
};

// Size: 0x14
struct FBlendProfileBoneEntry {
    /* 0x0000 */ FBoneReference BoneReference;
    /* 0x0010 */ float BlendScale;
};

// Size: 0x20
struct FBlendProfileInterfaceWrapper {
    /* 0x0000 */ bool bIsSkeletonBlendProfile;
    /* 0x0008 */ TScriptInterface<IBlendProfileProviderInterface> BlendProfileProvider;
    /* 0x0018 */ UBlendProfile* BlendProfile;
};

// Size: 0x28
class IBlendProfileProviderInterface : public UInterface {
};

// Size: 0x28
struct FBlendSample {
    /* 0x0000 */ UAnimSequence* Animation;
    /* 0x0008 */ FVector SampleValue;
    /* 0x0020 */ float RateScale;
};

// Size: 0x60
struct FBlendSampleData {
    /* 0x0000 */ int32_t SampleDataIndex;
    /* 0x0008 */ UAnimSequence* Animation;
    /* 0x0010 */ float TotalWeight;
    /* 0x0014 */ float WeightRate;
    /* 0x0018 */ float Time;
    /* 0x001c */ float PreviousTime;
    /* 0x0020 */ float SamplePlayRate;
};

// Size: 0x1c0
class UBlendSpace : public UAnimationAsset {
    /* 0x0088 */ bool bContainsRotationOffsetMeshSpaceSamples;
    /* 0x008c */ FInterpolationParameter InterpolationParam[3];
    /* 0x00bc */ float TargetWeightInterpolationSpeedPerSec;
    /* 0x00c0 */ bool bTargetWeightInterpolationEaseInOut;
    /* 0x00c1 */ bool bAllowMeshSpaceBlending;
    /* 0x00c2 */ bool bLoop;
    /* 0x00c3 */ bool bAllowMarkerBasedSync;
    /* 0x00c4 */ bool bShouldMatchSyncPhases;
    /* 0x00c8 */ float AnimLength;
    /* 0x00cc */ uint8_t NotifyTriggerMode;
    /* 0x00cd */ bool bInterpolateUsingGrid;
    /* 0x00ce */ EPreferredTriangulationDirection PreferredTriangulationDirection;
    /* 0x00cf */ EBlendSpacePerBoneBlendMode PerBoneBlendMode;
    /* 0x00d0 */ TArray<FPerBoneInterpolation> ManualPerBoneOverrides;
    /* 0x00e0 */ FBlendSpaceBlendProfile PerBoneBlendProfile;
    /* 0x0100 */ int32_t SampleIndexWithMarkers;
    /* 0x0108 */ TArray<FBlendSample> SampleData;
    /* 0x0118 */ TArray<FEditorElement> GridSamples;
    /* 0x0128 */ FBlendSpaceData BlendSpaceData;
    /* 0x0148 */ FBlendParameter BlendParameters[3];
    /* 0x01a8 */ uint8_t AxisToScaleAnimation;
    /* 0x01b0 */ TArray<int32_t> DimensionIndices;
};

// Size: 0x1c8
class UBlendSpace1D : public UBlendSpace {
    /* 0x01c0 */ bool bScaleAnimation;
};

// Size: 0x10
struct FBlendSpaceBlendProfile {
    /* 0x0000 */ UBlendProfile* BlendProfile;
    /* 0x0008 */ float TargetWeightInterpolationSpeedPerSec;
};

// Size: 0x20
struct FBlendSpaceData {
    /* 0x0000 */ TArray<FBlendSpaceSegment> Segments;
    /* 0x0010 */ TArray<FBlendSpaceTriangle> Triangles;
};

// Size: 0x10
struct FBlendSpaceSegment {
    /* 0x0000 */ int32_t SampleIndices[2];
    /* 0x0008 */ float Vertices[2];
};

// Size: 0xb8
struct FBlendSpaceTriangle {
    /* 0x0000 */ int32_t SampleIndices[3];
    /* 0x0010 */ FVector2D Vertices[3];
    /* 0x0040 */ FBlendSpaceTriangleEdgeInfo EdgeInfo[3];
};

// Size: 0x28
struct FBlendSpaceTriangleEdgeInfo {
    /* 0x0000 */ FVector2D Normal;
    /* 0x0010 */ int32_t NeighbourTriangleIndex;
    /* 0x0014 */ int32_t AdjacentPerimeterTriangleIndices[2];
    /* 0x001c */ int32_t AdjacentPerimeterVertexIndices[2];
};

// Size: 0x28
class IBlendableInterface : public UInterface {
};

// Size: 0x2e0
class ABlockingVolume : public AVolume {
};

// Size: 0xa8
class UBlueprint : public UBlueprintCore {
    /* 0x0058 */ UClass* ParentClass;
    /* 0x0060 */ uint8_t BlueprintType;
    /* 0x0061 */ bool bRecompileOnLoad;
    /* 0x0061 */ bool bHasBeenRegenerated;
    /* 0x0061 */ bool bIsRegeneratingOnLoad;
    /* 0x0064 */ int32_t BlueprintSystemVersion;
    /* 0x0068 */ USimpleConstructionScript* SimpleConstructionScript;
    /* 0x0070 */ TArray<UActorComponent*> ComponentTemplates;
    /* 0x0080 */ TArray<UTimelineTemplate*> Timelines;
    /* 0x0090 */ TArray<FBPComponentClassOverride> ComponentClassOverrides;
    /* 0x00a0 */ UInheritableComponentHandler* InheritableComponentHandler;
};

// Size: 0x30
class UBlueprintAsyncActionBase : public UObject {

    void Activate();
};

// Size: 0x18
struct FBlueprintComponentChangedPropertyInfo {
    /* 0x0000 */ FName PropertyName;
    /* 0x0008 */ int32_t ArrayIndex;
    /* 0x0010 */ UStruct* PropertyScope;
};

// Size: 0x18
struct FBlueprintComponentDelegateBinding {
    /* 0x0000 */ FName ComponentPropertyName;
    /* 0x0008 */ FName DelegatePropertyName;
    /* 0x0010 */ FName FunctionNameToBind;
};

// Size: 0x48
struct FBlueprintCookedComponentInstancingData {
    /* 0x0000 */ TArray<FBlueprintComponentChangedPropertyInfo> ChangedPropertyList;
    /* 0x0021 */ bool bHasValidCookedData;
};

// Size: 0x50
class UBlueprintCore : public UObject {
    /* 0x0028 */ UClass* SkeletonGeneratedClass;
    /* 0x0030 */ UClass* GeneratedClass;
    /* 0x0038 */ bool bLegacyNeedToPurgeSkelRefs;
    /* 0x003c */ FGuid BlueprintGuid;
};

// Size: 0x1
struct FBlueprintDebugData {
};

// Size: 0x30
struct FBlueprintEditorPromotionSettings {
    /* 0x0000 */ FFilePath FirstMeshPath;
    /* 0x0010 */ FFilePath SecondMeshPath;
    /* 0x0020 */ FFilePath DefaultParticleAsset;
};

// Size: 0x28
class UBlueprintExtension : public UObject {
};

// Size: 0x28
class UBlueprintFunctionLibrary : public UObject {
};

// Size: 0x360
class UBlueprintGeneratedClass : public UClass {
    /* 0x0208 */ int32_t NumReplicatedProperties;
    /* 0x020c */ bool bHasCookedComponentInstancingData;
    /* 0x020c */ bool bSupportsDynamicInstancedReference;
    /* 0x0210 */ TArray<UDynamicBlueprintBinding*> DynamicBindingObjects;
    /* 0x0220 */ TArray<UActorComponent*> ComponentTemplates;
    /* 0x0230 */ TArray<UTimelineTemplate*> Timelines;
    /* 0x0240 */ TArray<FBPComponentClassOverride> ComponentClassOverrides;
    /* 0x0250 */ TArray<FFieldNotificationId> FieldNotifies;
    /* 0x0268 */ USimpleConstructionScript* SimpleConstructionScript;
    /* 0x0270 */ UInheritableComponentHandler* InheritableComponentHandler;
    /* 0x0280 */ UFunction* UberGraphFunction;
    /* 0x0288 */ TMap<FName, FGuid> CookedPropertyGuids;
    /* 0x02d8 */ TMap<FName, FBlueprintCookedComponentInstancingData> CookedComponentInstancingData;
};

// Size: 0x18
struct FBlueprintInputActionDelegateBinding : public FBlueprintInputDelegateBinding {
    /* 0x0004 */ FName InputActionName;
    /* 0x000c */ uint8_t InputKeyEvent;
    /* 0x0010 */ FName FunctionNameToBind;
};

// Size: 0x14
struct FBlueprintInputAxisDelegateBinding : public FBlueprintInputDelegateBinding {
    /* 0x0004 */ FName InputAxisName;
    /* 0x000c */ FName FunctionNameToBind;
};

// Size: 0x28
struct FBlueprintInputAxisKeyDelegateBinding : public FBlueprintInputDelegateBinding {
    /* 0x0008 */ FKey AxisKey;
    /* 0x0020 */ FName FunctionNameToBind;
};

// Size: 0x4
struct FBlueprintInputDelegateBinding {
    /* 0x0000 */ bool bConsumeInput;
    /* 0x0000 */ bool bExecuteWhenPaused;
    /* 0x0000 */ bool bOverrideParentBinding;
};

// Size: 0x38
struct FBlueprintInputKeyDelegateBinding : public FBlueprintInputDelegateBinding {
    /* 0x0008 */ FInputChord InputChord;
    /* 0x0028 */ uint8_t InputKeyEvent;
    /* 0x002c */ FName FunctionNameToBind;
};

// Size: 0x10
struct FBlueprintInputTouchDelegateBinding : public FBlueprintInputDelegateBinding {
    /* 0x0004 */ uint8_t InputKeyEvent;
    /* 0x0008 */ FName FunctionNameToBind;
};

// Size: 0x28
class UBlueprintInstancedStructLibrary : public UBlueprintFunctionLibrary {

    static bool EqualEqual_InstancedStruct(const FInstancedStruct& A, const FInstancedStruct& B);
    static void GetInstancedStructValue(EStructUtilsResult& ExecResult, const FInstancedStruct& InstancedStruct, int32_t& Value);
    static EStructUtilsResult IsInstancedStructValid(const FInstancedStruct& InstancedStruct);
    static bool IsValid_InstancedStruct(const FInstancedStruct& InstancedStruct);
    static FInstancedStruct MakeInstancedStruct(const int32_t& Value);
    static bool NotEqual_InstancedStruct(const FInstancedStruct& A, const FInstancedStruct& B);
    static void Reset(FInstancedStruct& InstancedStruct, const UScriptStruct* StructType);
    static void SetInstancedStructValue(FInstancedStruct& InstancedStruct, const int32_t& Value);
};

// Size: 0x1
struct FBlueprintMacroCosmeticInfo {
};

// Size: 0x28
class UBlueprintMapLibrary : public UBlueprintFunctionLibrary {

    static void Map_Add(const TMap<int32_t, int32_t>& TargetMap, const int32_t& Key, const int32_t& Value);
    static void Map_Clear(const TMap<int32_t, int32_t>& TargetMap);
    static bool Map_Contains(const TMap<int32_t, int32_t>& TargetMap, const int32_t& Key);
    static bool Map_Find(const TMap<int32_t, int32_t>& TargetMap, const int32_t& Key, int32_t& Value);
    static void Map_GetKeyValueByIndex(const TMap<int32_t, int32_t>& TargetMap, int32_t Index, int32_t& Key, int32_t& Value);
    static int32_t Map_GetLastIndex(const TMap<int32_t, int32_t>& TargetMap);
    static bool Map_IsEmpty(const TMap<int32_t, int32_t>& TargetMap);
    static bool Map_IsNotEmpty(const TMap<int32_t, int32_t>& TargetMap);
    static void Map_Keys(const TMap<int32_t, int32_t>& TargetMap, TArray<int32_t>& Keys);
    static int32_t Map_Length(const TMap<int32_t, int32_t>& TargetMap);
    static bool Map_Remove(const TMap<int32_t, int32_t>& TargetMap, const int32_t& Key);
    static void Map_Values(const TMap<int32_t, int32_t>& TargetMap, TArray<int32_t>& Values);
    static void SetMapPropertyByName(UObject* Object, FName PropertyName, const TMap<int32_t, int32_t>& Value);
};

// Size: 0x28
class UBlueprintPathsLibrary : public UBlueprintFunctionLibrary {

    static FString AutomationDir();
    static FString AutomationLogDir();
    static FString AutomationTransientDir();
    static FString BugItDir();
    static FString ChangeExtension(FString InPath, FString InNewExtension);
    static FString CloudDir();
    static bool CollapseRelativeDirectories(FString InPath, FString& OutPath);
    static FString Combine(const TArray<FString>& InPaths);
    static FString ConvertFromSandboxPath(FString InPath, FString InSandboxName);
    static FString ConvertRelativePathToFull(FString InPath, FString InBasePath);
    static FString ConvertToSandboxPath(FString InPath, FString InSandboxName);
    static FString CreateTempFilename(FString Path, FString Prefix, FString Extension);
    static FString DiffDir();
    static bool DirectoryExists(FString InPath);
    static FString EngineConfigDir();
    static FString EngineContentDir();
    static FString EngineDir();
    static FString EngineIntermediateDir();
    static FString EnginePluginsDir();
    static FString EngineSavedDir();
    static FString EngineSourceDir();
    static FString EngineUserDir();
    static FString EngineVersionAgnosticUserDir();
    static FString EnterpriseDir();
    static FString EnterpriseFeaturePackDir();
    static FString EnterprisePluginsDir();
    static FString FeaturePackDir();
    static bool FileExists(FString InPath);
    static FString GameAgnosticSavedDir();
    static FString GameDevelopersDir();
    static FString GameSourceDir();
    static FString GameUserDeveloperDir();
    static FString GeneratedConfigDir();
    static FString GetBaseFilename(FString InPath, bool bRemovePath);
    static FString GetCleanFilename(FString InPath);
    static TArray<FString> GetEditorLocalizationPaths();
    static TArray<FString> GetEngineLocalizationPaths();
    static FString GetExtension(FString InPath, bool bIncludeDot);
    static TArray<FString> GetGameLocalizationPaths();
    static FString GetInvalidFileSystemChars();
    static FString GetPath(FString InPath);
    static FString GetProjectFilePath();
    static TArray<FString> GetPropertyNameLocalizationPaths();
    static FString GetRelativePathToRoot();
    static TArray<FString> GetRestrictedFolderNames();
    static TArray<FString> GetToolTipLocalizationPaths();
    static bool HasProjectPersistentDownloadDir();
    static bool IsDrive(FString InPath);
    static bool IsProjectFilePathSet();
    static bool IsRelative(FString InPath);
    static bool IsRestrictedPath(FString InPath);
    static bool IsSamePath(FString PathA, FString PathB);
    static FString LaunchDir();
    static bool MakePathRelativeTo(FString InPath, FString InRelativeTo, FString& OutPath);
    static void MakePlatformFilename(FString InPath, FString& OutPath);
    static void MakeStandardFilename(FString InPath, FString& OutPath);
    static FString MakeValidFileName(FString InString, FString InReplacementChar);
    static void NormalizeDirectoryName(FString InPath, FString& OutPath);
    static void NormalizeFilename(FString InPath, FString& OutPath);
    static FString ProfilingDir();
    static FString ProjectConfigDir();
    static FString ProjectContentDir();
    static FString ProjectDir();
    static FString ProjectIntermediateDir();
    static FString ProjectLogDir();
    static FString ProjectModsDir();
    static FString ProjectPersistentDownloadDir();
    static FString ProjectPluginsDir();
    static FString ProjectSavedDir();
    static FString ProjectUserDir();
    static void RemoveDuplicateSlashes(FString InPath, FString& OutPath);
    static FString RootDir();
    static FString SandboxesDir();
    static FString ScreenShotDir();
    static FString SetExtension(FString InPath, FString InNewExtension);
    static void SetProjectFilePath(FString NewGameProjectFilePath);
    static FString ShaderWorkingDir();
    static bool ShouldSaveToUserDir();
    static FString SourceConfigDir();
    static void Split(FString InPath, FString& PathPart, FString& FilenamePart, FString& ExtensionPart);
    static void ValidatePath(FString InPath, bool& bDidSucceed, FText& OutReason);
    static FString VideoCaptureDir();
};

// Size: 0x28
class UBlueprintPlatformLibrary : public UBlueprintFunctionLibrary {

    static void CancelLocalNotification(FString ActivationEvent);
    static void CancelLocalNotificationById(int32_t NotificationId);
    static void ClearAllLocalNotifications();
    static uint8_t GetAllowedDeviceOrientation();
    static uint8_t GetDeviceOrientation();
    static void GetLaunchNotification(bool& NotificationLaunchedApp, FString& ActivationEvent, int32_t& FireDate);
    static int32_t ScheduleLocalNotificationAtTime(const FDateTime& FireDateTime, bool LocalTime, const FText& Title, const FText& Body, const FText& action, FString ActivationEvent);
    static int32_t ScheduleLocalNotificationBadgeAtTime(const FDateTime& FireDateTime, bool LocalTime, FString ActivationEvent);
    static void ScheduleLocalNotificationBadgeFromNow(int32_t inSecondsFromNow, FString ActivationEvent);
    static int32_t ScheduleLocalNotificationFromNow(int32_t inSecondsFromNow, const FText& Title, const FText& Body, const FText& action, FString ActivationEvent);
    static void SetAllowedDeviceOrientation(uint8_t NewAllowedDeviceOrientation);
};

// Size: 0x28
class UBlueprintSetLibrary : public UBlueprintFunctionLibrary {

    static void SetSetPropertyByName(UObject* Object, FName PropertyName, const TSet<int32_t>& Value);
    static void Set_Add(const TSet<int32_t>& TargetSet, const int32_t& NewItem);
    static void Set_AddItems(const TSet<int32_t>& TargetSet, const TArray<int32_t>& NewItems);
    static void Set_Clear(const TSet<int32_t>& TargetSet);
    static bool Set_Contains(const TSet<int32_t>& TargetSet, const int32_t& ItemToFind);
    static void Set_Difference(const TSet<int32_t>& A, const TSet<int32_t>& B, TSet<int32_t>& Result);
    static void Set_GetItemByIndex(const TSet<int32_t>& TargetSet, int32_t Index, int32_t& Item);
    static int32_t Set_GetLastIndex(const TSet<int32_t>& TargetSet);
    static void Set_Intersection(const TSet<int32_t>& A, const TSet<int32_t>& B, TSet<int32_t>& Result);
    static bool Set_IsEmpty(const TSet<int32_t>& TargetSet);
    static bool Set_IsNotEmpty(const TSet<int32_t>& TargetSet);
    static int32_t Set_Length(const TSet<int32_t>& TargetSet);
    static bool Set_Remove(const TSet<int32_t>& TargetSet, const int32_t& Item);
    static void Set_RemoveItems(const TSet<int32_t>& TargetSet, const TArray<int32_t>& Items);
    static void Set_ToArray(const TSet<int32_t>& A, TArray<int32_t>& Result);
    static void Set_Union(const TSet<int32_t>& A, const TSet<int32_t>& B, TSet<int32_t>& Result);
};

// Size: 0x28
class UBlueprintTypeConversions : public UObject {

    static TArray<int32_t> ConvertArrayType(const TArray<int32_t>& inArray);
    static int32_t ConvertFBox2dToFBox2f(int32_t InFromData);
    static int32_t ConvertFBox2fToFBox2d(int32_t InFromData);
    static int32_t ConvertFMatrix44dToFMatrix44f(int32_t InFromData);
    static int32_t ConvertFMatrix44fToFMatrix44d(int32_t InFromData);
    static int32_t ConvertFPlane4dToFPlane4f(int32_t InFromData);
    static int32_t ConvertFPlane4fToFPlane4d(int32_t InFromData);
    static int32_t ConvertFQuat4dToFQuat4f(int32_t InFromData);
    static int32_t ConvertFQuat4fToFQuat4d(int32_t InFromData);
    static int32_t ConvertFRotator3dToFRotator3f(int32_t InFromData);
    static int32_t ConvertFRotator3fToFRotator3d(int32_t InFromData);
    static int32_t ConvertFTransform3dToFTransform3f(int32_t InFromData);
    static int32_t ConvertFTransform3fToFTransform3d(int32_t InFromData);
    static int32_t ConvertFVector2dToFVector2f(int32_t InFromData);
    static int32_t ConvertFVector2fToFVector2d(int32_t InFromData);
    static int32_t ConvertFVector3dToFVector3f(int32_t InFromData);
    static int32_t ConvertFVector3fToFVector3d(int32_t InFromData);
    static int32_t ConvertFVector4dToFVector4f(int32_t InFromData);
    static int32_t ConvertFVector4fToFVector4d(int32_t InFromData);
    static TMap<int32_t, int32_t> ConvertMapType(const TMap<int32_t, int32_t>& InMap);
    static TSet<int32_t> ConvertSetType(const TSet<int32_t>& InSet);
};

// Size: 0x180
struct FBodyInstance : public FBodyInstanceCore {
    /* 0x0012 */ uint8_t PositionSolverIterationCount;
    /* 0x0013 */ uint8_t VelocitySolverIterationCount;
    /* 0x0014 */ uint8_t ProjectionSolverIterationCount;
    /* 0x0015 */ uint8_t ObjectType;
    /* 0x0017 */ uint8_t CollisionEnabled;
    /* 0x0039 */ ESleepFamily SleepFamily;
    /* 0x003a */ uint8_t DOFMode;
    /* 0x003b */ bool bUseCCD;
    /* 0x003b */ bool bUseMACD;
    /* 0x003b */ bool bIgnoreAnalyticCollisions;
    /* 0x003b */ bool bNotifyRigidBodyCollision;
    /* 0x003b */ bool bSmoothEdgeCollisions;
    /* 0x003c */ bool bLockTranslation;
    /* 0x003c */ bool bLockRotation;
    /* 0x003c */ bool bLockXTranslation;
    /* 0x003c */ bool bLockYTranslation;
    /* 0x003c */ bool bLockZTranslation;
    /* 0x003c */ bool bLockXRotation;
    /* 0x003c */ bool bLockYRotation;
    /* 0x003c */ bool bLockZRotation;
    /* 0x003d */ bool bOverrideMaxAngularVelocity;
    /* 0x003d */ bool bOverrideMaxDepenetrationVelocity;
    /* 0x003d */ bool bOverrideWalkableSlopeOnInstance;
    /* 0x003d */ bool bInterpolateWhenSubStepping;
    /* 0x003d */ bool bInertiaConditioning;
    /* 0x003e */ bool bOneWayInteraction;
    /* 0x003e */ bool bOverrideSolverAsyncDeltaTime;
    /* 0x0040 */ float SolverAsyncDeltaTime;
    /* 0x0044 */ FName CollisionProfileName;
    /* 0x0068 */ FCollisionResponse CollisionResponses;
    /* 0x0098 */ float MaxDepenetrationVelocity;
    /* 0x009c */ float MassInKgOverride;
    /* 0x00a8 */ float LinearDamping;
    /* 0x00ac */ float AngularDamping;
    /* 0x00b0 */ FVector CustomDOFPlaneNormal;
    /* 0x00c8 */ FVector COMNudge;
    /* 0x00e0 */ float MassScale;
    /* 0x00e4 */ uint8_t GravityGroupIndex;
    /* 0x00e8 */ FVector InertiaTensorScale;
    /* 0x0110 */ FWalkableSlopeOverride WalkableSlopeOverride;
    /* 0x0120 */ UPhysicalMaterial* PhysMaterialOverride;
    /* 0x0128 */ float MaxAngularVelocity;
    /* 0x012c */ float CustomSleepThresholdMultiplier;
    /* 0x0130 */ float StabilizationThresholdMultiplier;
    /* 0x0134 */ float PhysicsBlendWeight;
};

// Size: 0x8
struct FBodyInstanceAsyncPhysicsTickHandle {
};

// Size: 0x328
class UBodySetup : public UBodySetupCore {
    /* 0x0038 */ FKAggregateGeom AggGeom;
    /* 0x00d8 */ bool bAlwaysFullAnimWeight;
    /* 0x00d8 */ bool bConsiderForBounds;
    /* 0x00d8 */ bool bMeshCollideAll;
    /* 0x00d8 */ bool bDoubleSidedGeometry;
    /* 0x00d8 */ bool bGenerateNonMirroredCollision;
    /* 0x00d8 */ bool bSharedCookedData;
    /* 0x00d8 */ bool bGenerateMirroredCollision;
    /* 0x00d8 */ bool bSupportUVsAndFaceRemap;
    /* 0x00d9 */ bool bNeverNeedsCookedCollisionData;
    /* 0x00e0 */ UPhysicalMaterial* PhysMaterial;
    /* 0x00e8 */ FWalkableSlopeOverride WalkableSlopeOverride;
    /* 0x0168 */ FBodyInstance DefaultInstance;
    /* 0x02f0 */ FVector BuildScale3D;
};

// Size: 0x40
struct FBoneAnimationTrack {
    /* 0x0000 */ FRawAnimSequenceTrack InternalTrackData;
    /* 0x0030 */ int32_t BoneTreeIndex;
    /* 0x0034 */ FName Name;
};

// Size: 0xc
struct FBoneFilter {
    /* 0x0000 */ bool bExcludeSelf;
    /* 0x0004 */ FName BoneName;
};

// Size: 0x38
class UBoneMaskFilter : public UObject {
    /* 0x0028 */ TArray<FInputBlendPose> BlendPoses;
};

// Size: 0x14
struct FBoneMirrorExport {
    /* 0x0000 */ FName BoneName;
    /* 0x0008 */ FName SourceBoneName;
    /* 0x0010 */ uint8_t BoneFlipAxis;
};

// Size: 0x8
struct FBoneMirrorInfo {
    /* 0x0000 */ int32_t SourceIndex;
    /* 0x0004 */ uint8_t BoneFlipAxis;
};

// Size: 0x1
struct FBoneNode {
    /* 0x0000 */ uint8_t TranslationRetargetingMode;
};

// Size: 0x10
struct FBoneReductionSetting {
    /* 0x0000 */ TArray<FName> BonesToRemove;
};

// Size: 0x10
struct FBoneReference {
    /* 0x0000 */ FName BoneName;
};

// Size: 0x28
class IBoneReferenceSkeletonProvider : public UInterface {
};

// Size: 0x90
struct FBoneSocketTarget {
    /* 0x0000 */ bool bUseSocket;
    /* 0x0004 */ FBoneReference BoneReference;
    /* 0x0020 */ FSocketReference SocketReference;
};

// Size: 0x68
class UBookMark : public UBookmarkBase {
    /* 0x0028 */ FVector Location;
    /* 0x0040 */ FRotator Rotation;
    /* 0x0058 */ TArray<FString> HiddenLevels;
};

// Size: 0x38
class UBookMark2D : public UBookmarkBase {
    /* 0x0028 */ float Zoom2D;
    /* 0x002c */ FIntPoint Location;
};

// Size: 0x1
struct FBookmark2DJumpToSettings {
};

// Size: 0x28
class UBookmarkBase : public UObject {
};

// Size: 0x1
struct FBookmarkBaseJumpToSettings {
};

// Size: 0x1
struct FBookmarkJumpToSettings : public FBookmarkBaseJumpToSettings {
};

// Size: 0x40
struct FBoundsCacheElement {
    /* 0x0000 */ bool bIsValid;
    /* 0x0004 */ uint32_t Hash;
    /* 0x0008 */ FBoxSphereBounds Value;
};

// Size: 0x160
class UBoundsCopyComponent : public UActorComponent {
    /* 0x00b8 */ TSoftObjectPtr<AActor> BoundsSourceActor;
    /* 0x00e0 */ bool bUseCollidingComponentsForSourceBounds;
    /* 0x00e1 */ bool bKeepOwnBoundsScale;
    /* 0x00e2 */ bool bUseCollidingComponentsForOwnBounds;
    /* 0x00f0 */ FTransform PostTransform;
    /* 0x0150 */ bool bCopyXBounds;
    /* 0x0151 */ bool bCopyYBounds;
    /* 0x0152 */ bool bCopyZBounds;
};

// Size: 0x560
class UBoxComponent : public UShapeComponent {
    /* 0x0540 */ FVector BoxExtent;

    FVector GetScaledBoxExtent() const;
    FVector GetUnscaledBoxExtent() const;
    void SetBoxExtent(FVector InBoxExtent, bool bUpdateOverlaps);
};

// Size: 0x2b0
class ABoxReflectionCapture : public AReflectionCapture {
};

// Size: 0x2c0
class UBoxReflectionCaptureComponent : public UReflectionCaptureComponent {
    /* 0x02a8 */ float BoxTransitionDistance;
    /* 0x02b0 */ UBoxComponent* PreviewInfluenceBox;
    /* 0x02b8 */ UBoxComponent* PreviewCaptureBox;
};

// Size: 0x10
struct FBracketPayload : public FEmptyPayload {
    /* 0x0000 */ FString Description;
};

// Size: 0xc
struct FBranchFilter {
    /* 0x0000 */ FName BoneName;
    /* 0x0008 */ int32_t BlendDepth;
};

// Size: 0x40
struct FBranchingPoint : public FAnimLinkableElement {
    /* 0x0030 */ FName EventName;
    /* 0x0038 */ float TriggerTimeOffset;
};

// Size: 0xc
struct FBranchingPointMarker {
    /* 0x0000 */ int32_t NotifyIndex;
    /* 0x0004 */ float TriggerTime;
    /* 0x0008 */ uint8_t NotifyEventType;
};

// Size: 0x20
struct FBranchingPointNotifyPayload {
};

// Size: 0x28
class UBreakpoint : public UObject {
};

// Size: 0x80
struct FBroadphaseSettings {
    /* 0x0000 */ bool bUseMBPOnClient;
    /* 0x0001 */ bool bUseMBPOnServer;
    /* 0x0002 */ bool bUseMBPOuterBounds;
    /* 0x0008 */ FBox MBPBounds;
    /* 0x0040 */ FBox MBPOuterBounds;
    /* 0x0078 */ uint32_t MBPNumSubdivs;
};

// Size: 0x2e0
class ABrush : public AActor {
    /* 0x02a8 */ uint8_t BrushType;
    /* 0x02ac */ FColor BrushColor;
    /* 0x02b0 */ int32_t PolyFlags;
    /* 0x02b4 */ bool bColored;
    /* 0x02b4 */ bool bSolidWhenSelected;
    /* 0x02b4 */ bool bPlaceableFromClassBrowser;
    /* 0x02b4 */ bool bNotForClientOrServer;
    /* 0x02b8 */ UModel* Brush;
    /* 0x02c0 */ UBrushComponent* BrushComponent;
    /* 0x02c8 */ bool bInManipulation;
    /* 0x02d0 */ TArray<FGeomSelection> SavedSelections;
};

// Size: 0x80
class UBrushBuilder : public UObject {
    /* 0x0028 */ FString BitmapFilename;
    /* 0x0038 */ FString Tooltip;
    /* 0x0048 */ bool NotifyBadParams;
    /* 0x0050 */ TArray<FVector> Vertices;
    /* 0x0060 */ TArray<FBuilderPoly> Polys;
    /* 0x0070 */ FName Layer;
    /* 0x0078 */ bool MergeCoplanars;
};

// Size: 0x530
class UBrushComponent : public UPrimitiveComponent {
    /* 0x0520 */ UModel* Brush;
    /* 0x0528 */ UBodySetup* BrushBodySetup;
};

// Size: 0x2e0
class ABrushShape : public ABrush {
};

// Size: 0x150
struct FBuildPromotionImportWorkflowSettings {
    /* 0x0000 */ FEditorImportWorkflowDefinition Diffuse;
    /* 0x0020 */ FEditorImportWorkflowDefinition Normal;
    /* 0x0040 */ FEditorImportWorkflowDefinition StaticMesh;
    /* 0x0060 */ FEditorImportWorkflowDefinition ReimportStaticMesh;
    /* 0x0080 */ FEditorImportWorkflowDefinition BlendShapeMesh;
    /* 0x00a0 */ FEditorImportWorkflowDefinition MorphMesh;
    /* 0x00c0 */ FEditorImportWorkflowDefinition SkeletalMesh;
    /* 0x00e0 */ FEditorImportWorkflowDefinition Animation;
    /* 0x0100 */ FEditorImportWorkflowDefinition Sound;
    /* 0x0120 */ FEditorImportWorkflowDefinition SurroundSound;
    /* 0x0140 */ TArray<FEditorImportWorkflowDefinition> OtherAssetsToImport;
};

// Size: 0x20
struct FBuildPromotionNewProjectSettings {
    /* 0x0000 */ FDirectoryPath NewProjectFolderOverride;
    /* 0x0010 */ FString NewProjectNameOverride;
};

// Size: 0x60
struct FBuildPromotionOpenAssetSettings {
    /* 0x0000 */ FFilePath BlueprintAsset;
    /* 0x0010 */ FFilePath MaterialAsset;
    /* 0x0020 */ FFilePath ParticleSystemAsset;
    /* 0x0030 */ FFilePath SkeletalMeshAsset;
    /* 0x0040 */ FFilePath StaticMeshAsset;
    /* 0x0050 */ FFilePath TextureAsset;
};

// Size: 0x1f0
struct FBuildPromotionTestSettings {
    /* 0x0000 */ FFilePath DefaultStaticMeshAsset;
    /* 0x0010 */ FBuildPromotionImportWorkflowSettings ImportWorkflow;
    /* 0x0160 */ FBuildPromotionOpenAssetSettings OpenAssets;
    /* 0x01c0 */ FBuildPromotionNewProjectSettings NewProjectSettings;
    /* 0x01e0 */ FFilePath SourceControlMaterial;
};

// Size: 0x20
struct FBuilderPoly {
    /* 0x0000 */ TArray<int32_t> VertexIndices;
    /* 0x0010 */ int32_t Direction;
    /* 0x0014 */ FName ItemName;
    /* 0x001c */ int32_t PolyFlags;
};

// Size: 0x28
class UBuiltInAttributesExtensions : public UBlueprintFunctionLibrary {
};

// Size: 0x3c0
class UButtonStyleAsset : public UObject {
    /* 0x0030 */ FButtonStyle ButtonStyle;
};

// Size: 0x18
struct FCachedAnimAssetPlayerData {
    /* 0x0000 */ FName StateMachineName;
    /* 0x0008 */ FName StateName;
};

// Size: 0x28
class UCachedAnimDataLibrary : public UBlueprintFunctionLibrary {

    static float StateMachine_GetAssetPlayerTime(UAnimInstance* InAnimInstance, const FCachedAnimAssetPlayerData& CachedAnimAssetPlayerData);
    static float StateMachine_GetAssetPlayerTimeRatio(UAnimInstance* InAnimInstance, const FCachedAnimAssetPlayerData& CachedAnimAssetPlayerData);
    static float StateMachine_GetCrossfadeDuration(UAnimInstance* InAnimInstance, const FCachedAnimTransitionData& CachedAnimTransitionData);
    static float StateMachine_GetGlobalWeight(UAnimInstance* InAnimInstance, const FCachedAnimStateData& CachedAnimStateData);
    static float StateMachine_GetLocalWeight(UAnimInstance* InAnimInstance, const FCachedAnimStateData& CachedAnimStateData);
    static float StateMachine_GetRelevantAnimTime(UAnimInstance* InAnimInstance, const FCachedAnimRelevancyData& CachedAnimRelevancyData);
    static float StateMachine_GetRelevantAnimTimeRemaining(UAnimInstance* InAnimInstance, const FCachedAnimRelevancyData& CachedAnimRelevancyData);
    static float StateMachine_GetRelevantAnimTimeRemainingFraction(UAnimInstance* InAnimInstance, const FCachedAnimRelevancyData& CachedAnimRelevancyData);
    static float StateMachine_GetTotalWeight(UAnimInstance* InAnimInstance, const FCachedAnimStateArray& CachedAnimStateArray);
    static bool StateMachine_IsFullWeight(UAnimInstance* InAnimInstance, const FCachedAnimStateArray& CachedAnimStateArray);
    static bool StateMachine_IsRelevant(UAnimInstance* InAnimInstance, const FCachedAnimStateArray& CachedAnimStateArray);
    static bool StateMachine_IsStateRelevant(UAnimInstance* InAnimInstance, const FCachedAnimStateData& CachedAnimStateData);
};

// Size: 0x1c
struct FCachedAnimRelevancyData {
    /* 0x0000 */ FName StateMachineName;
    /* 0x0008 */ FName StateName;
};

// Size: 0x18
struct FCachedAnimStateArray {
    /* 0x0000 */ TArray<FCachedAnimStateData> States;
};

// Size: 0x1c
struct FCachedAnimStateData {
    /* 0x0000 */ FName StateMachineName;
    /* 0x0008 */ FName StateName;
};

// Size: 0x24
struct FCachedAnimTransitionData {
    /* 0x0000 */ FName StateMachineName;
    /* 0x0008 */ FName FromStateName;
    /* 0x0010 */ FName ToStateName;
};

// Size: 0x8
struct FCachedFloatCurve {
    /* 0x0000 */ FName CurveName;
};

// Size: 0x70
struct FCachedKeyToActionInfo {
    /* 0x0000 */ TWeakObjectPtr<UPlayerInput> PlayerInput;
};

// Size: 0x10
struct FCachedPoseIndices {
    /* 0x0000 */ TArray<int32_t> OrderedSavedPoseNodeIndices;
};

// Size: 0xa30
class ACameraActor : public AActor {
    /* 0x02a8 */ uint8_t AutoActivateForPlayer;
    /* 0x02b0 */ UCameraComponent* CameraComponent;
    /* 0x02b8 */ USceneComponent* SceneComponent;
    /* 0x02c0 */ bool bConstrainAspectRatio;
    /* 0x02c4 */ float AspectRatio;
    /* 0x02c8 */ float FOVAngle;
    /* 0x02cc */ float PostProcessBlendWeight;
    /* 0x02d0 */ FPostProcessSettings PostProcessSettings;

    int32_t GetAutoActivatePlayerIndex() const;
};

// Size: 0x2e0
class ACameraBlockingVolume : public AVolume {
};

// Size: 0x8d0
struct FCameraCacheEntry {
    /* 0x0000 */ float Timestamp;
    /* 0x0010 */ FMinimalViewInfo POV;
};

// Size: 0xa80
class UCameraComponent : public USceneComponent {
    /* 0x0240 */ float FieldOfView;
    /* 0x0244 */ float FirstPersonFieldOfView;
    /* 0x0248 */ float FirstPersonScale;
    /* 0x024c */ float OrthoWidth;
    /* 0x0250 */ bool bAutoCalculateOrthoPlanes;
    /* 0x0254 */ float AutoPlaneShift;
    /* 0x0258 */ float OrthoNearClipPlane;
    /* 0x025c */ float OrthoFarClipPlane;
    /* 0x0260 */ bool bUpdateOrthoPlanes;
    /* 0x0261 */ bool bUseCameraHeightAsViewTarget;
    /* 0x0264 */ float AspectRatio;
    /* 0x0268 */ uint8_t AspectRatioAxisConstraint;
    /* 0x0269 */ bool bConstrainAspectRatio;
    /* 0x0269 */ bool bOverrideAspectRatioAxisConstraint;
    /* 0x0269 */ bool bUseFieldOfViewForLOD;
    /* 0x026c */ float Overscan;
    /* 0x0270 */ FVector4f AsymmetricOverscan;
    /* 0x0280 */ bool bScaleResolutionWithOverscan;
    /* 0x0281 */ bool bCropOverscan;
    /* 0x0282 */ bool bLockToHmd;
    /* 0x0282 */ bool bUsePawnControlRotation;
    /* 0x0282 */ bool bEnableFirstPersonFieldOfView;
    /* 0x0282 */ bool bEnableFirstPersonScale;
    /* 0x0283 */ uint8_t ProjectionMode;
    /* 0x02f0 */ float PostProcessBlendWeight;
    /* 0x0320 */ FPostProcessSettings PostProcessSettings;

    void AddOrUpdateBlendable(TScriptInterface<IBlendableInterface> InBlendableObject, float InWeight);
    void GetCameraView(float deltaTime, FMinimalViewInfo& DesiredView);
    void OnCameraMeshHiddenChanged();
    void RemoveBlendable(TScriptInterface<IBlendableInterface> InBlendableObject);
    void SetAspectRatio(float InAspectRatio);
    void SetAspectRatioAxisConstraint(uint8_t InAspectRatioAxisConstraint);
    void SetAsymmetricOverscan(const FVector4f& InAsymmetricOverscan);
    void SetAutoCalculateOrthoPlanes(bool bAutoCalculate);
    void SetAutoPlaneShift(float InAutoPlaneShift);
    void SetConstraintAspectRatio(bool bInConstrainAspectRatio);
    void SetCropOverscan(bool bInCropOverscan);
    void SetEnableFirstPersonFieldOfView(bool bInEnableFirstPersonFieldOfView);
    void SetEnableFirstPersonScale(bool bInEnableFirstPersonScale);
    void SetFieldOfView(float InFieldOfView);
    void SetFirstPersonFieldOfView(float InFirstPersonFieldOfView);
    void SetFirstPersonScale(float InFirstPersonScale);
    void SetOrthoFarClipPlane(float InOrthoFarClipPlane);
    void SetOrthoNearClipPlane(float InOrthoNearClipPlane);
    void SetOrthoWidth(float InOrthoWidth);
    void SetOverscan(float InOverscan);
    void SetPostProcessBlendWeight(float InPostProcessBlendWeight);
    void SetProjectionMode(uint8_t InProjectionMode);
    void SetScaleResolutionWithOverscan(bool bInScaleResolutionWithOverscan);
    void SetUpdateOrthoPlanes(bool bInUpdateOrthoPlanes);
    void SetUseCameraHeightAsViewTarget(bool bInUseCameraHeightAsViewTarget);
    void SetUseFieldOfViewForLOD(bool bInUseFieldOfViewForLOD);
};

// Size: 0x40
struct FCameraExposureSettings {
    /* 0x0000 */ uint8_t Method;
    /* 0x0004 */ float LowPercent;
    /* 0x0008 */ float HighPercent;
    /* 0x000c */ float MinBrightness;
    /* 0x0010 */ float MaxBrightness;
    /* 0x0014 */ float SpeedUp;
    /* 0x0018 */ float SpeedDown;
    /* 0x001c */ float Bias;
    /* 0x0020 */ UCurveFloat* BiasCurve;
    /* 0x0028 */ UTexture* MeterMask;
    /* 0x0030 */ float HistogramLogMin;
    /* 0x0034 */ float HistogramLogMax;
    /* 0x0038 */ float CalibrationConstant;
    /* 0x003c */ bool ApplyPhysicalCameraExposure;
};

// Size: 0x28
class ICameraLensEffectInterface : public UInterface {

    TArray<UFXSystemComponent*> GetParticleComponents() const;
    UFXSystemComponent* GetPrimaryParticleComponent() const;
};

// Size: 0x28
class UCameraLensEffectInterfaceClassSupportLibrary : public UBlueprintFunctionLibrary {

    static UClass* GetInterfaceClass(const FCameraLensInterfaceClassSupport& CameraLens);
    static void IsInterfaceClassValid(const FCameraLensInterfaceClassSupport& CameraLens, EInterfaceValidResult& Result);
    static void IsInterfaceValid(const TScriptInterface<ICameraLensEffectInterface>& CameraLens, EInterfaceValidResult& Result);
    static void SetInterfaceClass(UClass* Class, FCameraLensInterfaceClassSupport& Var, EInterfaceValidResult& Result);
};

// Size: 0x8
struct FCameraLensInterfaceClassSupport {
    /* 0x0000 */ UClass* Class;
};

// Size: 0x48
class UCameraModifier : public UObject {
    /* 0x0028 */ bool bDebug;
    /* 0x0028 */ bool bExclusive;
    /* 0x002c */ uint8_t Priority;
    /* 0x0030 */ APlayerCameraManager* CameraOwner;
    /* 0x0038 */ float AlphaInTime;
    /* 0x003c */ float AlphaOutTime;
    /* 0x0040 */ float Alpha;

    void BlueprintModifyCamera(float deltaTime, FVector ViewLocation, FRotator ViewRotation, float FOV, FVector& NewViewLocation, FRotator& NewViewRotation, float& NewFOV);
    void BlueprintModifyPostProcess(float deltaTime, float& PostProcessBlendWeight, FPostProcessSettings& PostProcessSettings);
    void DisableModifier(bool bImmediate);
    void EnableModifier();
    AActor* GetViewTarget() const;
    bool IsDisabled() const;
    bool IsPendingDisable() const;
    void OnCameraOwnerDestroyed(AActor* InOwner);
};

// Size: 0xb0
class UCameraModifier_CameraShake : public UCameraModifier {
    /* 0x0048 */ TArray<FActiveCameraShakeInfo> ActiveShakes;
    /* 0x0058 */ TMap<UClass*, FPooledCameraShakes> ExpiredPooledShakesMap;
    /* 0x00a8 */ float SplitScreenShakeScale;
};

// Size: 0x610
class UCameraProxyMeshComponent : public UStaticMeshComponent {
};

// Size: 0xe0
class UCameraShakeBase : public UObject {
    /* 0x0028 */ bool bSingleInstance;
    /* 0x002c */ float ShakeScale;
    /* 0x0030 */ UCameraShakePattern* RootShakePattern;
    /* 0x0038 */ APlayerCameraManager* CameraManager;

    UCameraShakePattern* GetRootShakePattern() const;
    void SetRootShakePattern(UCameraShakePattern* InPattern);
};

// Size: 0x8
struct FCameraShakeDuration {
    /* 0x0000 */ float Duration;
    /* 0x0004 */ ECameraShakeDurationType Type;
};

// Size: 0x10
struct FCameraShakeInfo {
    /* 0x0000 */ FCameraShakeDuration Duration;
    /* 0x0008 */ float BlendIn;
    /* 0x000c */ float BlendOut;
};

// Size: 0x28
class UCameraShakePattern : public UObject {
};

// Size: 0x8d0
struct FCameraShakePatternScrubParams {
    /* 0x0000 */ float AbsoluteTime;
    /* 0x0004 */ float ShakeScale;
    /* 0x0008 */ float DynamicScale;
    /* 0x0010 */ FMinimalViewInfo POV;
};

// Size: 0x8
struct FCameraShakePatternStartParams {
    /* 0x0000 */ bool bIsRestarting;
    /* 0x0001 */ bool bOverrideDuration;
    /* 0x0004 */ float DurationOverride;
};

// Size: 0x1
struct FCameraShakePatternStopParams {
    /* 0x0000 */ bool bImmediately;
};

// Size: 0x8d0
struct FCameraShakePatternUpdateParams {
    /* 0x0000 */ float deltaTime;
    /* 0x0004 */ float ShakeScale;
    /* 0x0008 */ float DynamicScale;
    /* 0x0010 */ FMinimalViewInfo POV;
};

// Size: 0x7b0
struct FCameraShakePatternUpdateResult {
};

// Size: 0x2b0
class ACameraShakeSourceActor : public AActor {
    /* 0x02a8 */ UCameraShakeSourceComponent* CameraShakeSourceComponent;
};

// Size: 0x260
class UCameraShakeSourceComponent : public USceneComponent {
    /* 0x0240 */ ECameraShakeAttenuation Attenuation;
    /* 0x0244 */ float InnerAttenuationRadius;
    /* 0x0248 */ float OuterAttenuationRadius;
    /* 0x0250 */ UClass* CameraShake;
    /* 0x0258 */ bool bAutoStart;

    float GetAttenuationFactor(const FVector& Location) const;
    void Start();
    void StartCameraShake(UClass* InCameraShake, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
    void StopAllCameraShakes(bool bImmediately);
    void StopAllCameraShakesOfType(UClass* InCameraShake, bool bImmediately);
};

// Size: 0x30
class UCancellableAsyncAction : public UBlueprintAsyncActionBase {

    void Cancel();
    bool IsActive() const;
};

// Size: 0x390
class UCanvas : public UObject {
    /* 0x0028 */ float OrgX;
    /* 0x002c */ float OrgY;
    /* 0x0030 */ float ClipX;
    /* 0x0034 */ float ClipY;
    /* 0x0038 */ FColor DrawColor;
    /* 0x003c */ bool bCenterX;
    /* 0x003c */ bool bCenterY;
    /* 0x003c */ bool bNoSmooth;
    /* 0x0040 */ int32_t SizeX;
    /* 0x0044 */ int32_t SizeY;
    /* 0x0050 */ FPlane ColorModulate;
    /* 0x0070 */ UTexture2D* DefaultTexture;
    /* 0x0078 */ UTexture2D* GradientTexture0;
    /* 0x0080 */ UReporterGraph* ReporterGraph;

    void K2_Deproject(FVector2D screenPosition, FVector& WorldOrigin, FVector& WorldDirection);
    void K2_DrawBorder(UTexture* BorderTexture, UTexture* BackgroundTexture, UTexture* LeftBorderTexture, UTexture* RightBorderTexture, UTexture* TopBorderTexture, UTexture* BottomBorderTexture, FVector2D screenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize, FLinearColor RenderColor, FVector2D BorderScale, FVector2D BackgroundScale, float Rotation, FVector2D PivotPoint, FVector2D CornerSize);
    void K2_DrawBox(FVector2D screenPosition, FVector2D ScreenSize, float Thickness, FLinearColor RenderColor);
    void K2_DrawLine(FVector2D ScreenPositionA, FVector2D ScreenPositionB, float Thickness, FLinearColor RenderColor);
    void K2_DrawMaterial(UMaterialInterface* RenderMaterial, FVector2D screenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize, float Rotation, FVector2D PivotPoint);
    void K2_DrawMaterialTriangle(UMaterialInterface* RenderMaterial, TArray<FCanvasUVTri> Triangles);
    void K2_DrawPolygon(UTexture* RenderTexture, FVector2D screenPosition, FVector2D Radius, int32_t NumberOfSides, FLinearColor RenderColor);
    void K2_DrawText(UFont* RenderFont, FString RenderText, FVector2D screenPosition, FVector2D Scale, FLinearColor RenderColor, float Kerning, FLinearColor ShadowColor, FVector2D ShadowOffset, bool bCentreX, bool bCentreY, bool bOutlined, FLinearColor OutlineColor);
    void K2_DrawTexture(UTexture* RenderTexture, FVector2D screenPosition, FVector2D ScreenSize, FVector2D CoordinatePosition, FVector2D CoordinateSize, FLinearColor RenderColor, uint8_t BlendMode, float Rotation, FVector2D PivotPoint);
    void K2_DrawTriangle(UTexture* RenderTexture, TArray<FCanvasUVTri> Triangles);
    FVector K2_Project(FVector WorldLocation);
    FVector2D K2_StrLen(UFont* RenderFont, FString RenderText);
    FVector2D K2_TextSize(UFont* RenderFont, FString RenderText, FVector2D Scale);
};

// Size: 0x18
struct FCanvasIcon {
    /* 0x0000 */ UTexture* Texture;
    /* 0x0008 */ float U;
    /* 0x000c */ float V;
    /* 0x0010 */ float UL;
    /* 0x0014 */ float VL;
};

// Size: 0x190
class UCanvasRenderTarget2D : public UTextureRenderTarget2D {
    /* 0x0170 */ FMulticastInlineDelegate OnCanvasRenderTargetUpdate;
    /* 0x0180 */ TWeakObjectPtr<UWorld> World;
    /* 0x0188 */ ETextureRenderTargetSampleCount SampleCount;
    /* 0x0189 */ bool bShouldClearRenderTargetOnReceiveUpdate;

    static UCanvasRenderTarget2D* CreateCanvasRenderTarget2D(UObject* WorldContextObject, UClass* CanvasRenderTarget2DClass, int32_t Width, int32_t Height);
    ETextureRenderTargetSampleCount GetSampleCount() const;
    void GetSize(int32_t& Width, int32_t& Height);
    void ReceiveUpdate(UCanvas* Canvas, int32_t Width, int32_t Height);
    void SetSampleCount(ETextureRenderTargetSampleCount InSampleCount);
    void UpdateResource();
};

// Size: 0x90
struct FCanvasUVTri {
    /* 0x0000 */ FVector2D V0_Pos;
    /* 0x0010 */ FVector2D V0_UV;
    /* 0x0020 */ FLinearColor V0_Color;
    /* 0x0030 */ FVector2D V1_Pos;
    /* 0x0040 */ FVector2D V1_UV;
    /* 0x0050 */ FLinearColor V1_Color;
    /* 0x0060 */ FVector2D V2_Pos;
    /* 0x0070 */ FVector2D V2_UV;
    /* 0x0080 */ FLinearColor V2_Color;
};

// Size: 0x550
class UCapsuleComponent : public UShapeComponent {
    /* 0x0540 */ float CapsuleHalfHeight;
    /* 0x0544 */ float CapsuleRadius;

    float GetScaledCapsuleHalfHeight() const;
    float GetScaledCapsuleHalfHeight_WithoutHemisphere() const;
    float GetScaledCapsuleRadius() const;
    void GetScaledCapsuleSize(float& OutRadius, float& OutHalfHeight) const;
    void GetScaledCapsuleSize_WithoutHemisphere(float& OutRadius, float& OutHalfHeightWithoutHemisphere) const;
    float GetShapeScale() const;
    float GetUnscaledCapsuleHalfHeight() const;
    float GetUnscaledCapsuleHalfHeight_WithoutHemisphere() const;
    float GetUnscaledCapsuleRadius() const;
    void GetUnscaledCapsuleSize(float& OutRadius, float& OutHalfHeight) const;
    void GetUnscaledCapsuleSize_WithoutHemisphere(float& OutRadius, float& OutHalfHeightWithoutHemisphere) const;
    void SetCapsuleHalfHeight(float HalfHeight, bool bUpdateOverlaps);
    void SetCapsuleRadius(float Radius, bool bUpdateOverlaps);
    void SetCapsuleSize(float InRadius, float InHalfHeight, bool bUpdateOverlaps);
};

// Size: 0x68
class UChannel : public UObject {
    /* 0x0028 */ UNetConnection* Connection;
};

// Size: 0x20
struct FChannelDefinition {
    /* 0x0000 */ FName ChannelName;
    /* 0x0008 */ FName ClassName;
    /* 0x0010 */ UClass* ChannelClass;
    /* 0x0018 */ int32_t StaticChannelIndex;
    /* 0x001c */ bool bTickOnCreate;
    /* 0x001c */ bool bServerOpen;
    /* 0x001c */ bool bClientOpen;
    /* 0x001c */ bool bInitialServer;
    /* 0x001c */ bool bInitialClient;
};

// Size: 0x28
class UChaosBlueprintLibrary : public UBlueprintFunctionLibrary {

    static UChaosEventRelay* GetEventRelayFromContext(UObject* ContextObject);
};

// Size: 0xa0
struct FChaosBreakEvent {
    /* 0x0000 */ UPrimitiveComponent* Component;
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FQuat Orientation;
    /* 0x0040 */ FVector Velocity;
    /* 0x0058 */ FVector AngularVelocity;
    /* 0x0070 */ FVector Extents;
    /* 0x0088 */ float Mass;
    /* 0x008c */ int32_t Index;
    /* 0x0090 */ bool bFromCrumble;
};

// Size: 0xc0
struct FChaosCrumblingEvent {
    /* 0x0000 */ UPrimitiveComponent* Component;
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FQuat Orientation;
    /* 0x0040 */ FVector LinearVelocity;
    /* 0x0058 */ FVector AngularVelocity;
    /* 0x0070 */ float Mass;
    /* 0x0078 */ FBox LocalBounds;
    /* 0x00b0 */ TArray<int32_t> Children;
};

// Size: 0x68
class UChaosEventRelay : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnCollisionEvent;
    /* 0x0038 */ FMulticastInlineDelegate OnBreakEvent;
    /* 0x0048 */ FMulticastInlineDelegate OnRemovalEvent;
    /* 0x0058 */ FMulticastInlineDelegate OnCrumblingEvent;
};

// Size: 0x3
struct FChaosPhysicsSettings {
    /* 0x0000 */ EChaosThreadingMode DefaultThreadingModel;
    /* 0x0001 */ EChaosSolverTickMode DedicatedThreadTickMode;
    /* 0x0002 */ EChaosBufferMode DedicatedThreadBufferMode;
};

// Size: 0x28
struct FChaosRemovalEvent {
    /* 0x0000 */ UPrimitiveComponent* Component;
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ float Mass;
};

// Size: 0x650
class ACharacter : public APawn {
    /* 0x0328 */ USkeletalMeshComponent* Mesh;
    /* 0x0330 */ UCharacterMovementComponent* CharacterMovement;
    /* 0x0338 */ UCapsuleComponent* CapsuleComponent;
    /* 0x0340 */ FBasedMovementInfo BasedMovement;
    /* 0x0388 */ FBasedMovementInfo ReplicatedBasedMovement;
    /* 0x03d0 */ float ReplicatedServerLastTransformUpdateTimeStamp;
    /* 0x03d4 */ float ReplayLastTransformUpdateTimeStamp;
    /* 0x03e0 */ FQuat BaseRotationOffset;
    /* 0x0400 */ FVector BaseTranslationOffset;
    /* 0x0418 */ FVector_NetQuantizeNormal ReplicatedGravityDirection;
    /* 0x0448 */ float AnimRootMotionTranslationScale;
    /* 0x044c */ float CrouchedEyeHeight;
    /* 0x0450 */ bool bInBaseReplication;
    /* 0x0450 */ bool bIsCrouched;
    /* 0x0450 */ bool bProxyIsJumpForceApplied;
    /* 0x0450 */ bool bPressedJump;
    /* 0x0450 */ bool bClientUpdating;
    /* 0x0450 */ bool bClientWasFalling;
    /* 0x0450 */ bool bClientResimulateRootMotion;
    /* 0x0450 */ bool bClientResimulateRootMotionSources;
    /* 0x0451 */ bool bSimGravityDisabled;
    /* 0x0451 */ bool bClientCheckEncroachmentOnNetUpdate;
    /* 0x0451 */ bool bServerMoveIgnoreRootMotion;
    /* 0x0451 */ bool bWasJumping;
    /* 0x0452 */ uint8_t ReplicatedMovementMode;
    /* 0x0454 */ float JumpKeyHoldTime;
    /* 0x0458 */ float JumpForceTimeRemaining;
    /* 0x045c */ float ProxyJumpForceStartedTime;
    /* 0x0460 */ float JumpMaxHoldTime;
    /* 0x0464 */ int32_t JumpMaxCount;
    /* 0x0468 */ int32_t JumpCurrentCount;
    /* 0x046c */ int32_t JumpCurrentCountPreJump;
    /* 0x0478 */ FMulticastInlineDelegate OnReachedJumpApex;
    /* 0x0488 */ FMulticastInlineDelegate LandedDelegate;
    /* 0x0498 */ FMulticastInlineDelegate MovementModeChangedDelegate;
    /* 0x04a8 */ FMulticastInlineDelegate OnCharacterMovementUpdated;
    /* 0x04b8 */ FRootMotionSourceGroup SavedRootMotion;
    /* 0x0500 */ FRootMotionMovementParams ClientRootMotionParams;
    /* 0x0570 */ TArray<FSimulatedRootMotionReplicatedMove> RootMotionRepMoves;
    /* 0x0580 */ FRepRootMotionMontage RepRootMotion;

    void CacheInitialMeshOffset(FVector MeshRelativeLocation, FRotator MeshRelativeRotation);
    bool CanCrouch() const;
    bool CanJump() const;
    bool CanJumpInternal() const;
    void ClientAckGoodMove(float Timestamp);
    void ClientAdjustPosition(float Timestamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8_t ServerMovementMode);
    void ClientAdjustRootMotionPosition(float Timestamp, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8_t ServerMovementMode);
    void ClientAdjustRootMotionSourcePosition(float Timestamp, FRootMotionSourceGroup ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, FVector ServerLoc, FVector_NetQuantizeNormal ServerRotation, float ServerVelZ, UPrimitiveComponent* ServerBase, FName ServerBoneName, bool bHasBase, bool bBaseRelativePosition, uint8_t ServerMovementMode);
    void ClientCheatFly();
    void ClientCheatGhost();
    void ClientCheatWalk();
    void ClientMoveResponsePacked(const FCharacterMoveResponsePackedBits PackedBits);
    void ClientVeryShortAdjustPosition(float Timestamp, FVector NewLoc, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8_t ServerMovementMode);
    void Crouch(bool bClientSimulation);
    float GetAnimRootMotionTranslationScale() const;
    FRotator GetBaseRotationOffsetRotator() const;
    FVector GetBaseTranslationOffset() const;
    UAnimMontage* GetCurrentMontage() const;
    bool HasAnyRootMotion() const;
    bool IsJumpProvidingForce() const;
    bool IsPlayingNetworkedRootMotionMontage() const;
    bool IsPlayingRootMotion() const;
    void Jump();
    void K2_OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
    void K2_OnMovementModeChanged(uint8_t PrevMovementMode, uint8_t NewMovementMode, uint8_t PrevCustomMode, uint8_t NewCustomMode);
    void K2_OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust);
    void K2_UpdateCustomMovement(float deltaTime);
    void LaunchCharacter(FVector LaunchVelocity, bool bXYOverride, bool bZOverride);
    void OnJumped();
    void OnLanded(const FHitResult& Hit);
    void OnLaunched(FVector LaunchVelocity, bool bXYOverride, bool bZOverride);
    void OnRep_IsCrouched();
    void OnRep_ReplayLastTransformUpdateTimeStamp();
    void OnRep_ReplicatedBasedMovement();
    void OnRep_RootMotion();
    void OnWalkingOffLedge(const FVector& PreviousFloorImpactNormal, const FVector& PreviousFloorContactNormal, const FVector& PreviousLocation, float TimeDelta);
    float PlayAnimMontage(UAnimMontage* AnimMontage, float InPlayRate, FName StartSectionName);
    void RootMotionDebugClientPrintOnScreen(FString InString);
    void ServerMove(float Timestamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8_t CompressedMoveFlags, uint8_t ClientRoll, uint32_t View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8_t ClientMovementMode);
    void ServerMoveDual(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8_t PendingFlags, uint32_t View0, float Timestamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8_t NewFlags, uint8_t ClientRoll, uint32_t View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8_t ClientMovementMode);
    void ServerMoveDualHybridRootMotion(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8_t PendingFlags, uint32_t View0, float Timestamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8_t NewFlags, uint8_t ClientRoll, uint32_t View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8_t ClientMovementMode);
    void ServerMoveDualNoBase(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8_t PendingFlags, uint32_t View0, float Timestamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8_t NewFlags, uint8_t ClientRoll, uint32_t View, uint8_t ClientMovementMode);
    void ServerMoveNoBase(float Timestamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8_t CompressedMoveFlags, uint8_t ClientRoll, uint32_t View, uint8_t ClientMovementMode);
    void ServerMoveOld(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8_t OldMoveFlags);
    void ServerMovePacked(const FCharacterServerMovePackedBits PackedBits);
    void StopAnimMontage(UAnimMontage* AnimMontage);
    void StopJumping();
    void UnCrouch(bool bClientSimulation);
};

// Size: 0x118
struct FCharacterMoveResponsePackedBits : public FCharacterNetworkSerializationPackedBits {
};

// Size: 0xfd0
class UCharacterMovementComponent : public UPawnMovementComponent {
    /* 0x0198 */ ACharacter* CharacterOwner;
    /* 0x01a0 */ float GravityScale;
    /* 0x01a4 */ float MaxStepHeight;
    /* 0x01a8 */ float JumpZVelocity;
    /* 0x01ac */ float JumpOffJumpZFactor;
    /* 0x01cc */ float WalkableFloorAngle;
    /* 0x01d0 */ float WalkableFloorZ;
    /* 0x01d8 */ FVector GravityDirection;
    /* 0x01f0 */ FQuat WorldToGravityTransform;
    /* 0x0210 */ FQuat GravityToWorldTransform;
    /* 0x0231 */ uint8_t MovementMode;
    /* 0x0232 */ uint8_t CustomMovementMode;
    /* 0x0233 */ ENetworkSmoothingMode NetworkSmoothingMode;
    /* 0x0234 */ float GroundFriction;
    /* 0x0278 */ float MaxWalkSpeed;
    /* 0x027c */ float MaxWalkSpeedCrouched;
    /* 0x0280 */ float MaxSwimSpeed;
    /* 0x0284 */ float MaxFlySpeed;
    /* 0x0288 */ float MaxCustomMovementSpeed;
    /* 0x028c */ float MaxAcceleration;
    /* 0x0290 */ float MinAnalogWalkSpeed;
    /* 0x0294 */ float BrakingFrictionFactor;
    /* 0x0298 */ float BrakingFriction;
    /* 0x029c */ float BrakingSubStepTime;
    /* 0x02a0 */ float BrakingDecelerationWalking;
    /* 0x02a4 */ float BrakingDecelerationFalling;
    /* 0x02a8 */ float BrakingDecelerationSwimming;
    /* 0x02ac */ float BrakingDecelerationFlying;
    /* 0x02b0 */ float AirControl;
    /* 0x02b4 */ float AirControlBoostMultiplier;
    /* 0x02b8 */ float AirControlBoostVelocityThreshold;
    /* 0x02bc */ float FallingLateralFriction;
    /* 0x02c0 */ float CrouchedHalfHeight;
    /* 0x02c4 */ float Buoyancy;
    /* 0x02c8 */ float PerchRadiusThreshold;
    /* 0x02cc */ float PerchAdditionalHeight;
    /* 0x02d0 */ FRotator RotationRate;
    /* 0x02e8 */ bool bUseSeparateBrakingFriction;
    /* 0x02e8 */ bool bDontFallBelowJumpZVelocityDuringJump;
    /* 0x02e8 */ bool bApplyGravityWhileJumping;
    /* 0x02e8 */ bool bUseControllerDesiredRotation;
    /* 0x02e8 */ bool bOrientRotationToMovement;
    /* 0x02e8 */ bool bSweepWhileNavWalking;
    /* 0x02e8 */ bool bMovementInProgress;
    /* 0x02e9 */ bool bEnableScopedMovementUpdates;
    /* 0x02e9 */ bool bEnableServerDualMoveScopedMovementUpdates;
    /* 0x02e9 */ bool bForceMaxAccel;
    /* 0x02e9 */ bool bRunPhysicsWithNoController;
    /* 0x02e9 */ bool bForceNextFloorCheck;
    /* 0x02e9 */ bool bShrinkProxyCapsule;
    /* 0x02e9 */ bool bCanWalkOffLedges;
    /* 0x02e9 */ bool bCanWalkOffLedgesWhenCrouching;
    /* 0x02ea */ bool bNetworkSkipProxyPredictionOnNetUpdate;
    /* 0x02ea */ bool bNetworkAlwaysReplicateTransformUpdateTimestamp;
    /* 0x02ea */ bool bDeferUpdateMoveComponent;
    /* 0x02ea */ bool bEnablePhysicsInteraction;
    /* 0x02ea */ bool bTouchForceScaledToMass;
    /* 0x02ea */ bool bPushForceScaledToMass;
    /* 0x02eb */ bool bPushForceUsingZOffset;
    /* 0x02eb */ bool bScalePushForceToVelocity;
    /* 0x02f0 */ USceneComponent* DeferredUpdatedMoveComponent;
    /* 0x02f8 */ float MaxOutOfWaterStepHeight;
    /* 0x02fc */ float OutofWaterZ;
    /* 0x0300 */ float Mass;
    /* 0x0304 */ float StandingDownwardForceScale;
    /* 0x0308 */ float InitialPushForceFactor;
    /* 0x030c */ float PushForceFactor;
    /* 0x0310 */ float PushForcePointZOffsetFactor;
    /* 0x0314 */ float TouchForceFactor;
    /* 0x0318 */ float MinTouchForce;
    /* 0x031c */ float MaxTouchForce;
    /* 0x0320 */ float RepulsionForce;
    /* 0x0328 */ FVector Acceleration;
    /* 0x0340 */ FQuat LastUpdateRotation;
    /* 0x0360 */ FVector LastUpdateLocation;
    /* 0x0378 */ FVector LastUpdateVelocity;
    /* 0x0390 */ float ServerLastTransformUpdateTimeStamp;
    /* 0x0394 */ float ServerLastClientGoodMoveAckTime;
    /* 0x0398 */ float ServerLastClientAdjustmentTime;
    /* 0x03a0 */ FVector PendingImpulseToApply;
    /* 0x03b8 */ FVector PendingForceToApply;
    /* 0x03d0 */ float AnalogInputModifier;
    /* 0x03e0 */ float MaxSimulationTimeStep;
    /* 0x03e4 */ int32_t MaxSimulationIterations;
    /* 0x03e8 */ int32_t MaxJumpApexAttemptsPerSimulation;
    /* 0x03ec */ float MaxDepenetrationWithGeometry;
    /* 0x03f0 */ float MaxDepenetrationWithGeometryAsProxy;
    /* 0x03f4 */ float MaxDepenetrationWithPawn;
    /* 0x03f8 */ float MaxDepenetrationWithPawnAsProxy;
    /* 0x03fc */ float NetworkSimulatedSmoothLocationTime;
    /* 0x0400 */ float NetworkSimulatedSmoothRotationTime;
    /* 0x0404 */ float ListenServerNetworkSimulatedSmoothLocationTime;
    /* 0x0408 */ float ListenServerNetworkSimulatedSmoothRotationTime;
    /* 0x040c */ float NetProxyShrinkRadius;
    /* 0x0410 */ float NetProxyShrinkHalfHeight;
    /* 0x0414 */ float NetworkMaxSmoothUpdateDistance;
    /* 0x0418 */ float NetworkNoSmoothUpdateDistance;
    /* 0x041c */ float NetworkMinTimeBetweenClientAckGoodMoves;
    /* 0x0420 */ float NetworkMinTimeBetweenClientAdjustments;
    /* 0x0424 */ float NetworkMinTimeBetweenClientAdjustmentsLargeCorrection;
    /* 0x0428 */ float NetworkLargeClientCorrectionDistance;
    /* 0x042c */ float LedgeCheckThreshold;
    /* 0x0430 */ float JumpOutOfWaterPitch;
    /* 0x0438 */ FFindFloorResult CurrentFloor;
    /* 0x0548 */ uint8_t DefaultLandMovementMode;
    /* 0x0549 */ uint8_t DefaultWaterMovementMode;
    /* 0x054a */ uint8_t GroundMovementMode;
    /* 0x0554 */ bool bMaintainHorizontalGroundVelocity;
    /* 0x0554 */ bool bImpartBaseVelocityX;
    /* 0x0554 */ bool bImpartBaseVelocityY;
    /* 0x0554 */ bool bImpartBaseVelocityZ;
    /* 0x0554 */ bool bImpartBaseAngularVelocity;
    /* 0x0554 */ bool bJustTeleported;
    /* 0x0554 */ bool bNetworkUpdateReceived;
    /* 0x0554 */ bool bNetworkMovementModeChanged;
    /* 0x0555 */ bool bNetworkGravityDirectionChanged;
    /* 0x0555 */ bool bIgnoreClientMovementErrorChecksAndCorrection;
    /* 0x0555 */ bool bServerAcceptClientAuthoritativePosition;
    /* 0x0555 */ bool bNotifyApex;
    /* 0x0555 */ bool bCheatFlying;
    /* 0x0555 */ bool bWantsToCrouch;
    /* 0x0555 */ bool bCrouchMaintainsBaseLocation;
    /* 0x0555 */ bool bIgnoreBaseRotation;
    /* 0x0556 */ bool bFastAttachedMove;
    /* 0x0556 */ bool bAlwaysCheckFloor;
    /* 0x0556 */ bool bUseFlatBaseForFloorChecks;
    /* 0x0556 */ bool bPerformingJumpOff;
    /* 0x0556 */ bool bWantsToLeaveNavWalking;
    /* 0x0556 */ bool bUseRVOAvoidance;
    /* 0x0556 */ bool bRequestedMoveUseAcceleration;
    /* 0x0557 */ bool bWasSimulatingRootMotion;
    /* 0x0557 */ bool bAllowPhysicsRotationDuringAnimRootMotion;
    /* 0x0558 */ float FormerBaseVelocityDecayHalfLife;
    /* 0x055c */ bool bHasRequestedVelocity;
    /* 0x055c */ bool bRequestedMoveWithMaxSpeed;
    /* 0x055c */ bool bWasAvoidanceUpdated;
    /* 0x055c */ bool bProjectNavMeshWalking;
    /* 0x055c */ bool bProjectNavMeshOnBothWorldChannels;
    /* 0x057c */ float AvoidanceConsiderationRadius;
    /* 0x0580 */ FVector RequestedVelocity;
    /* 0x0598 */ FVector LastUpdateRequestedVelocity;
    /* 0x05b0 */ int32_t AvoidanceUID;
    /* 0x05b4 */ FNavAvoidanceMask AvoidanceGroup;
    /* 0x05b8 */ FNavAvoidanceMask GroupsToAvoid;
    /* 0x05bc */ FNavAvoidanceMask GroupsToIgnore;
    /* 0x05c0 */ float AvoidanceWeight;
    /* 0x05c8 */ FVector PendingLaunchVelocity;
    /* 0x0730 */ float NavMeshProjectionInterval;
    /* 0x0734 */ float NavMeshProjectionTimer;
    /* 0x0738 */ float NavMeshProjectionInterpSpeed;
    /* 0x073c */ float NavMeshProjectionHeightScaleUp;
    /* 0x0740 */ float NavMeshProjectionHeightScaleDown;
    /* 0x0744 */ float NavWalkingFloorDistTolerance;
    /* 0x0748 */ bool bBasedMovementIgnorePhysicsBase;
    /* 0x0749 */ bool bBaseOnAttachmentRoot;
    /* 0x074a */ bool bStayBasedInAir;
    /* 0x074c */ float StayBasedInAirHeight;
    /* 0x0780 */ FCharacterMovementComponentPostPhysicsTickFunction PostPhysicsTickFunction;
    /* 0x07c8 */ float MinTimeBetweenTimeStampResets;
    /* 0x0d28 */ FRootMotionSourceGroup CurrentRootMotion;
    /* 0x0d70 */ FRootMotionSourceGroup ServerCorrectionRootMotion;
    /* 0x0f20 */ FRootMotionMovementParams RootMotionParams;
    /* 0x0f90 */ FVector AnimRootMotionVelocity;

    void AddForce(FVector Force);
    void AddImpulse(FVector Impulse, bool bVelocityChange);
    void CalcVelocity(float deltaTime, float Friction, bool bFluid, float BrakingDeceleration);
    void CapsuleTouched(UPrimitiveComponent* OverlappedComp, AActor* Other, UPrimitiveComponent* OtherComp, int32_t OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
    void ClearAccumulatedForces();
    void DisableMovement();
    float GetAnalogInputModifier() const;
    ACharacter* GetCharacterOwner() const;
    float GetCrouchedHalfHeight() const;
    FVector GetCurrentAcceleration() const;
    FVector GetGravityDirection() const;
    FVector GetImpartedMovementBaseVelocity() const;
    FVector GetLastUpdateLocation() const;
    FVector GetLastUpdateRequestedVelocity() const;
    FRotator GetLastUpdateRotation() const;
    FVector GetLastUpdateVelocity() const;
    float GetMaxAcceleration() const;
    float GetMaxBrakingDeceleration() const;
    float GetMaxJumpHeight() const;
    float GetMaxJumpHeightWithJumpTime() const;
    float GetMinAnalogSpeed() const;
    UPrimitiveComponent* GetMovementBase() const;
    float GetPerchRadiusThreshold() const;
    float GetValidPerchRadius() const;
    bool HasCustomGravity() const;
    bool IsWalkable(const FHitResult& Hit) const;
    bool IsWalking() const;
    void K2_ComputeFloorDist(FVector CapsuleLocation, float LineDistance, float SweepDistance, float SweepRadius, FFindFloorResult& FloorResult) const;
    void K2_FindFloor(FVector CapsuleLocation, FFindFloorResult& FloorResult) const;
    float K2_GetWalkableFloorAngle() const;
    float K2_GetWalkableFloorZ() const;
    void SetAvoidanceEnabled(bool bEnable);
    void SetAvoidanceGroup(int32_t GroupFlags);
    void SetAvoidanceGroupMask(const FNavAvoidanceMask& GroupMask);
    void SetCrouchedHalfHeight(const float NewValue);
    void SetGravityDirection(const FVector& GravityDir);
    void SetGroupsToAvoid(int32_t GroupFlags);
    void SetGroupsToAvoidMask(const FNavAvoidanceMask& GroupMask);
    void SetGroupsToIgnore(int32_t GroupFlags);
    void SetGroupsToIgnoreMask(const FNavAvoidanceMask& GroupMask);
    void SetMovementMode(uint8_t NewMovementMode, uint8_t NewCustomMode);
    void SetWalkableFloorAngle(float InWalkableFloorAngle);
    void SetWalkableFloorZ(float InWalkableFloorZ);
};

// Size: 0x30
struct FCharacterMovementComponentPostPhysicsTickFunction : public FTickFunction {
};

// Size: 0x30
struct FCharacterMovementComponentPrePhysicsTickFunction : public FTickFunction {
};

// Size: 0x118
struct FCharacterNetworkSerializationPackedBits {
};

// Size: 0x18
struct FCharacterNetworkSerializationPackedBitsNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint32_t MaxAllowedDataBits;
};

// Size: 0x118
struct FCharacterServerMovePackedBits : public FCharacterNetworkSerializationPackedBits {
};

// Size: 0x88
class UCheatManager : public UObject {
    /* 0x0028 */ ADebugCameraController* DebugCameraControllerRef;
    /* 0x0030 */ UClass* DebugCameraControllerClass;
    /* 0x0078 */ TArray<UCheatManagerExtension*> CheatManagerExtensions;

    void BugIt(FString ScreenShotDescription);
    void BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll);
    void BugItStringCreator(FVector ViewLocation, FRotator ViewRotation, FString& GoString, FString& LocString);
    void ChangeSize(float F);
    void CheatScript(FString ScriptName);
    void DamageTarget(float DamageAmount);
    void DebugCapsuleSweep();
    void DebugCapsuleSweepCapture();
    void DebugCapsuleSweepChannel(uint8_t Channel);
    void DebugCapsuleSweepClear();
    void DebugCapsuleSweepComplex(bool bTraceComplex);
    void DebugCapsuleSweepPawn();
    void DebugCapsuleSweepSize(float HalfHeight, float Radius);
    void DestroyAll(UClass* aClass);
    void DestroyAllPawnsExceptTarget();
    void DestroyPawns(UClass* aClass);
    void DestroyServerStatReplicator();
    void DestroyTarget();
    void DisableDebugCamera();
    void DumpChatState();
    void DumpOnlineSessionState();
    void DumpPartyState();
    void DumpVoiceMutingState();
    void EnableDebugCamera();
    void FlushLog();
    void Fly();
    void FreezeFrame(float Delay);
    APlayerController* GetPlayerController() const;
    void Ghost();
    void God();
    void InvertMouse();
    void LogLoc();
    void OnPlayerEndPlayed(AActor* Player, uint8_t EndPlayReason);
    void OnlyLoadLevel(FName PackageName);
    void PlayersOnly();
    void ReceiveEndPlay();
    void ReceiveInitCheatManager();
    void ServerToggleAILogging();
    void SetMouseSensitivityToDefault();
    void SetWorldOrigin();
    void Slomo(float NewTimeDilation);
    void SpawnServerStatReplicator();
    void StreamLevelIn(FName PackageName);
    void StreamLevelOut(FName PackageName);
    void Summon(FString ClassName);
    void Teleport();
    void TestCollisionDistance();
    void ToggleAILogging();
    void ToggleDebugCamera();
    void ToggleServerStatReplicatorClientOverwrite();
    void ToggleServerStatReplicatorUpdateStatNet();
    void UpdateSafeArea();
    void ViewActor(FName ActorName);
    void ViewClass(UClass* DesiredClass);
    void ViewPlayer(FString S);
    void ViewSelf();
    void Walk();
};

// Size: 0x28
class UCheatManagerExtension : public UObject {

    void AddedToCheatManager();
    APlayerController* GetPlayerController() const;
    void RemovedFromCheatManager();
};

// Size: 0x980
class UCheckBoxStyleAsset : public UObject {
    /* 0x0030 */ FCheckBoxStyle CheckBoxStyle;
};

// Size: 0x70
struct FChildActorAttachedActorInfo {
    /* 0x0000 */ TWeakObjectPtr<AActor> Actor;
    /* 0x0008 */ FName SocketName;
    /* 0x0010 */ FTransform RelativeTransform;
};

// Size: 0x290
class UChildActorComponent : public USceneComponent {
    /* 0x0240 */ UClass* ChildActorClass;
    /* 0x0248 */ AActor* childActor;
    /* 0x0250 */ AActor* ChildActorTemplate;
    /* 0x0270 */ bool bChildActorIsTransient;
    /* 0x0270 */ bool bSetOwner;

    void OnChildActorDestroyed(AActor* Actor);
    void OnRep_ChildActor();
    void SetChildActorClass(UClass* InClass);
};

// Size: 0xf8
struct FChildActorComponentInstanceData : public FSceneComponentInstanceData {
    /* 0x00b8 */ UClass* ChildActorClass;
    /* 0x00c0 */ FName ChildActorName;
    /* 0x00c8 */ TArray<FChildActorAttachedActorInfo> AttachedActors;
};

// Size: 0x1e30
class UChildConnection : public UNetConnection {
    /* 0x1e28 */ UNetConnection* Parent;
};

// Size: 0x3c
struct FClassRedirect {
    /* 0x0000 */ FName ObjectName;
    /* 0x0008 */ FName OldClassName;
    /* 0x0010 */ FName NewClassName;
    /* 0x0018 */ FName OldSubobjName;
    /* 0x0020 */ FName NewSubobjName;
    /* 0x0028 */ FName NewClassClass;
    /* 0x0030 */ FName NewClassPackage;
    /* 0x0038 */ bool InstanceOnly;
};

// Size: 0x40
struct FClientReceiveData {
    /* 0x0000 */ APlayerController* LocalPC;
    /* 0x0008 */ FName MessageType;
    /* 0x0010 */ int32_t MessageIndex;
    /* 0x0018 */ FString MessageString;
    /* 0x0028 */ APlayerState* RelatedPlayerState_1;
    /* 0x0030 */ APlayerState* RelatedPlayerState_2;
    /* 0x0038 */ UObject* OptionalObject;
};

// Size: 0x50
struct FClothPhysicsProperties_Legacy {
    /* 0x0000 */ float VerticalResistance;
    /* 0x0004 */ float HorizontalResistance;
    /* 0x0008 */ float BendResistance;
    /* 0x000c */ float ShearResistance;
    /* 0x0010 */ float Friction;
    /* 0x0014 */ float Damping;
    /* 0x0018 */ float TetherStiffness;
    /* 0x001c */ float TetherLimit;
    /* 0x0020 */ float Drag;
    /* 0x0024 */ float StiffnessFrequency;
    /* 0x0028 */ float GravityScale;
    /* 0x002c */ float MassScale;
    /* 0x0030 */ float InertiaBlend;
    /* 0x0034 */ float SelfCollisionThickness;
    /* 0x0038 */ float SelfCollisionSquashScale;
    /* 0x003c */ float SelfCollisionStiffness;
    /* 0x0040 */ float SolverFrequency;
    /* 0x0044 */ float FiberCompression;
    /* 0x0048 */ float FiberExpansion;
    /* 0x004c */ float FiberResistance;
};

// Size: 0x70
struct FClothingAssetData_Legacy {
    /* 0x0000 */ FName AssetName;
    /* 0x0008 */ FString ApexFileName;
    /* 0x0018 */ bool bClothPropertiesChanged;
    /* 0x001c */ FClothPhysicsProperties_Legacy PhysicsProperties;
};

// Size: 0x50
class UCloudStorageBase : public UPlatformInterfaceBase {
    /* 0x0038 */ TArray<FString> LocalCloudFiles;
    /* 0x0048 */ bool bSuppressDelegateCalls;
};

// Size: 0x40
struct FClusterNode {
    /* 0x0000 */ FVector3f BoundMin;
    /* 0x000c */ int32_t FirstChild;
    /* 0x0010 */ FVector3f BoundMax;
    /* 0x001c */ int32_t LastChild;
    /* 0x0020 */ int32_t FirstInstance;
    /* 0x0024 */ int32_t LastInstance;
    /* 0x0028 */ FVector3f MinInstanceScale;
    /* 0x0034 */ FVector3f MaxInstanceScale;
};

// Size: 0x28
struct FClusterNode_DEPRECATED {
    /* 0x0000 */ FVector3f BoundMin;
    /* 0x000c */ int32_t FirstChild;
    /* 0x0010 */ FVector3f BoundMax;
    /* 0x001c */ int32_t LastChild;
    /* 0x0020 */ int32_t FirstInstance;
    /* 0x0024 */ int32_t LastInstance;
};

// Size: 0x2b0
class AClusterUnionActor : public AActor {
    /* 0x02a8 */ UClusterUnionComponent* ClusterUnion;

    UClusterUnionComponent* GetClusterUnionComponent() const;
};

// Size: 0x8
struct FClusterUnionBoneData {
};

// Size: 0x770
class UClusterUnionComponent : public UPrimitiveComponent {
    /* 0x0520 */ bool bEnableDamageFromCollision;
    /* 0x0528 */ FMulticastInlineDelegate OnComponentAddedEvent;
    /* 0x0538 */ FMulticastInlineDelegate OnComponentRemovedEvent;
    /* 0x0548 */ FMulticastInlineDelegate OnComponentBoundsChangedEvent;
    /* 0x05f0 */ TArray<FComponentReference> ClusteredComponentsReferences;
    /* 0x0600 */ int32_t GravityGroupIndexOverride;
    /* 0x0708 */ FClusterUnionReplicatedData ReplicatedRigidState;

    void AddComponentToCluster(UPrimitiveComponent* InComponent, const TArray<int32_t>& BoneIds, bool bRebuildGeometry);
    void ForceSetChildToParent(UPrimitiveComponent* InComponent, const TArray<int32_t>& BoneIds, const TArray<FTransform>& ChildToParent);
    TArray<AActor*> GetActors();
    TArray<UPrimitiveComponent*> GetPrimitiveComponents();
    void HandleComponentPhysicsStateChange(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
    void HandleComponentPhysicsStateChangePostAddIntoClusterUnion(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
    bool IsAuthority() const;
    bool IsComponentAdded(UPrimitiveComponent* Component);
    void OnRep_RigidState();
    void RemoveComponentBonesFromCluster(UPrimitiveComponent* InComponent, const TArray<int32_t>& BoneIds);
    void RemoveComponentFromCluster(UPrimitiveComponent* InComponent);
    void SetEnableDamageFromCollision(bool bValue);
    void SetIsAnchored(bool bIsAnchored);
};

// Size: 0x18
struct FClusterUnionInitializationData {
    /* 0x0000 */ UClusterUnionComponent* ClusterUnionComponent;
    /* 0x0008 */ TArray<UPrimitiveComponent*> ProcessedComponents;
};

// Size: 0x50
struct FClusterUnionPendingAddData {
    /* 0x0000 */ TSet<FClusterUnionBoneData> BonesData;
};

// Size: 0x2
struct FClusterUnionReplicatedData {
    /* 0x0000 */ uint8_t ObjectState;
    /* 0x0001 */ bool bIsAnchored;
};

// Size: 0x148
class UClusterUnionReplicatedProxyComponent : public UActorComponent {
    /* 0x00b8 */ TWeakObjectPtr<UClusterUnionComponent> ParentClusterUnion;
    /* 0x00c0 */ TWeakObjectPtr<UPrimitiveComponent> ChildClusteredComponent;
    /* 0x00c8 */ TArray<int32_t> ParticleBoneIds;
    /* 0x0128 */ TArray<FTransform> ParticleChildToParents;
    /* 0x0138 */ bool bNetUpdateParentClusterUnion;
    /* 0x0139 */ bool bNetUpdateChildClusteredComponent;
    /* 0x013a */ bool bNetUpdateParticleBoneIds;
    /* 0x013b */ bool bNetUpdateParticleChildToParents;
    /* 0x013c */ bool bIsPendingDeletion;

    UPrimitiveComponent* GetChildClusteredComponent() const;
    UClusterUnionComponent* GetParentClusterUnionComponent() const;
    TArray<int32_t> GetParticleBoneIds() const;
    bool IsPendingDeletion();
    void MarkPendingDeletion();
    void OnRep_ChildClusteredComponent();
    void OnRep_ParentClusterUnion();
    void OnRep_ParticleBoneIds();
    void OnRep_ParticleChildToParents();
    void SetChildClusteredComponent(UPrimitiveComponent* InComponent);
    void SetParentClusterUnion(UClusterUnionComponent* InComponent);
    void SetParticleBoneIds(const TArray<int32_t>& InIds);
    void SetParticleChildToParent(int32_t BoneID, const FTransform& ChildToParent);
};

// Size: 0x58
struct FClusteredActorData {
    /* 0x0050 */ bool bWasReplicatingMovement;
};

// Size: 0x28
struct FClusteredComponentData {
    /* 0x0010 */ TWeakObjectPtr<UClusterUnionReplicatedProxyComponent> ReplicatedProxyComponent;
    /* 0x0018 */ TWeakObjectPtr<AActor> Owner;
    /* 0x0020 */ bool bWasReplicating;
    /* 0x0021 */ bool bPendingDeletion;
};

// Size: 0x18
struct FCollectionParameterBase {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ FGuid ID;
};

// Size: 0x8
struct FCollectionReference {
    /* 0x0000 */ FName CollectionName;
};

// Size: 0x1c
struct FCollectionScalarParameter : public FCollectionParameterBase {
    /* 0x0018 */ float DefaultValue;
};

// Size: 0x28
struct FCollectionVectorParameter : public FCollectionParameterBase {
    /* 0x0018 */ FLinearColor DefaultValue;
};

// Size: 0x130
struct FCollisionChaosEvent {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector AccumulatedImpulse;
    /* 0x0030 */ FVector Normal;
    /* 0x0048 */ float PenetrationDepth;
    /* 0x0050 */ FCollisionChaosEventBodyInfo Body1;
    /* 0x00c0 */ FCollisionChaosEventBodyInfo Body2;
};

// Size: 0x70
struct FCollisionChaosEventBodyInfo {
    /* 0x0000 */ FVector Velocity;
    /* 0x0018 */ FVector DeltaVelocity;
    /* 0x0030 */ FVector AngularVelocity;
    /* 0x0048 */ float Mass;
    /* 0x0050 */ UPhysicalMaterial* PhysMaterial;
    /* 0x0058 */ TWeakObjectPtr<UPrimitiveComponent> Component;
    /* 0x0060 */ int32_t BodyIndex;
    /* 0x0064 */ FName BoneName;
};

// Size: 0x48
struct FCollisionImpactData {
    /* 0x0000 */ TArray<FRigidBodyContactInfo> ContactInfos;
    /* 0x0010 */ FVector TotalNormalImpulse;
    /* 0x0028 */ FVector TotalFrictionImpulse;
    /* 0x0040 */ bool bIsVelocityDeltaUnderThreshold;
};

// Size: 0x170
class UCollisionProfile : public UDeveloperSettings {
    /* 0x0038 */ TArray<FCollisionResponseTemplate> Profiles;
    /* 0x0048 */ TArray<FCustomChannelSetup> DefaultChannelResponses;
    /* 0x0058 */ TArray<FCustomProfile> EditProfiles;
    /* 0x0068 */ TArray<FRedirector> ProfileRedirects;
    /* 0x0078 */ TArray<FRedirector> CollisionChannelRedirects;
};

// Size: 0x8
struct FCollisionProfileName {
    /* 0x0000 */ FName Name;
};

// Size: 0x30
struct FCollisionResponse {
    /* 0x0000 */ FCollisionResponseContainer ResponseToChannels;
    /* 0x0020 */ TArray<FResponseChannel> ResponseArray;
};

// Size: 0x20
struct FCollisionResponseContainer {
    /* 0x0000 */ uint8_t WorldStatic;
    /* 0x0001 */ uint8_t WorldDynamic;
    /* 0x0002 */ uint8_t Pawn;
    /* 0x0003 */ uint8_t Visibility;
    /* 0x0004 */ uint8_t Camera;
    /* 0x0005 */ uint8_t PhysicsBody;
    /* 0x0006 */ uint8_t Vehicle;
    /* 0x0007 */ uint8_t Destructible;
    /* 0x0008 */ uint8_t EngineTraceChannel1;
    /* 0x0009 */ uint8_t EngineTraceChannel2;
    /* 0x000a */ uint8_t EngineTraceChannel3;
    /* 0x000b */ uint8_t EngineTraceChannel4;
    /* 0x000c */ uint8_t EngineTraceChannel5;
    /* 0x000d */ uint8_t EngineTraceChannel6;
    /* 0x000e */ uint8_t GameTraceChannel1;
    /* 0x000f */ uint8_t GameTraceChannel2;
    /* 0x0010 */ uint8_t GameTraceChannel3;
    /* 0x0011 */ uint8_t GameTraceChannel4;
    /* 0x0012 */ uint8_t GameTraceChannel5;
    /* 0x0013 */ uint8_t GameTraceChannel6;
    /* 0x0014 */ uint8_t GameTraceChannel7;
    /* 0x0015 */ uint8_t GameTraceChannel8;
    /* 0x0016 */ uint8_t GameTraceChannel9;
    /* 0x0017 */ uint8_t GameTraceChannel10;
    /* 0x0018 */ uint8_t GameTraceChannel11;
    /* 0x0019 */ uint8_t GameTraceChannel12;
    /* 0x001a */ uint8_t GameTraceChannel13;
    /* 0x001b */ uint8_t GameTraceChannel14;
    /* 0x001c */ uint8_t GameTraceChannel15;
    /* 0x001d */ uint8_t GameTraceChannel16;
    /* 0x001e */ uint8_t GameTraceChannel17;
    /* 0x001f */ uint8_t GameTraceChannel18;
};

// Size: 0x48
struct FCollisionResponseTemplate {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ uint8_t CollisionEnabled;
    /* 0x000a */ bool bCanModify;
    /* 0x002c */ FName ObjectTypeName;
    /* 0x0038 */ TArray<FResponseChannel> CustomResponses;
};

// Size: 0xa0
struct FColorGradePerRangeSettings {
    /* 0x0000 */ FVector4 Saturation;
    /* 0x0020 */ FVector4 Contrast;
    /* 0x0040 */ FVector4 Gamma;
    /* 0x0060 */ FVector4 Gain;
    /* 0x0080 */ FVector4 Offset;
};

// Size: 0x290
struct FColorGradingSettings {
    /* 0x0000 */ FColorGradePerRangeSettings Global;
    /* 0x00a0 */ FColorGradePerRangeSettings Shadows;
    /* 0x0140 */ FColorGradePerRangeSettings Midtones;
    /* 0x01e0 */ FColorGradePerRangeSettings Highlights;
    /* 0x0280 */ float ShadowsMax;
    /* 0x0284 */ float HighlightsMin;
    /* 0x0288 */ float HighlightsMax;
};

// Size: 0xa0
class UColorInputDeviceCurveProperty : public UInputDeviceProperty {
    /* 0x0030 */ FDeviceColorCurveData ColorData;
    /* 0x0040 */ TMap<FName, FDeviceColorCurveData> DeviceOverrideData;
};

// Size: 0x98
class UColorInputDeviceProperty : public UInputDeviceProperty {
    /* 0x0030 */ FDeviceColorData ColorData;
    /* 0x0038 */ TMap<FName, FDeviceColorData> DeviceOverrideData;
};

// Size: 0x40
struct FColorMaterialInput : public FMaterialInput {
    /* 0x0028 */ bool UseConstant;
    /* 0x002c */ FLinearColor Constant;
};

// Size: 0x80
class UCommandlet : public UObject {
    /* 0x0028 */ FString HelpDescription;
    /* 0x0038 */ FString HelpUsage;
    /* 0x0048 */ FString HelpWebLink;
    /* 0x0058 */ TArray<FString> HelpParamNames;
    /* 0x0068 */ TArray<FString> HelpParamDescriptions;
    /* 0x0078 */ bool IsServer;
    /* 0x0078 */ bool IsClient;
    /* 0x0078 */ bool isEditor;
    /* 0x0078 */ bool LogToConsole;
    /* 0x0078 */ bool ShowErrorCount;
    /* 0x0078 */ bool showProgress;
    /* 0x0078 */ bool FastExit;
    /* 0x0078 */ bool UseCommandletResultAsExitCode;
};

// Size: 0x38
class UComponentDelegateBinding : public UDynamicBlueprintBinding {
    /* 0x0028 */ TArray<FBlueprintComponentDelegateBinding> ComponentDelegateBindings;
};

// Size: 0x30
class UComponentElementCounterInterface : public UObject {
};

// Size: 0x30
class UComponentElementHierarchyInterface : public UObject {
};

// Size: 0x30
class UComponentElementObjectInterface : public UObject {
};

// Size: 0x30
class UComponentElementSelectionInterface : public UObject {
};

// Size: 0x30
class UComponentElementWorldInterface : public UObject {
};

// Size: 0x20
struct FComponentKey {
    /* 0x0000 */ UClass* OwnerClass;
    /* 0x0008 */ FName SCSVariableName;
    /* 0x0010 */ FGuid AssociatedGuid;
};

// Size: 0x78
struct FComponentOverrideRecord {
    /* 0x0000 */ UClass* ComponentClass;
    /* 0x0008 */ UActorComponent* ComponentTemplate;
    /* 0x0010 */ FComponentKey ComponentKey;
    /* 0x0030 */ FBlueprintCookedComponentInstancingData CookedComponentInstancingData;
};

// Size: 0x28
struct FComponentReference : public FBaseComponentReference {
    /* 0x0020 */ TWeakObjectPtr<AActor> OtherActor;
};

// Size: 0x20
struct FComponentSpacePose {
    /* 0x0000 */ TArray<FTransform> Transforms;
    /* 0x0010 */ TArray<FName> Names;
};

// Size: 0x10
struct FComponentSpacePoseLink : public FPoseLinkBase {
};

// Size: 0xc
struct FComponentSync {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ ESyncOption SyncOption;
};

// Size: 0xc8
class UCompositeCurveTable : public UCurveTable {
    /* 0x00a0 */ TArray<UCurveTable*> ParentTables;
    /* 0x00b0 */ TArray<UCurveTable*> OldParentTables;
};

// Size: 0xd8
class UCompositeDataTable : public UDataTable {
    /* 0x00b0 */ TArray<UDataTable*> ParentTables;
    /* 0x00c0 */ TArray<UDataTable*> OldParentTables;
};

// Size: 0x10
struct FCompositeReroute {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UMaterialExpressionReroute* Expression;
};

// Size: 0x50
struct FCompositeSection : public FAnimLinkableElement {
    /* 0x0030 */ FName SectionName;
    /* 0x0038 */ FName NextSectionName;
    /* 0x0040 */ TArray<UAnimMetaData*> MetaData;
};

// Size: 0x18
struct FCompressedRichCurve {
};

// Size: 0x38
struct FCompressedTrack {
    /* 0x0000 */ TArray<uint8_t> ByteStream;
    /* 0x0010 */ TArray<float> Times;
    /* 0x0020 */ float Mins[3];
    /* 0x002c */ float Ranges[3];
};

// Size: 0x20
struct FConeConstraint : public FConstraintBaseParams {
    /* 0x0014 */ float Swing1LimitDegrees;
    /* 0x0018 */ float Swing2LimitDegrees;
    /* 0x001c */ uint8_t Swing1Motion;
    /* 0x001d */ uint8_t Swing2Motion;
};

// Size: 0x160
class UConsole : public UObject {
    /* 0x0038 */ ULocalPlayer* ConsoleTargetPlayer;
    /* 0x0040 */ UTexture2D* DefaultTexture_Black;
    /* 0x0048 */ UTexture2D* DefaultTexture_White;
    /* 0x0068 */ TArray<FString> HistoryBuffer;
};

// Size: 0x8
struct FConstrainComponentPropName {
    /* 0x0000 */ FName ComponentName;
};

// Size: 0x14
struct FConstraintBaseParams {
    /* 0x0000 */ float Stiffness;
    /* 0x0004 */ float Damping;
    /* 0x0008 */ float Restitution;
    /* 0x000c */ float ContactDistance;
    /* 0x0010 */ bool bSoftConstraint;
};

// Size: 0x10
struct FConstraintDrive {
    /* 0x0000 */ float Stiffness;
    /* 0x0004 */ float Damping;
    /* 0x0008 */ float MaxForce;
    /* 0x000c */ bool bEnablePositionDrive;
    /* 0x000c */ bool bEnableVelocityDrive;
};

// Size: 0x288
struct FConstraintInstance : public FConstraintInstanceBase {
    /* 0x0048 */ FName JointName;
    /* 0x0050 */ FName ConstraintBone1;
    /* 0x0058 */ FName ConstraintBone2;
    /* 0x0068 */ FVector Pos1;
    /* 0x0080 */ FVector PriAxis1;
    /* 0x0098 */ FVector SecAxis1;
    /* 0x00b0 */ FVector Pos2;
    /* 0x00c8 */ FVector PriAxis2;
    /* 0x00e0 */ FVector SecAxis2;
    /* 0x00f8 */ FRotator AngularRotationOffset;
    /* 0x0110 */ bool bScaleLinearLimits;
    /* 0x0118 */ FConstraintProfileProperties ProfileInstance;
};

// Size: 0xc
struct FConstraintInstanceAccessor {
    /* 0x0000 */ TWeakObjectPtr<UObject> Owner;
    /* 0x0008 */ uint32_t Index;
};

// Size: 0x48
struct FConstraintInstanceBase {
};

// Size: 0x28
class UConstraintInstanceBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void CopyParams(FConstraintInstanceAccessor& Accessor, FConstraintInstanceAccessor& SourceAccessor, bool bKeepPosition, bool bKeepRotation);
    static void GetAngularBreakable(FConstraintInstanceAccessor& Accessor, bool& bAngularBreakable, float& AngularBreakThreshold);
    static void GetAngularDriveMode(FConstraintInstanceAccessor& Accessor, uint8_t& OutDriveMode);
    static void GetAngularDriveParams(FConstraintInstanceAccessor& Accessor, float& OutPositionStrength, float& OutVelocityStrength, float& OutForceLimit);
    static void GetAngularLimits(FConstraintInstanceAccessor& Accessor, uint8_t& Swing1MotionType, float& Swing1LimitAngle, uint8_t& Swing2MotionType, float& Swing2LimitAngle, uint8_t& TwistMotionType, float& TwistLimitAngle);
    static void GetAngularOrientationTarget(FConstraintInstanceAccessor& Accessor, FRotator& OutPosTarget);
    static void GetAngularPlasticity(FConstraintInstanceAccessor& Accessor, bool& bAngularPlasticity, float& AngularPlasticityThreshold);
    static void GetAngularSoftSwingLimitParams(FConstraintInstanceAccessor& Accessor, bool& bSoftSwingLimit, float& SwingLimitStiffness, float& SwingLimitDamping, float& SwingLimitRestitution, float& SwingLimitContactDistance);
    static void GetAngularSoftTwistLimitParams(FConstraintInstanceAccessor& Accessor, bool& bSoftTwistLimit, float& TwistLimitStiffness, float& TwistLimitDamping, float& TwistLimitRestitution, float& TwistLimitContactDistance);
    static void GetAngularVelocityDriveSLERP(FConstraintInstanceAccessor& Accessor, bool& bOutEnableSLERP);
    static void GetAngularVelocityDriveTwistAndSwing(FConstraintInstanceAccessor& Accessor, bool& bOutEnableTwistDrive, bool& bOutEnableSwingDrive);
    static void GetAngularVelocityTarget(FConstraintInstanceAccessor& Accessor, FVector& OutVelTarget);
    static void GetAttachedBodyNames(FConstraintInstanceAccessor& Accessor, FName& ParentBody, FName& ChildBody);
    static void GetContactTransferScale(FConstraintInstanceAccessor& Accessor, float& ContactTransferScale);
    static bool GetDisableCollsion(FConstraintInstanceAccessor& Accessor);
    static void GetLinearBreakable(FConstraintInstanceAccessor& Accessor, bool& bLinearBreakable, float& LinearBreakThreshold);
    static void GetLinearDriveParams(FConstraintInstanceAccessor& Accessor, float& OutPositionStrength, float& OutVelocityStrength, float& OutForceLimit);
    static void GetLinearLimits(FConstraintInstanceAccessor& Accessor, uint8_t& XMotion, uint8_t& YMotion, uint8_t& ZMotion, float& Limit);
    static void GetLinearPlasticity(FConstraintInstanceAccessor& Accessor, bool& bLinearPlasticity, float& LinearPlasticityThreshold, uint8_t& PlasticityType);
    static void GetLinearPositionDrive(FConstraintInstanceAccessor& Accessor, bool& bOutEnableDriveX, bool& bOutEnableDriveY, bool& bOutEnableDriveZ);
    static void GetLinearPositionTarget(FConstraintInstanceAccessor& Accessor, FVector& OutPosTarget);
    static void GetLinearSoftLimitParams(FConstraintInstanceAccessor& Accessor, bool& bSoftLinearLimit, float& LinearLimitStiffness, float& LinearLimitDamping, float& LinearLimitRestitution, float& LinearLimitContactDistance);
    static void GetLinearVelocityDrive(FConstraintInstanceAccessor& Accessor, bool& bOutEnableDriveX, bool& bOutEnableDriveY, bool& bOutEnableDriveZ);
    static void GetLinearVelocityTarget(FConstraintInstanceAccessor& Accessor, FVector& OutVelTarget);
    static bool GetMassConditioningEnabled(FConstraintInstanceAccessor& Accessor);
    static void GetOrientationDriveSLERP(FConstraintInstanceAccessor& Accessor, bool& bOutEnableSLERP);
    static void GetOrientationDriveTwistAndSwing(FConstraintInstanceAccessor& Accessor, bool& bOutEnableTwistDrive, bool& bOutEnableSwingDrive);
    static bool GetParentDominates(FConstraintInstanceAccessor& Accessor);
    static void GetProjectionParams(FConstraintInstanceAccessor& Accessor, bool& bEnableProjection, float& ProjectionLinearAlpha, float& ProjectionAngularAlpha);
    static void SetAngularBreakable(FConstraintInstanceAccessor& Accessor, bool bAngularBreakable, float AngularBreakThreshold);
    static void SetAngularDriveMode(FConstraintInstanceAccessor& Accessor, uint8_t DriveMode);
    static void SetAngularDriveParams(FConstraintInstanceAccessor& Accessor, float PositionStrength, float VelocityStrength, float InForceLimit);
    static void SetAngularLimits(FConstraintInstanceAccessor& Accessor, uint8_t Swing1MotionType, float Swing1LimitAngle, uint8_t Swing2MotionType, float Swing2LimitAngle, uint8_t TwistMotionType, float TwistLimitAngle);
    static void SetAngularOrientationTarget(FConstraintInstanceAccessor& Accessor, const FRotator& InPosTarget);
    static void SetAngularPlasticity(FConstraintInstanceAccessor& Accessor, bool bAngularPlasticity, float AngularPlasticityThreshold);
    static void SetAngularSoftSwingLimitParams(FConstraintInstanceAccessor& Accessor, bool bSoftSwingLimit, float SwingLimitStiffness, float SwingLimitDamping, float SwingLimitRestitution, float SwingLimitContactDistance);
    static void SetAngularSoftTwistLimitParams(FConstraintInstanceAccessor& Accessor, bool bSoftTwistLimit, float TwistLimitStiffness, float TwistLimitDamping, float TwistLimitRestitution, float TwistLimitContactDistance);
    static void SetAngularVelocityDriveSLERP(FConstraintInstanceAccessor& Accessor, bool bEnableSLERP);
    static void SetAngularVelocityDriveTwistAndSwing(FConstraintInstanceAccessor& Accessor, bool bEnableTwistDrive, bool bEnableSwingDrive);
    static void SetAngularVelocityTarget(FConstraintInstanceAccessor& Accessor, const FVector& InVelTarget);
    static void SetContactTransferScale(FConstraintInstanceAccessor& Accessor, float ContactTransferScale);
    static void SetDisableCollision(FConstraintInstanceAccessor& Accessor, bool bDisableCollision);
    static void SetLinearBreakable(FConstraintInstanceAccessor& Accessor, bool bLinearBreakable, float LinearBreakThreshold);
    static void SetLinearDriveParams(FConstraintInstanceAccessor& Accessor, float PositionStrength, float VelocityStrength, float InForceLimit);
    static void SetLinearLimits(FConstraintInstanceAccessor& Accessor, uint8_t XMotion, uint8_t YMotion, uint8_t ZMotion, float Limit);
    static void SetLinearPlasticity(FConstraintInstanceAccessor& Accessor, bool bLinearPlasticity, float LinearPlasticityThreshold, uint8_t PlasticityType);
    static void SetLinearPositionDrive(FConstraintInstanceAccessor& Accessor, bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
    static void SetLinearPositionTarget(FConstraintInstanceAccessor& Accessor, const FVector& InPosTarget);
    static void SetLinearSoftLimitParams(FConstraintInstanceAccessor& Accessor, bool bSoftLinearLimit, float LinearLimitStiffness, float LinearLimitDamping, float LinearLimitRestitution, float LinearLimitContactDistance);
    static void SetLinearVelocityDrive(FConstraintInstanceAccessor& Accessor, bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
    static void SetLinearVelocityTarget(FConstraintInstanceAccessor& Accessor, const FVector& InVelTarget);
    static void SetMassConditioningEnabled(FConstraintInstanceAccessor& Accessor, bool bEnableMassConditioning);
    static void SetOrientationDriveSLERP(FConstraintInstanceAccessor& Accessor, bool bEnableSLERP);
    static void SetOrientationDriveTwistAndSwing(FConstraintInstanceAccessor& Accessor, bool bEnableTwistDrive, bool bEnableSwingDrive);
    static void SetParentDominates(FConstraintInstanceAccessor& Accessor, bool bParentDominates);
    static void SetProjectionParams(FConstraintInstanceAccessor& Accessor, bool bEnableProjection, float ProjectionLinearAlpha, float ProjectionAngularAlpha);
};

// Size: 0x160
struct FConstraintProfileProperties {
    /* 0x0000 */ float ProjectionLinearTolerance;
    /* 0x0004 */ float ProjectionAngularTolerance;
    /* 0x0008 */ float ProjectionLinearAlpha;
    /* 0x000c */ float ProjectionAngularAlpha;
    /* 0x0010 */ float ShockPropagationAlpha;
    /* 0x0014 */ float LinearBreakThreshold;
    /* 0x0018 */ float LinearPlasticityThreshold;
    /* 0x001c */ float AngularBreakThreshold;
    /* 0x0020 */ float AngularPlasticityThreshold;
    /* 0x0024 */ float ContactTransferScale;
    /* 0x0028 */ FLinearConstraint LinearLimit;
    /* 0x0044 */ FConeConstraint ConeLimit;
    /* 0x0064 */ FTwistConstraint TwistLimit;
    /* 0x0080 */ bool bDisableCollision;
    /* 0x0080 */ bool bParentDominates;
    /* 0x0080 */ bool bEnableShockPropagation;
    /* 0x0080 */ bool bEnableProjection;
    /* 0x0080 */ bool bEnableMassConditioning;
    /* 0x0080 */ bool bUseLinearJointSolver;
    /* 0x0080 */ bool bAngularBreakable;
    /* 0x0080 */ bool bAngularPlasticity;
    /* 0x0081 */ bool bLinearBreakable;
    /* 0x0081 */ bool bLinearPlasticity;
    /* 0x0088 */ FLinearDriveConstraint LinearDrive;
    /* 0x00f0 */ FAngularDriveConstraint AngularDrive;
    /* 0x0158 */ uint8_t LinearPlasticityType;
};

// Size: 0x1
struct FContainerPropertyOverride {
};

// Size: 0x50
class UContentBundleDescriptor : public UObject {
    /* 0x0028 */ FString DisplayName;
    /* 0x0038 */ FColor DebugColor;
    /* 0x003c */ FGuid Guid;
};

// Size: 0x28
class UContentBundleDuplicateForPIEHelper : public UObject {
};

// Size: 0xd0
class UContentBundleEngineSubsystem : public UEngineSubsystem {
    /* 0x00a0 */ TSoftClassPtr<UContentBundleTypeFactory> ContentBundleTypeFactoryClass;
    /* 0x00c8 */ UContentBundleTypeFactory* ContentBundleTypeFactory;
};

// Size: 0x38
class UContentBundleManager : public UObject {
};

// Size: 0x28
class UContentBundleTypeFactory : public UObject {
};

// Size: 0x28
class UContentBundleUnsavedActorMonitor : public UObject {
};

// Size: 0x80
class UControlChannel : public UChannel {
};

// Size: 0x340
class AController : public AActor {
    /* 0x02b0 */ APlayerState* PlayerState;
    /* 0x02c0 */ FMulticastInlineDelegate OnInstigatedAnyDamage;
    /* 0x02d0 */ FMulticastInlineDelegate OnPossessedPawnChanged;
    /* 0x02e0 */ FName StateName;
    /* 0x02e8 */ APawn* Pawn;
    /* 0x02f8 */ ACharacter* Character;
    /* 0x0300 */ USceneComponent* TransformComponent;
    /* 0x0320 */ FRotator ControlRotation;
    /* 0x0338 */ bool bAttachToPawn;

    void ClientSetLocation(FVector NewLocation, FRotator NewRotation);
    void ClientSetRotation(FRotator NewRotation, bool bResetCamera);
    FRotator GetControlRotation() const;
    FRotator GetDesiredRotation() const;
    void GetPlayerViewPoint(FVector& Location, FRotator& Rotation) const;
    AActor* GetViewTarget() const;
    bool IsLocalController() const;
    bool IsLocalPlayerController() const;
    bool IsLookInputIgnored() const;
    bool IsMoveInputIgnored() const;
    bool IsPlayerController() const;
    APawn* K2_GetPawn() const;
    bool LineOfSightTo(const AActor* Other, FVector ViewPoint, bool bAlternateChecks) const;
    void OnRep_Pawn();
    void OnRep_PlayerState();
    void Possess(APawn* InPawn);
    void ReceiveInstigatedAnyDamage(float Damage, const UDamageType* DamageType, AActor* DamagedActor, AActor* DamageCauser);
    void ReceivePossess(APawn* PossessedPawn);
    void ReceiveUnPossess(APawn* UnpossessedPawn);
    void ResetIgnoreInputFlags();
    void ResetIgnoreLookInput();
    void ResetIgnoreMoveInput();
    void SetControlRotation(const FRotator& NewRotation);
    void SetIgnoreLookInput(bool bNewLookInput);
    void SetIgnoreMoveInput(bool bNewMoveInput);
    void SetInitialLocationAndRotation(const FVector& NewLocation, const FRotator& NewRotation);
    void StopMovement();
    void UnPossess();
};

// Size: 0x30
struct FConvolutionBloomSettings {
    /* 0x0000 */ UTexture2D* Texture;
    /* 0x0008 */ float ScatterDispersion;
    /* 0x000c */ float Size;
    /* 0x0010 */ FVector2D CenterUV;
    /* 0x0020 */ float PreFilterMin;
    /* 0x0024 */ float PreFilterMax;
    /* 0x0028 */ float PreFilterMult;
    /* 0x002c */ float BufferScale;
};

// Size: 0x8
struct FCullDistanceSizePair {
    /* 0x0000 */ float Size;
    /* 0x0004 */ float CullDistance;
};

// Size: 0x2f8
class ACullDistanceVolume : public AVolume {
    /* 0x02e0 */ TArray<FCullDistanceSizePair> CullDistances;
    /* 0x02f0 */ bool bEnabled;
};

// Size: 0x24
struct FCurveAtlasColorAdjustments {
    /* 0x0000 */ bool bChromaKeyTexture;
    /* 0x0004 */ float AdjustBrightness;
    /* 0x0008 */ float AdjustBrightnessCurve;
    /* 0x000c */ float AdjustVibrance;
    /* 0x0010 */ float AdjustSaturation;
    /* 0x0014 */ float AdjustRGBCurve;
    /* 0x0018 */ float AdjustHue;
    /* 0x001c */ float AdjustMinAlpha;
    /* 0x0020 */ float AdjustMaxAlpha;
};

// Size: 0x30
class UCurveBase : public UObject {

    void GetTimeRange(float& MinTime, float& MaxTime) const;
    void GetValueRange(float& MinValue, float& MaxValue) const;
};

// Size: 0x38
struct FCurveEdEntry {
    /* 0x0000 */ UObject* CurveObject;
    /* 0x0008 */ FColor CurveColor;
    /* 0x0010 */ FString CurveName;
    /* 0x0020 */ int32_t bHideCurve;
    /* 0x0024 */ int32_t bColorCurve;
    /* 0x0028 */ int32_t bFloatingPointColorCurve;
    /* 0x002c */ int32_t bClamp;
    /* 0x0030 */ float ClampLow;
    /* 0x0034 */ float ClampHigh;
};

// Size: 0x28
class UCurveEdPresetCurve : public UObject {
};

// Size: 0x30
struct FCurveEdTab {
    /* 0x0000 */ FString TabName;
    /* 0x0010 */ TArray<FCurveEdEntry> Curves;
    /* 0x0020 */ float ViewStartInput;
    /* 0x0024 */ float ViewEndInput;
    /* 0x0028 */ float ViewStartOutput;
    /* 0x002c */ float ViewEndOutput;
};

// Size: 0x10
struct FCurveFlagsChangedPayload : public FCurvePayload {
    /* 0x000c */ int32_t OldFlags;
};

// Size: 0xb8
class UCurveFloat : public UCurveBase {
    /* 0x0030 */ FRichCurve FloatCurve;
    /* 0x00b0 */ bool bIsEventCurve;

    float GetFloatValue(float InTime) const;
};

// Size: 0x250
class UCurveLinearColor : public UCurveBase {
    /* 0x0030 */ FRichCurve FloatCurves[4];
    /* 0x0230 */ float AdjustHue;
    /* 0x0234 */ float AdjustSaturation;
    /* 0x0238 */ float AdjustBrightness;
    /* 0x023c */ float AdjustBrightnessCurve;
    /* 0x0240 */ float AdjustVibrance;
    /* 0x0244 */ float AdjustMinAlpha;
    /* 0x0248 */ float AdjustMaxAlpha;

    FLinearColor GetClampedLinearColorValue(float InTime) const;
    FLinearColor GetLinearColorValue(float InTime) const;
    FLinearColor GetUnadjustedLinearColorValue(float InTime) const;
};

// Size: 0x180
class UCurveLinearColorAtlas : public UTexture2D {
    /* 0x0160 */ uint32_t TextureSize;
    /* 0x0164 */ bool bSquareResolution;
    /* 0x0168 */ uint32_t TextureHeight;
    /* 0x0170 */ TArray<UCurveLinearColor*> GradientCurves;

    bool GetCurvePosition(UCurveLinearColor* InCurve, float& position);
};

// Size: 0x18
struct FCurveMetaData {
    /* 0x0000 */ TArray<FBoneReference> LinkedBones;
    /* 0x0010 */ uint8_t MaxLOD;
    /* 0x0011 */ FAnimCurveType Type;
};

// Size: 0xc
struct FCurvePayload : public FEmptyPayload {
    /* 0x0000 */ FAnimationCurveIdentifier Identifier;
};

// Size: 0x18
struct FCurveRenamedPayload : public FCurvePayload {
    /* 0x000c */ FAnimationCurveIdentifier NewIdentifier;
};

// Size: 0x14
struct FCurveScaledPayload : public FCurvePayload {
    /* 0x000c */ float Factor;
    /* 0x0010 */ float Origin;
};

// Size: 0x28
class ICurveSourceInterface : public UInterface {

    FName GetBindingName() const;
    float GetCurveValue(FName CurveName) const;
    void GetCurves(TArray<FNamedCurveValue>& OutValues) const;
};

// Size: 0xa0
class UCurveTable : public UObject {
};

// Size: 0x10
struct FCurveTableRowHandle {
    /* 0x0000 */ UCurveTable* CurveTable;
    /* 0x0008 */ FName RowName;
};

// Size: 0x18
struct FCurveTrack {
    /* 0x0000 */ FName CurveName;
    /* 0x0008 */ TArray<float> CurveWeights;
};

// Size: 0x1b0
class UCurveVector : public UCurveBase {
    /* 0x0030 */ FRichCurve FloatCurves[3];

    FVector GetVectorValue(float InTime) const;
};

// Size: 0x1
struct FCustomAttribute {
};

// Size: 0x1
struct FCustomAttributePerBoneData {
};

// Size: 0x20
struct FCustomAttributeSetting {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Meaning;
};

// Size: 0xc
struct FCustomChannelSetup {
    /* 0x0000 */ uint8_t Channel;
    /* 0x0001 */ uint8_t DefaultResponse;
    /* 0x0002 */ bool bTraceType;
    /* 0x0003 */ bool bStaticObject;
    /* 0x0004 */ FName Name;
};

// Size: 0x20
struct FCustomDefine {
    /* 0x0000 */ FString DefineName;
    /* 0x0010 */ FString DefineValue;
};

// Size: 0x30
struct FCustomInput {
    /* 0x0000 */ FName InputName;
    /* 0x0008 */ FExpressionInput Input;
};

// Size: 0xc
struct FCustomOutput {
    /* 0x0000 */ FName OutputName;
    /* 0x0008 */ uint8_t OutputType;
};

// Size: 0x10
struct FCustomPrimitiveData {
    /* 0x0000 */ TArray<float> Data;
};

// Size: 0x18
struct FCustomProfile {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ TArray<FResponseChannel> CustomResponses;
};

enum class CylinderHeightAxis {
    PMLPC_HEIGHTAXIS_X = 0,
    PMLPC_HEIGHTAXIS_Y = 1,
    PMLPC_HEIGHTAXIS_Z = 2,
    PMLPC_HEIGHTAXIS_MAX = 3,
};

// Size: 0x28
class UDPICustomScalingRule : public UObject {
};

// Size: 0x28
struct FDPMatchingIfCondition {
    /* 0x0000 */ FName Operator;
    /* 0x0008 */ FString Arg1;
    /* 0x0018 */ FString Arg2;
};

// Size: 0x68
struct FDPMatchingRulestruct : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructE> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructE> OnFalse;
};

// Size: 0x68
struct FDPMatchingRulestructA : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructBase> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructBase> OnFalse;
};

// Size: 0x68
struct FDPMatchingRulestructB : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructA> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructA> OnFalse;
};

// Size: 0x48
struct FDPMatchingRulestructBase {
    /* 0x0008 */ FString RuleName;
    /* 0x0018 */ TArray<FDPMatchingIfCondition> IfConditions;
    /* 0x0028 */ FString AppendFragments;
    /* 0x0038 */ FString SetUserVar;
};

// Size: 0x68
struct FDPMatchingRulestructC : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructB> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructB> OnFalse;
};

// Size: 0x68
struct FDPMatchingRulestructD : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructC> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructC> OnFalse;
};

// Size: 0x68
struct FDPMatchingRulestructE : public FDPMatchingRulestructBase {
    /* 0x0048 */ TArray<FDPMatchingRulestructD> OnTrue;
    /* 0x0058 */ TArray<FDPMatchingRulestructD> OnFalse;
};

// Size: 0x10
struct FDamageEvent {
    /* 0x0008 */ UClass* DamageTypeClass;
};

// Size: 0x40
class UDamageType : public UObject {
    /* 0x0028 */ bool bCausedByWorld;
    /* 0x0028 */ bool bScaleMomentumByMass;
    /* 0x0028 */ bool bRadialDamageVelChange;
    /* 0x002c */ float DamageImpulse;
    /* 0x0030 */ float DestructibleImpulse;
    /* 0x0034 */ float DestructibleDamageSpreadScale;
    /* 0x0038 */ float DamageFalloff;
};

// Size: 0x30
class UDataAsset : public UObject {
    /* 0x0028 */ UClass* NativeClass;
};

// Size: 0x10
struct FDataCacheDuplicatedObjectData {
};

// Size: 0x40
class UDataDrivenCVarEngineSubsystem : public UEngineSubsystem {
    /* 0x0030 */ FMulticastInlineDelegate OnDataDrivenCVarDelegate;

    void OnDataDrivenCVarChanged__DelegateSignature(FString CVarName);
};

// Size: 0x60
struct FDataDrivenConsoleVariable {
    /* 0x0000 */ FDataDrivenCVarType Type;
    /* 0x0008 */ FString Name;
    /* 0x0018 */ FString Tooltip;
    /* 0x0028 */ float DefaultValueFloat;
    /* 0x002c */ int32_t DefaultValueInt;
    /* 0x0030 */ bool DefaultValueBool;
};

// Size: 0x70
class UDataDrivenConsoleVariableSettings : public UDeveloperSettings {
    /* 0x0050 */ TArray<FDataDrivenConsoleVariable> CVarsArray;
};

// Size: 0xc
struct FDataDrivenShaderPlatformInfoInput {
    /* 0x0000 */ FName InputName;
    /* 0x0008 */ uint8_t PropertyCondition;
};

// Size: 0x58
class UDataLayer : public UObject {
    /* 0x0028 */ FName DataLayerLabel;
    /* 0x0030 */ bool bIsRuntime;
    /* 0x0034 */ EDataLayerRuntimeState InitialRuntimeState;
    /* 0x0038 */ FColor DebugColor;
    /* 0x0040 */ UDataLayer* Parent;
    /* 0x0048 */ TArray<UDataLayer*> Children;

    bool Equals(const FActorDataLayer& ActorDataLayer) const;
    FName GetDataLayerLabel() const;
    FColor GetDebugColor() const;
    EDataLayerRuntimeState GetInitialRuntimeState() const;
    EDataLayerState GetInitialState() const;
    bool IsDynamicallyLoaded() const;
    bool IsEffectiveVisible() const;
    bool IsInitiallyActive() const;
    bool IsInitiallyVisible() const;
    bool IsRuntime() const;
    bool IsVisible() const;
};

// Size: 0x40
class UDataLayerAsset : public UDataAsset {
    /* 0x0030 */ EDataLayerType DataLayerType;
    /* 0x0031 */ bool bSupportsActorFilters;
    /* 0x0034 */ FColor DebugColor;
    /* 0x0038 */ EDataLayerLoadFilter LoadFilter;

    FColor GetDebugColor() const;
    EDataLayerType GetType() const;
    bool IsClientOnly() const;
    bool IsRuntime() const;
    bool IsServerOnly() const;
};

// Size: 0x48
class UDataLayerInstance : public UObject {
    /* 0x0028 */ EDataLayerRuntimeState InitialRuntimeState;
    /* 0x0030 */ UDataLayerInstance* Parent;
    /* 0x0038 */ TArray<UDataLayerInstance*> Children;

    UDataLayerAsset* GetAsset() const;
    FString GetDataLayerFullName() const;
    FString GetDataLayerShortName() const;
    FColor GetDebugColor() const;
    EDataLayerRuntimeState GetInitialRuntimeState() const;
    EDataLayerType GetType() const;
    bool IsClientOnly() const;
    bool IsEffectiveVisible() const;
    bool IsInitiallyVisible() const;
    bool IsRuntime() const;
    bool IsServerOnly() const;
    bool IsVisible() const;
};

// Size: 0x18
struct FDataLayerInstanceNames {
    /* 0x0000 */ bool bIsFirstDataLayerExternal;
    /* 0x0008 */ TArray<FName> DataLayers;
};

// Size: 0x60
class UDataLayerInstancePrivate : public UDataLayerInstance {
    /* 0x0048 */ FString ShortName;
    /* 0x0058 */ UDataLayerAsset* DataLayerAsset;
};

// Size: 0x28
class IDataLayerInstanceProvider : public UInterface {
};

// Size: 0x50
class UDataLayerInstanceWithAsset : public UDataLayerInstance {
    /* 0x0048 */ UDataLayerAsset* DataLayerAsset;
};

// Size: 0x28
class UDataLayerLoadingPolicy : public UObject {
};

// Size: 0x88
class UDataLayerManager : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnDataLayerInstanceRuntimeStateChanged;

    EDataLayerRuntimeState GetDataLayerInstanceEffectiveRuntimeState(const UDataLayerInstance* InDataLayerInstance) const;
    UDataLayerInstance* GetDataLayerInstanceFromAsset(const UDataLayerAsset* InDataLayerAsset) const;
    UDataLayerInstance* GetDataLayerInstanceFromName(const FName& InDataLayerInstanceName) const;
    EDataLayerRuntimeState GetDataLayerInstanceRuntimeState(const UDataLayerInstance* InDataLayerInstance) const;
    TArray<UDataLayerInstance*> GetDataLayerInstances() const;
    bool SetDataLayerInstanceRuntimeState(const UDataLayerInstance* InDataLayerInstance, EDataLayerRuntimeState InState, bool bInIsRecursive);
    bool SetDataLayerRuntimeState(const UDataLayerAsset* InDataLayerAsset, EDataLayerRuntimeState InState, bool bInIsRecursive);
};

// Size: 0x68
class UDataLayerSubsystem : public UWorldSubsystem {
    /* 0x0030 */ FMulticastInlineDelegate OnDataLayerRuntimeStateChanged;
    /* 0x0040 */ TSoftClassPtr<UDataLayerLoadingPolicy> DataLayerLoadingPolicyClass;

    TSet<FName> GetActiveDataLayerNames() const;
    UDataLayerInstance* GetDataLayer(const FActorDataLayer& InDataLayer) const;
    EDataLayerRuntimeState GetDataLayerEffectiveRuntimeState(const FActorDataLayer& InDataLayer) const;
    EDataLayerRuntimeState GetDataLayerEffectiveRuntimeStateByLabel(const FName& InDataLayerLabel) const;
    UDataLayerInstance* GetDataLayerFromLabel(FName InDataLayerLabel) const;
    UDataLayerInstance* GetDataLayerFromName(FName InDataLayerName) const;
    EDataLayerRuntimeState GetDataLayerInstanceEffectiveRuntimeState(const UDataLayerAsset* InDataLayerAsset) const;
    UDataLayerInstance* GetDataLayerInstanceFromAsset(const UDataLayerAsset* InDataLayerAsset) const;
    EDataLayerRuntimeState GetDataLayerInstanceRuntimeState(const UDataLayerAsset* InDataLayerAsset) const;
    EDataLayerRuntimeState GetDataLayerRuntimeState(const FActorDataLayer& InDataLayer) const;
    EDataLayerRuntimeState GetDataLayerRuntimeStateByLabel(const FName& InDataLayerLabel) const;
    EDataLayerState GetDataLayerState(const FActorDataLayer& InDataLayer) const;
    EDataLayerState GetDataLayerStateByLabel(const FName& InDataLayerLabel) const;
    TSet<FName> GetLoadedDataLayerNames() const;
    void SetDataLayerInstanceRuntimeState(const UDataLayerAsset* InDataLayerAsset, EDataLayerRuntimeState InState, bool bInIsRecursive);
    void SetDataLayerRuntimeState(const FActorDataLayer& InDataLayer, EDataLayerRuntimeState InState, bool bInIsRecursive);
    void SetDataLayerRuntimeStateByLabel(const FName& InDataLayerLabel, EDataLayerRuntimeState InState, bool bInIsRecursive);
    void SetDataLayerState(const FActorDataLayer& InDataLayer, EDataLayerState InState);
    void SetDataLayerStateByLabel(const FName& InDataLayerLabel, EDataLayerState InState);
};

// Size: 0x2098
class UDataStreamChannel : public UChannel {
};

// Size: 0xb0
class UDataTable : public UObject {
    /* 0x0028 */ UScriptStruct* RowStruct;
    /* 0x0080 */ bool bStripFromClientBuilds;
    /* 0x0080 */ bool bIgnoreExtraFields;
    /* 0x0080 */ bool bIgnoreMissingFields;
    /* 0x0080 */ bool bPreserveExistingValues;
    /* 0x0088 */ FString ImportKeyField;
};

// Size: 0x18
struct FDataTableCategoryHandle {
    /* 0x0000 */ UDataTable* DataTable;
    /* 0x0008 */ FName ColumnName;
    /* 0x0010 */ FName RowContents;
};

// Size: 0x28
class UDataTableFunctionLibrary : public UBlueprintFunctionLibrary {

    static bool DoesDataTableRowExist(const UDataTable* Table, FName RowName);
    static void EvaluateCurveTableRow(UCurveTable* CurveTable, FName RowName, float InXY, uint8_t& OutResult, float& OutXY, FString ContextString);
    static TArray<FString> GetDataTableColumnAsString(const UDataTable* DataTable, FName PropertyName);
    static void GetDataTableColumnExportNames(const UDataTable* Table, TArray<FString>& OutExportColumnNames);
    static bool GetDataTableColumnNameFromExportName(const UDataTable* Table, FString ColumnExportName, FName& OutColumnName);
    static void GetDataTableColumnNames(const UDataTable* Table, TArray<FName>& OutColumnNames);
    static bool GetDataTableRowFromName(UDataTable* Table, FName RowName, FTableRowBase& OutRow);
    static void GetDataTableRowNames(const UDataTable* Table, TArray<FName>& OutRowNames);
    static UScriptStruct* GetDataTableRowStruct(const UDataTable* Table);
};

// Size: 0x10
struct FDataTableRowHandle {
    /* 0x0000 */ UDataTable* DataTable;
    /* 0x0008 */ FName RowName;
};

// Size: 0x8d0
class ADebugCameraController : public APlayerController {
    /* 0x0738 */ bool bShowSelectedInfo;
    /* 0x0738 */ bool bIsFrozenRendering;
    /* 0x0738 */ bool bIsOrbitingSelectedActor;
    /* 0x0738 */ bool bOrbitPivotUseCenter;
    /* 0x0738 */ bool bEnableBufferVisualization;
    /* 0x0738 */ bool bEnableBufferVisualizationFullMode;
    /* 0x0738 */ bool bIsBufferVisualizationInputSetup;
    /* 0x0738 */ bool bLastDisplayEnabled;
    /* 0x0740 */ UDrawFrustumComponent* DrawFrustum;
    /* 0x0748 */ TWeakObjectPtr<AActor> SelectedActor;
    /* 0x0750 */ TWeakObjectPtr<UPrimitiveComponent> SelectedComponent;
    /* 0x0758 */ FHitResult SelectedHitPoint;
    /* 0x0858 */ APlayerController* OriginalControllerRef;
    /* 0x0860 */ UPlayer* OriginalPlayer;
    /* 0x0868 */ float SpeedScale;
    /* 0x086c */ float InitialMaxSpeed;
    /* 0x0870 */ float InitialAccel;
    /* 0x0874 */ float InitialDecel;

    AActor* GetSelectedActor() const;
    void ReceiveOnActivate(APlayerController* OriginalPC);
    void ReceiveOnActorSelected(AActor* NewSelectedActor, const FVector& SelectHitLocation, const FVector& SelectHitNormal, const FHitResult& Hit);
    void ReceiveOnDeactivate(APlayerController* RestoredPC);
    void SetPawnMovementSpeedScale(float NewSpeedScale);
    void ShowDebugSelectedInfo();
    void ToggleDisplay();
};

// Size: 0x48
class UDebugCameraControllerSettings : public UDeveloperSettings {
    /* 0x0038 */ TArray<FDebugCameraControllerSettingsViewModeIndex> CycleViewModes;
};

// Size: 0x10
struct FDebugCameraControllerSettingsViewModeIndex {
    /* 0x0008 */ uint8_t ViewModeIndex;
};

// Size: 0x398
class ADebugCameraHUD : public AHUD {
};

// Size: 0x20
struct FDebugDisplayProperty {
    /* 0x0000 */ UObject* Obj;
    /* 0x0008 */ UClass* WithinClass;
};

// Size: 0x580
class UDebugDrawComponent : public UPrimitiveComponent {
};

// Size: 0x28
class UDebugDrawService : public UBlueprintFunctionLibrary {
};

// Size: 0x20
struct FDebugFloatHistory {
    /* 0x0000 */ TArray<float> Samples;
    /* 0x0010 */ int32_t MaxSamples;
    /* 0x0014 */ float MinValue;
    /* 0x0018 */ float MaxValue;
    /* 0x001c */ bool bAutoAdjustMinMax;
};

// Size: 0x48
class UDebugGarbageCollectionGraph : public UObject {
};

// Size: 0x80
struct FDebugTextInfo {
    /* 0x0000 */ AActor* SrcActor;
    /* 0x0008 */ FVector SrcActorOffset;
    /* 0x0020 */ FVector SrcActorDesiredOffset;
    /* 0x0038 */ FString DebugText;
    /* 0x0048 */ float TimeRemaining;
    /* 0x004c */ float Duration;
    /* 0x0050 */ FColor TextColor;
    /* 0x0054 */ bool bAbsoluteLocation;
    /* 0x0054 */ bool bKeepAttachedToActor;
    /* 0x0054 */ bool bDrawShadow;
    /* 0x0058 */ FVector OrigActorLocation;
    /* 0x0070 */ UFont* Font;
    /* 0x0078 */ float FontScale;
};

// Size: 0x190
struct FDebuggingInfoForSingleFunction {
};

// Size: 0x2b0
class ADecalActor : public AActor {
    /* 0x02a8 */ UDecalComponent* Decal;

    UMaterialInstanceDynamic* CreateDynamicMaterialInstance();
    UMaterialInterface* GetDecalMaterial() const;
    void SetDecalMaterial(UMaterialInterface* NewDecalMaterial);
};

// Size: 0x2b0
class UDecalComponent : public USceneComponent {
    /* 0x0240 */ UMaterialInterface* DecalMaterial;
    /* 0x0248 */ int32_t SortOrder;
    /* 0x024c */ float FadeScreenSize;
    /* 0x0250 */ float FadeStartDelay;
    /* 0x0254 */ float FadeDuration;
    /* 0x0258 */ float FadeInDuration;
    /* 0x025c */ float FadeInStartDelay;
    /* 0x0260 */ bool bDestroyOwnerAfterFade;
    /* 0x0268 */ FVector DecalSize;
    /* 0x0280 */ FLinearColor DecalColor;

    UMaterialInstanceDynamic* CreateDynamicMaterialInstance();
    UMaterialInterface* GetDecalMaterial() const;
    float GetFadeDuration() const;
    float GetFadeInDuration() const;
    float GetFadeInStartDelay() const;
    float GetFadeStartDelay() const;
    void SetDecalColor(const FLinearColor& Color);
    void SetDecalMaterial(UMaterialInterface* NewDecalMaterial);
    void SetFadeIn(float StartDelay, float Duration);
    void SetFadeOut(float StartDelay, float Duration, bool DestroyOwnerAfterFade);
    void SetFadeScreenSize(float NewFadeScreenSize);
    void SetSortOrder(int32_t Value);
};

// Size: 0x20
struct FDefaultAudioBusSettings {
    /* 0x0000 */ FSoftObjectPath AudioBus;
};

// Size: 0x350
class ADefaultPawn : public APawn {
    /* 0x0328 */ float BaseTurnRate;
    /* 0x032c */ float BaseLookUpRate;
    /* 0x0330 */ UPawnMovementComponent* MovementComponent;
    /* 0x0338 */ USphereComponent* CollisionComponent;
    /* 0x0340 */ UStaticMeshComponent* MeshComponent;
    /* 0x0348 */ bool bAddDefaultMovementBindings;

    void LookUpAtRate(float Rate);
    void MoveForward(float val);
    void MoveRight(float val);
    void MoveUp_World(float val);
    void TurnAtRate(float Rate);
};

// Size: 0x28
class UDefaultPhysicsQueryHandler : public UPhysicsQueryHandler {
};

// Size: 0x2f0
class ADefaultPhysicsVolume : public APhysicsVolume {
};

// Size: 0x28
class IDeformableInterface : public UInterface {
};

// Size: 0x10
struct FDelegateArray {
    /* 0x0000 */ TArray<FDelegate> Delegates;
};

// Size: 0x28
class UDeletedObjectPlaceholder : public UObject {
};

// Size: 0x1e80
class UDemoNetConnection : public UNetConnection {
};

// Size: 0x15a0
class UDemoNetDriver : public UNetDriver {
    /* 0x0928 */ TMap<FString, FRollbackNetStartupActorInfo> RollbackNetStartupActors;
    /* 0x0a5c */ float CheckpointSaveMaxMSPerFrame;
    /* 0x0a78 */ TArray<FMulticastRecordOptions> MulticastRecordOptions;
    /* 0x0a88 */ TArray<APlayerController*> SpectatorControllers;
};

// Size: 0xc0
class UDemoPendingNetGame : public UPendingNetGame {
};

// Size: 0x60
class UDeprecatedDataLayerInstance : public UDataLayerInstance {
    /* 0x0048 */ FName Label;
    /* 0x0050 */ FName DeprecatedDataLayerFName;
    /* 0x0058 */ EDataLayerType DataLayerType;
    /* 0x005c */ FColor DebugColor;
};

// Size: 0x38
struct FDepthFieldGlowInfo {
    /* 0x0000 */ bool bEnableGlow;
    /* 0x0004 */ FLinearColor GlowColor;
    /* 0x0018 */ FVector2D GlowOuterRadius;
    /* 0x0028 */ FVector2D GlowInnerRadius;
};

// Size: 0x28
class IDestructibleInterface : public UInterface {
};

// Size: 0x10
struct FDeviceColorCurveData {
    /* 0x0000 */ bool bEnable;
    /* 0x0001 */ bool bResetAfterCompletion;
    /* 0x0008 */ UCurveLinearColor* DeviceColorCurve;
};

// Size: 0x8
struct FDeviceColorData {
    /* 0x0000 */ bool bEnable;
    /* 0x0001 */ bool bResetAfterCompletion;
    /* 0x0004 */ FColor LightColor;
};

// Size: 0xd0
class UDeviceProfile : public UTextureLODSettings {
    /* 0x0038 */ FString DeviceType;
    /* 0x0048 */ FString BaseProfileName;
    /* 0x0058 */ bool bIsVisibleForAssets;
    /* 0x0060 */ UDeviceProfile* Parent;
    /* 0x0090 */ TArray<FString> CVars;
    /* 0x00a0 */ TArray<FDPMatchingRulestruct> MatchingRules;
};

// Size: 0x38
class UDeviceProfileFragment : public UObject {
    /* 0x0028 */ TArray<FString> CVars;
};

// Size: 0xc0
class UDeviceProfileManager : public UObject {
    /* 0x0028 */ TArray<UDeviceProfile*> Profiles;
    /* 0x0038 */ TArray<UDeviceProfile*> BackupProfiles;
};

// Size: 0x2
struct FDeviceTriggerBaseData {
    /* 0x0000 */ EInputDeviceTriggerMask AffectedTriggers;
    /* 0x0001 */ bool bResetUponCompletion;
};

// Size: 0x10
struct FDeviceTriggerFeedbackData {
    /* 0x0000 */ UCurveFloat* FeedbackPositionCurve;
    /* 0x0008 */ UCurveFloat* FeedbackStrenghCurve;
};

// Size: 0x10
struct FDeviceTriggerTriggerResistanceData {
    /* 0x0000 */ int32_t StartPosition;
    /* 0x0004 */ int32_t StartStrengh;
    /* 0x0008 */ int32_t EndPosition;
    /* 0x000c */ int32_t EndStrengh;
};

// Size: 0x18
struct FDeviceTriggerTriggerVibrationData {
    /* 0x0000 */ UCurveFloat* TriggerPositionCurve;
    /* 0x0008 */ UCurveFloat* VibrationFrequencyCurve;
    /* 0x0010 */ UCurveFloat* VibrationAmplitudeCurve;
};

// Size: 0x18
struct FDialogueContext {
    /* 0x0000 */ UDialogueVoice* Speaker;
    /* 0x0008 */ TArray<UDialogueVoice*> Targets;
};

// Size: 0x38
struct FDialogueContextMapping {
    /* 0x0000 */ FDialogueContext Context;
    /* 0x0018 */ USoundWave* SoundWave;
    /* 0x0020 */ FString LocalizationKeyFormat;
    /* 0x0030 */ UDialogueSoundWaveProxy* Proxy;
};

// Size: 0x1a0
class UDialogueSoundWaveProxy : public USoundBase {
};

// Size: 0x40
class UDialogueVoice : public UObject {
    /* 0x0028 */ uint8_t Gender;
    /* 0x0029 */ uint8_t Plurality;
    /* 0x002c */ FGuid LocalizationGUID;
};

// Size: 0x70
class UDialogueWave : public UObject {
    /* 0x0028 */ bool bMature;
    /* 0x0028 */ bool bOverride_SubtitleOverride;
    /* 0x0030 */ FString SpokenText;
    /* 0x0040 */ FString SubtitleOverride;
    /* 0x0050 */ TArray<FDialogueContextMapping> ContextMappings;
    /* 0x0060 */ FGuid LocalizationGUID;
};

// Size: 0x20
struct FDialogueWaveParameter {
    /* 0x0000 */ UDialogueWave* DialogueWave;
    /* 0x0008 */ FDialogueContext Context;
};

// Size: 0x2b8
class ADirectionalLight : public ALight {
};

// Size: 0x470
class UDirectionalLightComponent : public ULightComponent {
    /* 0x0398 */ float ShadowCascadeBiasDistribution;
    /* 0x039c */ bool bEnableLightShaftOcclusion;
    /* 0x03a0 */ float OcclusionMaskDarkness;
    /* 0x03a4 */ float OcclusionDepthRange;
    /* 0x03a8 */ FVector LightShaftOverrideDirection;
    /* 0x03c0 */ float WholeSceneDynamicShadowRadius;
    /* 0x03c4 */ float DynamicShadowDistanceMovableLight;
    /* 0x03c8 */ float DynamicShadowDistanceStationaryLight;
    /* 0x03cc */ int32_t DynamicShadowCascades;
    /* 0x03d0 */ float CascadeDistributionExponent;
    /* 0x03d4 */ float CascadeTransitionFraction;
    /* 0x03d8 */ float ShadowDistanceFadeoutFraction;
    /* 0x03dc */ bool bUseInsetShadowsForMovableObjects;
    /* 0x03e0 */ int32_t FarShadowCascadeCount;
    /* 0x03e4 */ float FarShadowDistance;
    /* 0x03e8 */ float DistanceFieldShadowDistance;
    /* 0x03ec */ int32_t ForwardShadingPriority;
    /* 0x03f0 */ float LightSourceAngle;
    /* 0x03f4 */ float LightSourceSoftAngle;
    /* 0x03f8 */ float ShadowSourceAngleFactor;
    /* 0x03fc */ float TraceDistance;
    /* 0x0400 */ bool bUsedAsAtmosphereSunLight;
    /* 0x0400 */ bool bAtmosphereSunLight;
    /* 0x0404 */ int32_t AtmosphereSunLightIndex;
    /* 0x0408 */ FLinearColor AtmosphereSunDiskColorScale;
    /* 0x0418 */ bool bPerPixelAtmosphereTransmittance;
    /* 0x0418 */ bool bCastShadowsOnClouds;
    /* 0x0418 */ bool bCastShadowsOnAtmosphere;
    /* 0x0418 */ bool bCastCloudShadows;
    /* 0x041c */ float CloudShadowStrength;
    /* 0x0420 */ float CloudShadowOnAtmosphereStrength;
    /* 0x0424 */ float CloudShadowOnSurfaceStrength;
    /* 0x0428 */ float CloudShadowDepthBias;
    /* 0x042c */ float CloudShadowExtent;
    /* 0x0430 */ float CloudShadowMapResolutionScale;
    /* 0x0434 */ float CloudShadowRaySampleCountScale;
    /* 0x0438 */ FLinearColor CloudScatteredLuminanceScale;
    /* 0x0448 */ FLightmassDirectionalLightSettings LightmassSettings;
    /* 0x0458 */ bool bCastModulatedShadows;
    /* 0x045c */ FColor ModulatedShadowColor;
    /* 0x0460 */ float ShadowAmount;

    void SetAtmosphereSunDiskColorScale(FLinearColor NewValue);
    void SetAtmosphereSunLight(bool bNewValue);
    void SetAtmosphereSunLightIndex(int32_t NewValue);
    void SetCascadeDistributionExponent(float NewValue);
    void SetCascadeTransitionFraction(float NewValue);
    void SetDynamicShadowCascades(int32_t NewValue);
    void SetDynamicShadowDistanceMovableLight(float NewValue);
    void SetDynamicShadowDistanceStationaryLight(float NewValue);
    void SetEnableLightShaftOcclusion(bool bNewValue);
    void SetForwardShadingPriority(int32_t NewValue);
    void SetLightShaftOverrideDirection(FVector NewValue);
    void SetLightSourceAngle(float NewValue);
    void SetLightSourceSoftAngle(float NewValue);
    void SetOcclusionDepthRange(float NewValue);
    void SetOcclusionMaskDarkness(float NewValue);
    void SetShadowAmount(float NewValue);
    void SetShadowCascadeBiasDistribution(float NewValue);
    void SetShadowDistanceFadeoutFraction(float NewValue);
    void SetShadowSourceAngleFactor(float NewValue);
};

// Size: 0x8
struct FDisplacementFadeRange {
    /* 0x0000 */ float StartSizePixels;
    /* 0x0004 */ float EndSizePixels;
};

// Size: 0x8
struct FDisplacementScaling {
    /* 0x0000 */ float Magnitude;
    /* 0x0004 */ float Center;
};

// Size: 0x14
struct FDistanceDatum {
    /* 0x0000 */ float FadeInDistanceStart;
    /* 0x0004 */ float FadeInDistanceEnd;
    /* 0x0008 */ float FadeOutDistanceStart;
    /* 0x000c */ float FadeOutDistanceEnd;
    /* 0x0010 */ float Volume;
};

// Size: 0x30
class UDistribution : public UObject {
};

// Size: 0x38
class UDistributionFloat : public UDistribution {
    /* 0x0030 */ bool bCanBeBaked;
    /* 0x0030 */ bool bBakedDataSuccesfully;
};

// Size: 0x40
class UDistributionFloatConstant : public UDistributionFloat {
    /* 0x0038 */ float Constant;
};

// Size: 0x50
class UDistributionFloatConstantCurve : public UDistributionFloat {
    /* 0x0038 */ FInterpCurveFloat ConstantCurve;
};

// Size: 0x60
class UDistributionFloatParameterBase : public UDistributionFloatConstant {
    /* 0x0040 */ FName ParameterName;
    /* 0x0048 */ float MinInput;
    /* 0x004c */ float MaxInput;
    /* 0x0050 */ float MinOutput;
    /* 0x0054 */ float MaxOutput;
    /* 0x0058 */ uint8_t ParamMode;
};

// Size: 0x60
class UDistributionFloatParticleParameter : public UDistributionFloatParameterBase {
};

// Size: 0x40
class UDistributionFloatUniform : public UDistributionFloat {
    /* 0x0038 */ float min;
    /* 0x003c */ float max;
};

// Size: 0x50
class UDistributionFloatUniformCurve : public UDistributionFloat {
    /* 0x0038 */ FInterpCurveVector2D ConstantCurve;
};

// Size: 0x20
struct FDistributionLookupTable {
    /* 0x0000 */ float TimeScale;
    /* 0x0004 */ float TimeBias;
    /* 0x0008 */ TArray<float> Values;
    /* 0x0018 */ uint8_t Op;
    /* 0x0019 */ uint8_t EntryCount;
    /* 0x001a */ uint8_t EntryStride;
    /* 0x001b */ uint8_t SubEntryStride;
    /* 0x001c */ uint8_t LockFlag;
};

enum class DistributionParamMode {
    DPM_Normal = 0,
    DPM_Abs = 1,
    DPM_Direct = 2,
    DPM_MAX = 3,
};

// Size: 0x38
class UDistributionVector : public UDistribution {
    /* 0x0030 */ bool bCanBeBaked;
    /* 0x0030 */ bool bIsDirty;
    /* 0x0030 */ bool bBakedDataSuccesfully;
};

// Size: 0x58
class UDistributionVectorConstant : public UDistributionVector {
    /* 0x0038 */ FVector Constant;
    /* 0x0050 */ bool bLockAxes;
    /* 0x0054 */ uint8_t LockedAxes;
};

// Size: 0x58
class UDistributionVectorConstantCurve : public UDistributionVector {
    /* 0x0038 */ FInterpCurveVector ConstantCurve;
    /* 0x0050 */ bool bLockAxes;
    /* 0x0054 */ uint8_t LockedAxes;
};

// Size: 0xc8
class UDistributionVectorParameterBase : public UDistributionVectorConstant {
    /* 0x0058 */ FName ParameterName;
    /* 0x0060 */ FVector MinInput;
    /* 0x0078 */ FVector MaxInput;
    /* 0x0090 */ FVector MinOutput;
    /* 0x00a8 */ FVector MaxOutput;
    /* 0x00c0 */ uint8_t ParamModes[3];
};

// Size: 0xc8
class UDistributionVectorParticleParameter : public UDistributionVectorParameterBase {
};

// Size: 0x78
class UDistributionVectorUniform : public UDistributionVector {
    /* 0x0038 */ FVector max;
    /* 0x0050 */ FVector min;
    /* 0x0068 */ bool bLockAxes;
    /* 0x006c */ uint8_t LockedAxes;
    /* 0x006d */ uint8_t MirrorFlags[3];
    /* 0x0070 */ bool bUseExtremes;
};

// Size: 0x60
class UDistributionVectorUniformCurve : public UDistributionVector {
    /* 0x0038 */ FInterpCurveTwoVectors ConstantCurve;
    /* 0x0050 */ bool bLockAxes1;
    /* 0x0050 */ bool bLockAxes2;
    /* 0x0054 */ uint8_t LockedAxes[2];
    /* 0x0056 */ uint8_t MirrorFlags[3];
    /* 0x005c */ bool bUseExtremes;
};

// Size: 0x2b0
class ADocumentationActor : public AActor {
};

// Size: 0x40
struct FDoubleVectorParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ FVector4d ParameterValue;
    /* 0x0030 */ FGuid ExpressionGUID;
};

// Size: 0x540
class UDrawFrustumComponent : public UPrimitiveComponent {
    /* 0x0520 */ bool bFrustumEnabled;
    /* 0x0524 */ FColor FrustumColor;
    /* 0x0528 */ float FrustumAngle;
    /* 0x052c */ float FrustumAspectRatio;
    /* 0x0530 */ float FrustumStartDist;
    /* 0x0534 */ float FrustumEndDist;
    /* 0x0538 */ UTexture* Texture;
};

// Size: 0x550
class UDrawSphereComponent : public USphereComponent {
};

// Size: 0x8
struct FDrawToRenderTargetContext {
    /* 0x0000 */ UTextureRenderTarget2D* RenderTarget;
};

// Size: 0x40
struct FDropNoteInfo {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ FString Comment;
};

// Size: 0x1
struct FDummySpacerCameraTypes {
};

// Size: 0x28
class UDynamicBlueprintBinding : public UObject {
};

// Size: 0x10
struct FDynamicChildSubmix {
    /* 0x0000 */ TArray<USoundSubmixBase*> ChildSubmixes;
};

// Size: 0x30
class UDynamicSubsystem : public USubsystem {
};

// Size: 0x58
struct FDynamicTextureInstance : public FStreamableTextureInstance {
    /* 0x0048 */ UTexture2D* Texture;
    /* 0x0050 */ bool bAttached;
    /* 0x0054 */ float OriginalRadius;
};

enum class EActorUpdateOverlapsMethod {
    UseConfigDefault = 0,
    AlwaysUpdate = 1,
    OnlyUpdateMovable = 2,
    NeverUpdate = 3,
    EActorUpdateOverlapsMethod_MAX = 4,
};

enum class EAdManagerDelegate {
    AMD_ClickedBanner = 0,
    AMD_UserClosedAd = 1,
    AMD_MAX = 2,
};

enum class EAdditiveAnimationType {
    AAT_None = 0,
    AAT_LocalSpaceBase = 1,
    AAT_RotationOffsetMeshSpace = 2,
    AAT_MAX = 3,
};

enum class EAdditiveBasePoseType {
    ABPT_None = 0,
    ABPT_RefPose = 1,
    ABPT_AnimScaled = 2,
    ABPT_AnimFrame = 3,
    ABPT_LocalAnimFrame = 4,
    ABPT_MAX = 5,
};

enum class EAggCollisionShape {
    Sphere = 0,
    Box = 1,
    Sphyl = 2,
    Convex = 3,
    TaperedCapsule = 4,
    LevelSet = 5,
    SkinnedLevelSet = 6,
    MLLevelSet = 7,
    SkinnedTriangleMesh = 8,
    Unknown = 9,
    EAggCollisionShape_MAX = 10,
};

enum class EAirAbsorptionMethod {
    Linear = 0,
    CustomCurve = 1,
    EAirAbsorptionMethod_MAX = 2,
};

enum class EAlphaBlendOption {
    Linear = 0,
    Cubic = 1,
    HermiteCubic = 2,
    Sinusoidal = 3,
    QuadraticInOut = 4,
    CubicInOut = 5,
    QuarticInOut = 6,
    QuinticInOut = 7,
    CircularIn = 8,
    CircularOut = 9,
    CircularInOut = 10,
    ExpIn = 11,
    ExpOut = 12,
    ExpInOut = 13,
    Custom = 14,
    EAlphaBlendOption_MAX = 15,
};

enum class EAlphaChannelMode {
    Disabled = 0,
    Enabled = 1,
    LinearColorSpaceOnly = 1,
    AllowThroughTonemapper = 1,
    EAlphaChannelMode_MAX = 2,
};

enum class EAngularDriveMode {
    SLERP = 0,
    TwistAndSwing = 1,
    EAngularDriveMode_MAX = 2,
};

enum class EAnimAlphaInputType {
    Float = 0,
    Bool = 1,
    Curve = 2,
    EAnimAlphaInputType_MAX = 3,
};

enum class EAnimAssetCurveFlags {
    AACF_NONE = 0,
    AACF_DriveMorphTarget_DEPRECATED = 1,
    AACF_DriveAttribute_DEPRECATED = 2,
    AACF_Editable = 4,
    AACF_DriveMaterial_DEPRECATED = 8,
    AACF_Metadata = 16,
    AACF_DriveTrack = 32,
    AACF_Disabled = 64,
    AACF_MAX = 65,
};

enum class EAnimCurveType {
    AttributeCurve = 0,
    MaterialCurve = 1,
    MorphTargetCurve = 2,
    MaxAnimCurveType = 3,
    EAnimCurveType_MAX = 4,
};

enum class EAnimDataModelNotifyType {
    BracketOpened = 0,
    BracketClosed = 1,
    TrackAdded = 2,
    TrackChanged = 3,
    TrackRemoved = 4,
    SequenceLengthChanged = 5,
    FrameRateChanged = 6,
    CurveAdded = 7,
    CurveChanged = 8,
    CurveRemoved = 9,
    CurveFlagsChanged = 10,
    CurveRenamed = 11,
    CurveScaled = 12,
    CurveColorChanged = 13,
    CurveCommentChanged = 14,
    AttributeAdded = 15,
    AttributeRemoved = 16,
    AttributeChanged = 17,
    Populated = 18,
    Reset = 19,
    SkeletonChanged = 20,
    Invalid = 21,
    EAnimDataModelNotifyType_MAX = 22,
};

enum class EAnimExecutionContextConversionResult {
    Succeeded = 1,
    Failed = 0,
    EAnimExecutionContextConversionResult_MAX = 2,
};

enum class EAnimGroupRole {
    CanBeLeader = 0,
    AlwaysFollower = 1,
    AlwaysLeader = 2,
    TransitionLeader = 3,
    TransitionFollower = 4,
    ExclusiveAlwaysLeader = 5,
    EAnimGroupRole_MAX = 6,
};

enum class EAnimInstanceLocatorFragmentType {
    AnimInstance = 0,
    PostProcessAnimInstance = 1,
    EAnimInstanceLocatorFragmentType_MAX = 2,
};

enum class EAnimInterpolationType {
    Linear = 0,
    Step = 1,
    EAnimInterpolationType_MAX = 2,
};

enum class EAnimLinkMethod {
    Absolute = 0,
    Relative = 1,
    Proportional = 2,
    EAnimLinkMethod_MAX = 3,
};

enum class EAnimNodeDataFlags {
    None = 0,
    HasInitialUpdateFunction = 1,
    HasBecomeRelevantFunction = 2,
    HasUpdateFunction = 4,
    AllFunctions = 7,
    EAnimNodeDataFlags_MAX = 8,
};

enum class EAnimNodeReferenceConversionResult {
    Succeeded = 1,
    Failed = 0,
    EAnimNodeReferenceConversionResult_MAX = 2,
};

enum class EAnimNotifyEventType {
    Begin = 0,
    End = 1,
    EAnimNotifyEventType_MAX = 2,
};

enum class EAnimPropertyAccessCallSite {
    WorkerThread_Unbatched = 0,
    WorkerThread_Batched_PreEventGraph = 1,
    WorkerThread_Batched_PostEventGraph = 2,
    GameThread_Batched_PreEventGraph = 3,
    GameThread_Batched_PostEventGraph = 4,
    EAnimPropertyAccessCallSite_MAX = 5,
};

enum class EAnimSyncGroupScope {
    Local = 0,
    Component = 1,
    EAnimSyncGroupScope_MAX = 2,
};

enum class EAnimSyncMethod {
    DoNotSync = 0,
    SyncGroup = 1,
    Graph = 2,
    EAnimSyncMethod_MAX = 3,
};

enum class EAnimationMode {
    AnimationBlueprint = 0,
    AnimationSingleNode = 1,
    AnimationCustomMode = 2,
    EAnimationMode_MAX = 3,
};

enum class EAntiAliasingMethod {
    AAM_None = 0,
    AAM_FXAA = 1,
    AAM_TemporalAA = 2,
    AAM_MSAA = 3,
    AAM_TSR = 4,
    AAM_MAX = 5,
};

enum class EApplicationState {
    Unknown = 0,
    Inactive = 1,
    Background = 2,
    Active = 3,
    EApplicationState_MAX = 4,
};

enum class EArraySortOrder {
    Ascending = 0,
    Descending = 1,
    EArraySortOrder_MAX = 2,
};

enum class EAspectRatioAxisConstraint {
    AspectRatio_MaintainYFOV = 0,
    AspectRatio_MaintainXFOV = 1,
    AspectRatio_MajorAxisFOV = 2,
    AspectRatio_MAX = 3,
};

enum class EAttachLocation {
    KeepRelativeOffset = 0,
    KeepWorldPosition = 1,
    SnapToTarget = 2,
    SnapToTargetIncludingScale = 3,
    EAttachLocation_MAX = 4,
};

enum class EAttachmentRule {
    KeepRelative = 0,
    KeepWorld = 1,
    SnapToTarget = 2,
    EAttachmentRule_MAX = 3,
};

enum class EAttenuationDistanceModel {
    Linear = 0,
    Logarithmic = 1,
    Inverse = 2,
    LogReverse = 3,
    NaturalSound = 4,
    Custom = 5,
    EAttenuationDistanceModel_MAX = 6,
};

enum class EAttenuationShape {
    Sphere = 0,
    Capsule = 1,
    Box = 2,
    Cone = 3,
    EAttenuationShape_MAX = 4,
};

enum class EAttractorParticleSelectionMethod {
    EAPSM_Random = 0,
    EAPSM_Sequential = 1,
    EAPSM_MAX = 2,
};

enum class EAudioBusChannels {
    Mono = 0,
    Stereo = 1,
    Quad = 3,
    FivePointOne = 5,
    SevenPointOne = 7,
    MaxChannelCount = 8,
    EAudioBusChannels_MAX = 9,
};

enum class EAudioComponentPlayState {
    Playing = 0,
    Stopped = 1,
    Paused = 2,
    FadingIn = 3,
    FadingOut = 4,
    Count = 5,
    EAudioComponentPlayState_MAX = 6,
};

enum class EAudioFaderCurve {
    Linear = 0,
    Logarithmic = 1,
    SCurve = 2,
    Sin = 3,
    Count = 4,
    EAudioFaderCurve_MAX = 5,
};

enum class EAudioOutputTarget {
    Speaker = 0,
    Controller = 1,
    ControllerFallbackToSpeaker = 2,
    EAudioOutputTarget_MAX = 3,
};

enum class EAudioRecordingExportType {
    SoundWave = 0,
    WavFile = 1,
    EAudioRecordingExportType_MAX = 2,
};

enum class EAudioSpectrumBandPresetType {
    KickDrum = 0,
    SnareDrum = 1,
    Voice = 2,
    Cymbals = 3,
    EAudioSpectrumBandPresetType_MAX = 4,
};

enum class EAudioSpectrumType {
    MagnitudeSpectrum = 0,
    PowerSpectrum = 1,
    Decibel = 2,
    EAudioSpectrumType_MAX = 3,
};

enum class EAudioVolumeLocationState {
    InsideTheVolume = 0,
    OutsideTheVolume = 1,
    EAudioVolumeLocationState_MAX = 2,
};

enum class EAutoExposureMethod {
    AEM_Histogram = 0,
    AEM_Basic = 1,
    AEM_Manual = 2,
    AEM_MAX = 3,
};

enum class EAutoExposureMethodUI {
    AEM_Histogram = 0,
    AEM_Basic = 1,
    AEM_Manual = 2,
    AEM_MAX = 3,
};

enum class EAutoPossessAI {
    Disabled = 0,
    PlacedInWorld = 1,
    Spawned = 2,
    PlacedInWorldOrSpawned = 3,
    EAutoPossessAI_MAX = 4,
};

enum class EAutoReceiveInput {
    Disabled = 0,
    Player0 = 1,
    Player1 = 2,
    Player2 = 3,
    Player3 = 4,
    Player4 = 5,
    Player5 = 6,
    Player6 = 7,
    Player7 = 8,
    EAutoReceiveInput_MAX = 9,
};

enum class EAxisOption {
    X = 0,
    Y = 1,
    Z = 2,
    X_Neg = 3,
    Y_Neg = 4,
    Z_Neg = 5,
    Custom = 6,
    EAxisOption_MAX = 7,
};

enum class EBeam2Method {
    PEB2M_Distance = 0,
    PEB2M_Target = 1,
    PEB2M_Branch = 2,
    PEB2M_MAX = 3,
};

enum class EBeamTaperMethod {
    PEBTM_None = 0,
    PEBTM_Full = 1,
    PEBTM_Partial = 2,
    PEBTM_MAX = 3,
};

enum class EBlendMode {
    BLEND_Opaque = 0,
    BLEND_Masked = 1,
    BLEND_Translucent = 2,
    BLEND_Additive = 3,
    BLEND_Modulate = 4,
    BLEND_AlphaComposite = 5,
    BLEND_AlphaHoldout = 6,
    BLEND_TranslucentColoredTransmittance = 7,
    BLEND_MAX = 8,
    BLEND_TranslucentGreyTransmittance = 2,
    BLEND_ColoredTransmittanceOnly = 4,
};

enum class EBlendProfileMode {
    TimeFactor = 0,
    WeightFactor = 1,
    BlendMask = 2,
    EBlendProfileMode_MAX = 3,
};

enum class EBlendSpaceAxis {
    BSA_None = 0,
    BSA_X = 1,
    BSA_Y = 2,
    BSA_MAX = 3,
};

enum class EBlendSpacePerBoneBlendMode {
    ManualPerBoneOverride = 0,
    BlendProfile = 1,
    EBlendSpacePerBoneBlendMode_MAX = 2,
};

enum class EBlendableLocation {
    BL_SceneColorBeforeDOF = 2,
    BL_SceneColorAfterDOF = 1,
    BL_TranslucencyAfterDOF = 5,
    BL_SSRInput = 4,
    BL_SceneColorBeforeBloom = 6,
    BL_ReplacingTonemapper = 3,
    BL_SceneColorAfterTonemapping = 0,
    BL_MAX = 7,
    BL_BeforeTranslucency = 2,
    BL_BeforeTonemapping = 1,
    BL_AfterTonemapping = 0,
};

enum class EBloomMethod {
    BM_SOG = 0,
    BM_FFT = 1,
    BM_MAX = 2,
};

enum class EBlueprintCompileMode {
    Default = 0,
    Development = 1,
    FinalRelease = 2,
    EBlueprintCompileMode_MAX = 3,
};

enum class EBlueprintPinStyleType {
    BPST_Original = 0,
    BPST_VariantA = 1,
    BPST_MAX = 2,
};

enum class EBlueprintStatus {
    BS_Unknown = 0,
    BS_Dirty = 1,
    BS_Error = 2,
    BS_UpToDate = 3,
    BS_BeingCreated = 4,
    BS_UpToDateWithWarnings = 5,
    BS_MAX = 6,
};

enum class EBlueprintType {
    BPTYPE_Normal = 0,
    BPTYPE_Const = 1,
    BPTYPE_MacroLibrary = 2,
    BPTYPE_Interface = 3,
    BPTYPE_LevelScript = 4,
    BPTYPE_FunctionLibrary = 5,
    BPTYPE_MAX = 6,
};

enum class EBoneAxis {
    BA_X = 0,
    BA_Y = 1,
    BA_Z = 2,
    BA_MAX = 3,
};

enum class EBoneControlSpace {
    BCS_WorldSpace = 0,
    BCS_ComponentSpace = 1,
    BCS_ParentBoneSpace = 2,
    BCS_BoneSpace = 3,
    BCS_MAX = 4,
};

enum class EBoneFilterActionOption {
    Remove = 0,
    Keep = 1,
    Invalid = 2,
    EBoneFilterActionOption_MAX = 3,
};

enum class EBoneRotationSource {
    BRS_KeepComponentSpaceRotation = 0,
    BRS_KeepLocalSpaceRotation = 1,
    BRS_CopyFromTarget = 2,
    BRS_MAX = 3,
};

enum class EBoneSpaces {
    WorldSpace = 0,
    ComponentSpace = 1,
    EBoneSpaces_MAX = 2,
};

enum class EBoneTranslationRetargetingMode {
    Animation = 0,
    Skeleton = 1,
    AnimationScaled = 2,
    AnimationRelative = 3,
    OrientAndScale = 4,
    EBoneTranslationRetargetingMode_MAX = 5,
};

enum class EBoneVisibilityStatus {
    BVS_HiddenByParent = 0,
    BVS_Visible = 1,
    BVS_ExplicitlyHidden = 2,
    BVS_MAX = 3,
};

enum class EBrushType {
    Brush_Default = 0,
    Brush_Add = 1,
    Brush_Subtract = 2,
    Brush_MAX = 3,
};

enum class ECameraAlphaBlendMode {
    CABM_Linear = 0,
    CABM_Cubic = 1,
    CABM_MAX = 2,
};

enum class ECameraProjectionMode {
    Perspective = 0,
    Orthographic = 1,
    ECameraProjectionMode_MAX = 2,
};

enum class ECameraShakeAttenuation {
    Linear = 0,
    Quadratic = 1,
    ECameraShakeAttenuation_MAX = 2,
};

enum class ECameraShakeDurationType {
    Fixed = 0,
    Infinite = 1,
    Custom = 2,
    ECameraShakeDurationType_MAX = 3,
};

enum class ECameraShakePatternUpdateResultFlags {
    ApplyAsAbsolute = 1,
    SkipAutoScale = 2,
    SkipAutoPlaySpace = 4,
    Default = 0,
    ECameraShakePatternUpdateResultFlags_MAX = 5,
};

enum class ECameraShakePlaySpace {
    CameraLocal = 0,
    World = 1,
    UserDefined = 2,
    ECameraShakePlaySpace_MAX = 3,
};

enum class ECanBeCharacterBase {
    ECB_No = 0,
    ECB_Yes = 1,
    ECB_Owner = 2,
    ECB_MAX = 3,
};

enum class ECanCreateConnectionResponse {
    CONNECT_RESPONSE_MAKE = 0,
    CONNECT_RESPONSE_DISALLOW = 1,
    CONNECT_RESPONSE_BREAK_OTHERS_A = 2,
    CONNECT_RESPONSE_BREAK_OTHERS_B = 3,
    CONNECT_RESPONSE_BREAK_OTHERS_AB = 4,
    CONNECT_RESPONSE_MAKE_WITH_CONVERSION_NODE = 5,
    CONNECT_RESPONSE_MAKE_WITH_PROMOTION = 6,
    CONNECT_RESPONSE_MAX = 7,
};

enum class ECastRayTracedShadow {
    Disabled = 0,
    UseProjectSetting = 1,
    Enabled = 2,
    ECastRayTracedShadow_MAX = 3,
};

enum class EChannelMaskParameterColor {
    Red = 0,
    Green = 1,
    Blue = 2,
    Alpha = 3,
    EChannelMaskParameterColor_MAX = 4,
};

enum class EChunkSeekTableMode {
    ConstantSamplesPerEntry = 0,
    VariableSamplesPerEntry = 1,
    EChunkSeekTableMode_MAX = 2,
};

enum class EClampMode {
    CMODE_Clamp = 0,
    CMODE_ClampMin = 1,
    CMODE_ClampMax = 2,
    CMODE_MAX = 3,
};

enum class EClearSceneOptions {
    NoClear = 0,
    HardwareClear = 1,
    QuadAtMaxZ = 2,
    EClearSceneOptions_MAX = 3,
};

enum class EClothLODBiasMode {
    MappingsToSameLOD = 0,
    MappingsToMinLOD = 1,
    MappingsToAnyLOD = 2,
    EClothLODBiasMode_MAX = 3,
};

enum class ECloudStorageDelegate {
    CSD_KeyValueReadComplete = 0,
    CSD_KeyValueWriteComplete = 1,
    CSD_ValueChanged = 2,
    CSD_DocumentQueryComplete = 3,
    CSD_DocumentReadComplete = 4,
    CSD_DocumentWriteComplete = 5,
    CSD_DocumentConflictDetected = 6,
    CSD_MAX = 7,
};

enum class ECollectionScriptingShareType {
    Local = 0,
    Private = 1,
    Shared = 2,
    ECollectionScriptingShareType_MAX = 3,
};

enum class ECollisionChannel {
    ECC_WorldStatic = 0,
    ECC_WorldDynamic = 1,
    ECC_Pawn = 2,
    ECC_Visibility = 3,
    ECC_Camera = 4,
    ECC_PhysicsBody = 5,
    ECC_Vehicle = 6,
    ECC_Destructible = 7,
    ECC_EngineTraceChannel1 = 8,
    ECC_EngineTraceChannel2 = 9,
    ECC_EngineTraceChannel3 = 10,
    ECC_EngineTraceChannel4 = 11,
    ECC_EngineTraceChannel5 = 12,
    ECC_EngineTraceChannel6 = 13,
    ECC_GameTraceChannel1 = 14,
    ECC_GameTraceChannel2 = 15,
    ECC_GameTraceChannel3 = 16,
    ECC_GameTraceChannel4 = 17,
    ECC_GameTraceChannel5 = 18,
    ECC_GameTraceChannel6 = 19,
    ECC_GameTraceChannel7 = 20,
    ECC_GameTraceChannel8 = 21,
    ECC_GameTraceChannel9 = 22,
    ECC_GameTraceChannel10 = 23,
    ECC_GameTraceChannel11 = 24,
    ECC_GameTraceChannel12 = 25,
    ECC_GameTraceChannel13 = 26,
    ECC_GameTraceChannel14 = 27,
    ECC_GameTraceChannel15 = 28,
    ECC_GameTraceChannel16 = 29,
    ECC_GameTraceChannel17 = 30,
    ECC_GameTraceChannel18 = 31,
    ECC_OverlapAll_Deprecated = 32,
    ECC_MAX = 33,
};

enum class ECollisionEnabled {
    NoCollision = 0,
    QueryOnly = 1,
    PhysicsOnly = 2,
    QueryAndPhysics = 3,
    ProbeOnly = 4,
    QueryAndProbe = 5,
    ECollisionEnabled_MAX = 6,
};

enum class ECollisionResponse {
    ECR_Ignore = 0,
    ECR_Overlap = 1,
    ECR_Block = 2,
    ECR_MAX = 3,
};

enum class EComponentCreationMethod {
    Native = 0,
    SimpleConstructionScript = 1,
    UserConstructionScript = 2,
    Instance = 3,
    EComponentCreationMethod_MAX = 4,
};

enum class EComponentMobility {
    Static = 0,
    Stationary = 1,
    Movable = 2,
    EComponentMobility_MAX = 3,
};

enum class EComponentPhysicsStateChange {
    Created = 0,
    Destroyed = 1,
    EComponentPhysicsStateChange_MAX = 2,
};

enum class EComponentSocketType {
    Invalid = 0,
    Bone = 1,
    Socket = 2,
    EComponentSocketType_MAX = 3,
};

enum class EComponentType {
    None = 0,
    TranslationX = 1,
    TranslationY = 2,
    TranslationZ = 3,
    RotationX = 4,
    RotationY = 5,
    RotationZ = 6,
    Scale = 7,
    ScaleX = 8,
    ScaleY = 9,
    ScaleZ = 10,
    EComponentType_MAX = 11,
};

enum class ECompositeTextureMode {
    CTM_Disabled = 0,
    CTM_NormalRoughnessToRed = 1,
    CTM_NormalRoughnessToGreen = 2,
    CTM_NormalRoughnessToBlue = 3,
    CTM_NormalRoughnessToAlpha = 4,
    CTM_MAX = 5,
};

enum class ECompositingSampleCount {
    One = 1,
    Two = 2,
    Four = 4,
    Eight = 8,
    ECompositingSampleCount_MAX = 9,
};

enum class EConcurrencyVolumeScaleMode {
    Default = 0,
    Distance = 1,
    Priority = 2,
    EConcurrencyVolumeScaleMode_MAX = 3,
};

enum class EConstraintTransformComponentFlags {
    None = 0,
    ChildPosition = 1,
    ChildRotation = 2,
    ParentPosition = 4,
    ParentRotation = 8,
    AllChild = 3,
    AllParent = 12,
    AllPosition = 5,
    AllRotation = 10,
    All = 15,
    EConstraintTransformComponentFlags_MAX = 16,
};

enum class EContentBundleClientState {
    Unregistered = 0,
    Registered = 1,
    ContentInjectionRequested = 2,
    ContentRemovalRequested = 3,
    RegistrationFailed = 4,
    EContentBundleClientState_MAX = 5,
};

enum class EContentBundleStatus {
    Registered = 0,
    ReadyToInject = 1,
    FailedToInject = 2,
    ContentInjected = 3,
    Unknown = -1,
    EContentBundleStatus_MAX = 4,
};

enum class EControllerAnalogStick {
    CAS_LeftStick = 0,
    CAS_RightStick = 1,
    CAS_MAX = 2,
};

enum class ECsgOper {
    CSG_Active = 0,
    CSG_Add = 1,
    CSG_Subtract = 2,
    CSG_Intersect = 3,
    CSG_Deintersect = 4,
    CSG_None = 5,
    CSG_MAX = 6,
};

enum class ECurveBlendOption {
    Override = 0,
    DoNotOverride = 1,
    NormalizeByWeight = 2,
    BlendByWeight = 3,
    UseBasePose = 4,
    UseMaxValue = 5,
    UseMinValue = 6,
    ECurveBlendOption_MAX = 7,
};

enum class ECurveTableMode {
    Empty = 0,
    SimpleCurves = 1,
    RichCurves = 2,
    ECurveTableMode_MAX = 3,
};

enum class ECustomAttributeBlendType {
    Override = 0,
    Blend = 1,
    ECustomAttributeBlendType_MAX = 2,
};

enum class ECustomBoneAttributeLookup {
    BoneOnly = 0,
    ImmediateParent = 1,
    ParentHierarchy = 2,
    ECustomBoneAttributeLookup_MAX = 3,
};

enum class ECustomDepthStencil {
    Disabled = 0,
    Enabled = 1,
    EnabledOnDemand = 2,
    EnabledWithStencil = 3,
    ECustomDepthStencil_MAX = 4,
};

enum class ECustomMaterialOutputType {
    CMOT_Float1 = 0,
    CMOT_Float2 = 1,
    CMOT_Float3 = 2,
    CMOT_Float4 = 3,
    CMOT_MaterialAttributes = 4,
    CMOT_MAX = 5,
};

enum class ECustomTimeStepSynchronizationState {
    Closed = 0,
    Error = 1,
    Synchronized = 2,
    Synchronizing = 3,
    ECustomTimeStepSynchronizationState_MAX = 4,
};

enum class EDBufferTextureId {
    DBT_A = 0,
    DBT_B = 1,
    DBT_C = 2,
    DBT_MAX = 3,
};

enum class EDOFMode {
    Default = 0,
    SixDOF = 1,
    YZPlane = 2,
    XZPlane = 3,
    XYPlane = 4,
    CustomPlane = 5,
    None = 6,
    EDOFMode_MAX = 7,
};

enum class EDataDrivenShaderPlatformInfoCondition {
    COND_True = 0,
    COND_False = 1,
    COND_Max = 2,
};

enum class EDataLayerLoadFilter {
    None = 0,
    ClientOnly = 1,
    ServerOnly = 2,
    EDataLayerLoadFilter_MAX = 3,
};

enum class EDataLayerRuntimeState {
    Unloaded = 0,
    Loaded = 1,
    Activated = 2,
    EDataLayerRuntimeState_MAX = 3,
};

enum class EDataLayerState {
    Unloaded = 0,
    Loaded = 1,
    Activated = 2,
    EDataLayerState_MAX = 3,
};

enum class EDataLayerType {
    Runtime = 0,
    Editor = 1,
    Unknown = 2,
    Size = 3,
    EDataLayerType_MAX = 4,
};

enum class EDateTimeStyle {
    Default = 0,
    Short = 1,
    Medium = 2,
    Long = 3,
    Full = 4,
    Custom = 5,
    EDateTimeStyle_MAX = 6,
};

enum class EDecalBlendMode {
    DBM_Translucent = 0,
    DBM_Stain = 1,
    DBM_Normal = 2,
    DBM_Emissive = 3,
    DBM_DBuffer_ColorNormalRoughness = 4,
    DBM_DBuffer_Color = 5,
    DBM_DBuffer_ColorNormal = 6,
    DBM_DBuffer_ColorRoughness = 7,
    DBM_DBuffer_Normal = 8,
    DBM_DBuffer_NormalRoughness = 9,
    DBM_DBuffer_Roughness = 10,
    DBM_DBuffer_Emissive = 11,
    DBM_DBuffer_AlphaComposite = 12,
    DBM_DBuffer_EmissiveAlphaComposite = 13,
    DBM_Volumetric_DistanceFunction = 14,
    DBM_AlphaComposite = 15,
    DBM_AmbientOcclusion = 16,
    DBM_MAX = 17,
};

enum class EDecompressionType {
    DTYPE_Setup = 0,
    DTYPE_Invalid = 1,
    DTYPE_RealTime = 2,
    DTYPE_Procedural = 3,
    DTYPE_Xenon = 4,
    DTYPE_Streaming = 5,
    DTYPE_MAX = 6,
};

enum class EDefaultAudioCompressionType {
    BinkAudio = 0,
    ADPCM = 1,
    PCM = 2,
    Opus = 3,
    PlatformSpecific = 4,
    RADAudio = 5,
    EDefaultAudioCompressionType_MAX = 6,
};

enum class EDefaultBackBufferPixelFormat {
    DBBPF_B8G8R8A8 = 0,
    DBBPF_A16B16G16R16_DEPRECATED = 1,
    DBBPF_FloatRGB_DEPRECATED = 2,
    DBBPF_FloatRGBA = 3,
    DBBPF_A2B10G10R10 = 4,
    DBBPF_MAX = 5,
};

enum class EDemoPlayFailure {
    Generic = 0,
    DemoNotFound = 1,
    Corrupt = 2,
    InvalidVersion = 3,
    InitBase = 4,
    GameSpecificHeader = 5,
    ReplayStreamerInternal = 6,
    LoadMap = 7,
    Serialization = 8,
    EDemoPlayFailure_MAX = 9,
};

enum class EDepthOfFieldFunctionValue {
    TDOF_NearAndFarMask = 0,
    TDOF_NearMask = 1,
    TDOF_FarMask = 2,
    TDOF_CircleOfConfusionRadius = 3,
    TDOF_MAX = 4,
};

enum class EDepthOfFieldMethod {
    DOFM_BokehDOF = 0,
    DOFM_Gaussian = 1,
    DOFM_CircleDOF = 2,
    DOFM_MAX = 3,
};

enum class EDerivativeStatus {
    NotAware = 0,
    NotValid = 1,
    Zero = 2,
    Valid = 3,
    EDerivativeStatus_MAX = 4,
};

enum class EDetachmentRule {
    KeepRelative = 0,
    KeepWorld = 1,
    EDetachmentRule_MAX = 2,
};

enum class EDetailMode {
    DM_Low = 0,
    DM_Medium = 1,
    DM_High = 2,
    DM_Epic = 3,
    DM_MAX = 4,
};

enum class EDistributionVectorLockFlags {
    EDVLF_None = 0,
    EDVLF_XY = 1,
    EDVLF_XZ = 2,
    EDVLF_YZ = 3,
    EDVLF_XYZ = 4,
    EDVLF_MAX = 5,
};

enum class EDistributionVectorMirrorFlags {
    EDVMF_Same = 0,
    EDVMF_Different = 1,
    EDVMF_Mirror = 2,
    EDVMF_MAX = 3,
};

enum class EDrawDebugItemType {
    DirectionalArrow = 0,
    Sphere = 1,
    Line = 2,
    OnScreenMessage = 3,
    CoordinateSystem = 4,
    Point = 5,
    Circle = 6,
    Cone = 7,
    InWorldMessage = 8,
    Capsule = 9,
    EDrawDebugItemType_MAX = 10,
};

enum class EDrawDebugTrace {
    None = 0,
    ForOneFrame = 1,
    ForDuration = 2,
    Persistent = 3,
    EDrawDebugTrace_MAX = 4,
};

enum class EDynamicForceFeedbackAction {
    Start = 0,
    Update = 1,
    Stop = 2,
    EDynamicForceFeedbackAction_MAX = 3,
};

enum class EDynamicGlobalIlluminationMethod {
    None = 0,
    Lumen = 1,
    ScreenSpace = 2,
    Plugin = 3,
    EDynamicGlobalIlluminationMethod_MAX = 4,
};

enum class EEarlyZPass {
    None = 0,
    OpaqueOnly = 1,
    OpaqueAndMasked = 2,
    Auto = 3,
    EEarlyZPass_MAX = 4,
};

enum class EEasingFunc {
    Linear = 0,
    Step = 1,
    SinusoidalIn = 2,
    SinusoidalOut = 3,
    SinusoidalInOut = 4,
    EaseIn = 5,
    EaseOut = 6,
    EaseInOut = 7,
    ExpoIn = 8,
    ExpoOut = 9,
    ExpoInOut = 10,
    CircularIn = 11,
    CircularOut = 12,
    CircularInOut = 13,
    EEasingFunc_MAX = 14,
};

enum class EEdGraphPinDirection {
    EGPD_Input = 0,
    EGPD_Output = 1,
    EGPD_MAX = 2,
};

enum class EEditorPropertyValueState {
    Default = 0,
    Overridden = 1,
    NotFound = 2,
    AccessDenied = 3,
    EEditorPropertyValueState_MAX = 4,
};

enum class EEmitterDynamicParameterValue {
    EDPV_UserSet = 0,
    EDPV_AutoSet = 1,
    EDPV_VelocityX = 2,
    EDPV_VelocityY = 3,
    EDPV_VelocityZ = 4,
    EDPV_VelocityMag = 5,
    EDPV_MAX = 6,
};

enum class EEmitterNormalsMode {
    ENM_CameraFacing = 0,
    ENM_Spherical = 1,
    ENM_Cylindrical = 2,
    ENM_MAX = 3,
};

enum class EEmitterRenderMode {
    ERM_Normal = 0,
    ERM_Point = 1,
    ERM_Cross = 2,
    ERM_LightsOnly = 3,
    ERM_None = 4,
    ERM_MAX = 5,
};

enum class EEndPlayReason {
    Destroyed = 0,
    LevelTransition = 1,
    EndPlayInEditor = 2,
    RemovedFromWorld = 3,
    Quit = 4,
    EEndPlayReason_MAX = 5,
};

enum class EEvaluateCurveTableResult {
    RowFound = 0,
    RowNotFound = 1,
    EEvaluateCurveTableResult_MAX = 2,
};

enum class EEvaluatorDataSource {
    EDS_SourcePose = 0,
    EDS_DestinationPose = 1,
    EDS_MAX = 2,
};

enum class EEvaluatorMode {
    EM_Standard = 0,
    EM_Freeze = 1,
    EM_DelayedFreeze = 2,
    EM_MAX = 3,
};

enum class EFFTPeakInterpolationMethod {
    NearestNeighbor = 0,
    Linear = 1,
    Quadratic = 2,
    ConstantQ = 3,
    EFFTPeakInterpolationMethod_MAX = 4,
};

enum class EFFTSize {
    DefaultSize = 0,
    Min = 1,
    Small = 2,
    Medium = 3,
    Large = 4,
    VeryLarge = 5,
    Max = 6,
};

enum class EFFTWindowType {
    None = 0,
    Hamming = 1,
    Hann = 2,
    Blackman = 3,
    EFFTWindowType_MAX = 4,
};

enum class EFilterInterpolationType {
    BSIT_Average = 0,
    BSIT_Linear = 1,
    BSIT_Cubic = 2,
    BSIT_EaseInOut = 3,
    BSIT_ExponentialDecay = 4,
    BSIT_SpringDamper = 5,
    BSIT_MAX = 6,
};

enum class EFirstPersonPrimitiveType {
    None = 0,
    FirstPerson = 1,
    WorldSpaceRepresentation = 2,
    EFirstPersonPrimitiveType_MAX = 3,
};

enum class EFixedFoveationLevels {
    Disabled = 0,
    Low = 1,
    Medium = 2,
    High = 3,
    HighTop = 4,
    EFixedFoveationLevels_MAX = 5,
};

enum class EFloatToIntMode {
    Truncate = 0,
    Floor = 1,
    Round = 2,
    Ceil = 3,
    EFloatToIntMode_MAX = 4,
};

enum class EFontCacheType {
    Offline = 0,
    Runtime = 1,
    EFontCacheType_MAX = 2,
};

enum class EFontDPI {
    Standard = 0,
    Unreal = 1,
    Custom = 2,
    EFontDPI_MAX = 3,
};

enum class EFontImportCharacterSet {
    FontICS_Default = 0,
    FontICS_Ansi = 1,
    FontICS_Symbol = 2,
    FontICS_MAX = 3,
};

enum class EFormatArgumentType {
    Int = 0,
    UInt = 1,
    Float = 2,
    Double = 3,
    Text = 4,
    Gender = 5,
    EFormatArgumentType_MAX = 6,
};

enum class EFullyLoadPackageType {
    FULLYLOAD_Map = 0,
    FULLYLOAD_Game_PreLoadClass = 1,
    FULLYLOAD_Game_PostLoadClass = 2,
    FULLYLOAD_Always = 3,
    FULLYLOAD_Mutator = 4,
    FULLYLOAD_MAX = 5,
};

enum class EFunctionInputType {
    FunctionInput_Scalar = 0,
    FunctionInput_Vector2 = 1,
    FunctionInput_Vector3 = 2,
    FunctionInput_Vector4 = 3,
    FunctionInput_Texture2D = 4,
    FunctionInput_TextureCube = 5,
    FunctionInput_Texture2DArray = 6,
    FunctionInput_VolumeTexture = 7,
    FunctionInput_StaticBool = 8,
    FunctionInput_MaterialAttributes = 9,
    FunctionInput_TextureExternal = 10,
    FunctionInput_Bool = 11,
    FunctionInput_Substrate = 12,
    FunctionInput_MAX = 13,
};

enum class EGBufferFormat {
    Force8BitsPerChannel = 0,
    Default = 1,
    HighPrecisionNormals = 3,
    Force16BitsPerChannel = 5,
    EGBufferFormat_MAX = 6,
};

enum class EGainParamMode {
    Linear = 0,
    Decibels = 1,
    EGainParamMode_MAX = 2,
};

enum class EGrammaticalGender {
    Neuter = 0,
    Masculine = 1,
    Feminine = 2,
    Mixed = 3,
    EGrammaticalGender_MAX = 4,
};

enum class EGrammaticalNumber {
    Singular = 0,
    Plural = 1,
    EGrammaticalNumber_MAX = 2,
};

enum class EGraphAxisStyle {
    Lines = 0,
    Notches = 1,
    Grid = 2,
    EGraphAxisStyle_MAX = 3,
};

enum class EGraphDataStyle {
    Lines = 0,
    Filled = 1,
    EGraphDataStyle_MAX = 2,
};

enum class EGraphType {
    GT_Function = 0,
    GT_Ubergraph = 1,
    GT_Macro = 2,
    GT_Animation = 3,
    GT_StateMachine = 4,
    GT_MAX = 5,
};

enum class EHISMViewRelevanceType {
    Grass = 0,
    Foliage = 1,
    HISM = 2,
    EHISMViewRelevanceType_MAX = 3,
};

enum class EHLODBatchingPolicy {
    None = 0,
    MeshSection = 1,
    Instancing = 2,
    EHLODBatchingPolicy_MAX = 3,
};

enum class EHLODLayerType {
    Instancing = 0,
    MeshMerge = 1,
    MeshSimplify = 2,
    MeshApproximate = 3,
    Custom = 4,
    EHLODLayerType_MAX = 5,
};

enum class EHLODLevelExclusion {
    HLOD0 = 1,
    HLOD1 = 2,
    HLOD2 = 4,
    HLOD3 = 8,
    HLOD4 = 16,
    HLOD5 = 32,
    HLOD6 = 64,
    HLOD7 = 128,
    EHLODLevelExclusion_MAX = 129,
};

enum class EHardwareDevicePrimaryType {
    Unspecified = 0,
    KeyboardAndMouse = 1,
    Gamepad = 2,
    Touch = 3,
    MotionTracking = 4,
    RacingWheel = 5,
    FlightStick = 6,
    Camera = 7,
    Instrument = 8,
    CustomTypeA = 9,
    CustomTypeB = 10,
    CustomTypeC = 11,
    CustomTypeD = 12,
    EHardwareDevicePrimaryType_MAX = 13,
};

enum class EHardwareDeviceSupportedFeatures {
    Unspecified = 0,
    Keypress = 1,
    Pointer = 2,
    Gamepad = 4,
    Touch = 8,
    Camera = 16,
    MotionTracking = 32,
    Lights = 64,
    TriggerHaptics = 128,
    ForceFeedback = 256,
    AudioBasedVibrations = 512,
    Acceleration = 1024,
    Virtual = 2048,
    Microphone = 4096,
    Orientation = 8192,
    Guitar = 16384,
    Drums = 32768,
    CustomA = 16777216,
    CustomB = 33554432,
    CustomC = 67108864,
    CustomD = 134217728,
    All = 2147483647,
    EHardwareDeviceSupportedFeatures_MAX = 2147483648,
};

enum class EHasCustomNavigableGeometry {
    No = 0,
    Yes = 1,
    EvenIfNotCollidable = 2,
    DontExport = 3,
    EHasCustomNavigableGeometry_MAX = 4,
};

enum class EHierarchicalSimplificationMethod {
    None = 0,
    Merge = 1,
    Simplify = 2,
    Approximate = 3,
    EHierarchicalSimplificationMethod_MAX = 4,
};

enum class EHitProxyPriority {
    HPP_World = 0,
    HPP_Wireframe = 1,
    HPP_Foreground = 2,
    HPP_UI = 3,
    HPP_MAX = 4,
};

enum class EHorizTextAligment {
    EHTA_Left = 0,
    EHTA_Center = 1,
    EHTA_Right = 2,
    EHTA_MAX = 3,
};

enum class EImportanceLevel {
    IL_Off = 0,
    IL_Lowest = 1,
    IL_Low = 2,
    IL_Normal = 3,
    IL_High = 4,
    IL_Highest = 5,
    TEMP_BROKEN2 = 6,
    EImportanceLevel_MAX = 7,
};

enum class EImportanceWeight {
    Luminance = 0,
    Red = 1,
    Green = 2,
    Blue = 3,
    Alpha = 4,
    EImportanceWeight_MAX = 5,
};

enum class EIndirectLightingCacheQuality {
    ILCQ_Off = 0,
    ILCQ_Point = 1,
    ILCQ_Volume = 2,
    ILCQ_MAX = 3,
};

enum class EInertializationBoneState {
    Invalid = 0,
    Valid = 1,
    Excluded = 2,
    EInertializationBoneState_MAX = 3,
};

enum class EInertializationSpace {
    Default = 0,
    WorldSpace = 1,
    WorldRotation = 2,
    EInertializationSpace_MAX = 3,
};

enum class EInertializationState {
    Inactive = 0,
    Pending = 1,
    Active = 2,
    EInertializationState_MAX = 3,
};

enum class EInputEvent {
    IE_Pressed = 0,
    IE_Released = 1,
    IE_Repeat = 2,
    IE_DoubleClick = 3,
    IE_Axis = 4,
    IE_MAX = 5,
};

enum class EInterfaceValidResult {
    Valid = 0,
    Invalid = 1,
    EInterfaceValidResult_MAX = 2,
};

enum class EInterpToBehaviourType {
    OneShot = 0,
    OneShot_Reverse = 1,
    Loop_Reset = 2,
    PingPong = 3,
    EInterpToBehaviourType_MAX = 4,
};

enum class EKinematicBonesUpdateToPhysics {
    SkipSimulatingBones = 0,
    SkipAllBones = 1,
    EKinematicBonesUpdateToPhysics_MAX = 2,
};

enum class ELWCFunctionKind {
    Constructor = 0,
    Promote = 1,
    Demote = 2,
    Add = 3,
    Subtract = 4,
    Divide = 5,
    MultiplyVectorVector = 6,
    MultiplyVectorMatrix = 7,
    MultiplyMatrixMatrix = 8,
    Other = 9,
    Max = 10,
};

enum class ELandscapeCullingPrecision {
    High = 0,
    Medium = 1,
    Low = 2,
    ELandscapeCullingPrecision_MAX = 3,
};

enum class ELegendPosition {
    Outside = 0,
    Inside = 1,
    ELegendPosition_MAX = 2,
};

enum class ELerpInterpolationMode {
    QuatInterp = 0,
    EulerInterp = 1,
    DualQuatInterp = 2,
    ELerpInterpolationMode_MAX = 3,
};

enum class ELevelInstanceCreationType {
    LevelInstance = 0,
    PackedLevelActor = 1,
    ELevelInstanceCreationType_MAX = 2,
};

enum class ELevelInstanceFlags {
    None = 0,
    IsInEditHierarchy = 1,
    HasPropertyOverrides = 2,
    HasEditablePropertyOverrides = 4,
    ELevelInstanceFlags_MAX = 5,
};

enum class ELevelInstancePivotType {
    CenterMinZ = 0,
    Center = 1,
    Actor = 2,
    WorldOrigin = 3,
    ELevelInstancePivotType_MAX = 4,
};

enum class ELevelInstanceRuntimeBehavior {
    None = 0,
    Embedded_Deprecated = 1,
    Partitioned = 2,
    LevelStreaming = 3,
    ELevelInstanceRuntimeBehavior_MAX = 4,
};

enum class ELevelInstanceType {
    None = 0,
    LevelInstance = 1,
    LevelInstanceEdit = 2,
    LevelInstancePropertyOverride = 3,
    ELevelInstanceType_MAX = 4,
};

enum class ELightFunctionAtlasPixelFormat {
    LFAPF_R8 = 0,
    LFAPF_R8G8B8 = 1,
    LFAPF_MAX = 2,
};

enum class ELightMapPaddingType {
    LMPT_NormalPadding = 0,
    LMPT_PrePadding = 1,
    LMPT_NoPadding = 2,
    LMPT_MAX = 3,
};

enum class ELightUnits {
    Unitless = 0,
    Candelas = 1,
    Lumens = 2,
    EV = 3,
    Nits = 4,
    ELightUnits_MAX = 5,
};

enum class ELightingBuildQuality {
    Quality_Preview = 0,
    Quality_Medium = 1,
    Quality_High = 2,
    Quality_Production = 3,
    Quality_MAX = 4,
};

enum class ELightmapType {
    Default = 0,
    ForceSurface = 1,
    ForceVolumetric = 2,
    ELightmapType_MAX = 3,
};

enum class ELocalExposureMethod {
    Bilateral = 0,
    Fusion = 1,
    ELocalExposureMethod_MAX = 2,
};

enum class ELocalPositionOrigin {
    Instance = 0,
    InstancePreSkinning = 1,
    Primitive = 2,
    ELocalPositionOrigin_MAX = 3,
};

enum class ELocationBoneSocketSelectionMethod {
    BONESOCKETSEL_Sequential = 0,
    BONESOCKETSEL_Random = 1,
    BONESOCKETSEL_MAX = 2,
};

enum class ELocationBoneSocketSource {
    BONESOCKETSOURCE_Bones = 0,
    BONESOCKETSOURCE_Sockets = 1,
    BONESOCKETSOURCE_MAX = 2,
};

enum class ELocationEmitterSelectionMethod {
    ELESM_Random = 0,
    ELESM_Sequential = 1,
    ELESM_MAX = 2,
};

enum class ELocationSkelVertSurfaceSource {
    VERTSURFACESOURCE_Vert = 0,
    VERTSURFACESOURCE_Surface = 1,
    VERTSURFACESOURCE_MAX = 2,
};

enum class ELumenRayLightingMode {
    SurfaceCache = 0,
    HitLightingForReflections = 2,
    HitLighting = 1,
    ELumenRayLightingMode_MAX = 3,
};

enum class ELumenRayLightingModeOverride {
    Default = 0,
    SurfaceCache = 1,
    HitLightingForReflections = 2,
    HitLighting = 3,
    ELumenRayLightingModeOverride_MAX = 4,
};

enum class ELumenScreenTracingSource {
    SceneColor = 0,
    AntialiasedSceneColorWithTranslucency = 1,
    ELumenScreenTracingSource_MAX = 2,
};

enum class ELumenSoftwareTracingMode {
    DetailTracing = 1,
    GlobalTracing = 0,
    ELumenSoftwareTracingMode_MAX = 2,
};

enum class EMIDCreationFlags {
    None = 0,
    Transient = 1,
    EMIDCreationFlags_MAX = 2,
};

enum class EMaterialAttributeBlend {
    Blend = 0,
    UseA = 1,
    UseB = 2,
    EMaterialAttributeBlend_MAX = 3,
};

enum class EMaterialAttributeBlendFunction {
    Horizontal = 0,
    Vertical = 1,
    EMaterialAttributeBlendFunction_MAX = 2,
};

enum class EMaterialDecalResponse {
    MDR_None = 0,
    MDR_ColorNormalRoughness = 1,
    MDR_Color = 2,
    MDR_ColorNormal = 3,
    MDR_ColorRoughness = 4,
    MDR_Normal = 5,
    MDR_NormalRoughness = 6,
    MDR_Roughness = 7,
    MDR_MAX = 8,
};

enum class EMaterialDomain {
    MD_Surface = 0,
    MD_DeferredDecal = 1,
    MD_LightFunction = 2,
    MD_Volume = 3,
    MD_PostProcess = 4,
    MD_UI = 5,
    MD_RuntimeVirtualTexture = 6,
    MD_MAX = 7,
};

enum class EMaterialExposedTextureProperty {
    TMTM_TextureSize = 0,
    TMTM_TexelSize = 1,
    TMTM_MAX = 2,
};

enum class EMaterialExposedViewProperty {
    MEVP_BufferSize = 0,
    MEVP_FieldOfView = 1,
    MEVP_TanHalfFieldOfView = 2,
    MEVP_ViewSize = 3,
    MEVP_WorldSpaceViewPosition = 4,
    MEVP_WorldSpaceCameraPosition = 5,
    MEVP_ViewportOffset = 6,
    MEVP_TemporalSampleCount = 7,
    MEVP_TemporalSampleIndex = 8,
    MEVP_TemporalSampleOffset = 9,
    MEVP_RuntimeVirtualTextureOutputLevel = 10,
    MEVP_RuntimeVirtualTextureOutputDerivative = 11,
    MEVP_PreExposure = 12,
    MEVP_RuntimeVirtualTextureMaxLevel = 13,
    MEVP_ResolutionFraction = 14,
    MEVP_PostVolumeUserFlags = 15,
    MEVP_FirstPersonFieldOfView = 16,
    MEVP_FirstPersonTanHalfFieldOfView = 17,
    MEVP_FirstPersonScale = 18,
    MEVP_NearPlane = 19,
    MEVP_MAX = 20,
};

enum class EMaterialExpressionBoundsType {
    MEILB_InstanceLocal = 0,
    MEILB_ObjectLocal = 1,
    MEILB_PreSkinnedLocal = 2,
    MEILB_MAX = 3,
};

enum class EMaterialExpressionConvertType {
    Scalar = 0,
    Vector2 = 1,
    Vector3 = 2,
    Vector4 = 3,
    EMaterialExpressionConvertType_MAX = 4,
};

enum class EMaterialExpressionOperatorKind {
    BitwiseNot = 0,
    Negate = 1,
    Not = 2,
    Abs = 3,
    ACos = 4,
    ACosh = 5,
    ASin = 6,
    ASinh = 7,
    ATan = 8,
    ATanh = 9,
    Ceil = 10,
    Cos = 11,
    Cosh = 12,
    Exponential = 13,
    Exponential2 = 14,
    Floor = 15,
    Frac = 16,
    IsFinite = 17,
    IsInf = 18,
    IsNan = 19,
    Length = 20,
    Logarithm = 21,
    Logarithm10 = 22,
    Logarithm2 = 23,
    Round = 24,
    Saturate = 25,
    Sign = 26,
    Sin = 27,
    Sinh = 28,
    Sqrt = 29,
    Tan = 30,
    Tanh = 31,
    Truncate = 32,
    Equals = 33,
    GreaterThan = 34,
    GreaterThanOrEquals = 35,
    LessThan = 36,
    LessThanOrEquals = 37,
    NotEquals = 38,
    And = 39,
    Or = 40,
    Add = 41,
    Subtract = 42,
    Multiply = 43,
    Divide = 44,
    Modulo = 45,
    BitwiseAnd = 46,
    BitwiseOr = 47,
    BitShiftLeft = 48,
    BitShiftRight = 49,
    Cross = 50,
    Distance = 51,
    Dot = 52,
    Fmod = 53,
    Max = 54,
    Min = 55,
    Pow = 56,
    Step = 57,
    Clamp = 58,
    Lerp = 59,
    Select = 60,
    Smoothstep = 61,
};

enum class EMaterialFloatPrecisionMode {
    MFPM_Default = 0,
    MFPM_Full_MaterialExpressionOnly = 1,
    MFPM_Full = 2,
    MFPM_Half = 3,
    MFPM_MAX = 4,
};

enum class EMaterialFunctionUsage {
    Default = 0,
    MaterialLayer = 1,
    MaterialLayerBlend = 2,
    EMaterialFunctionUsage_MAX = 3,
};

enum class EMaterialLayerLinkState {
    Uninitialized = 0,
    LinkedToParent = 1,
    UnlinkedFromParent = 2,
    NotFromParent = 3,
    EMaterialLayerLinkState_MAX = 4,
};

enum class EMaterialMergeType {
    MaterialMergeType_Default = 0,
    MaterialMergeType_Simplygon = 1,
    MaterialMergeType_MAX = 2,
};

enum class EMaterialParameterAssociation {
    LayerParameter = 0,
    BlendParameter = 1,
    GlobalParameter = 2,
    EMaterialParameterAssociation_MAX = 3,
};

enum class EMaterialParameterType {
    Scalar = 0,
    Vector = 1,
    DoubleVector = 2,
    Texture = 3,
    TextureCollection = 4,
    Font = 5,
    RuntimeVirtualTexture = 6,
    SparseVolumeTexture = 7,
    StaticSwitch = 8,
    NumRuntime = 9,
    StaticComponentMask = 9,
    Num = 10,
    None = 255,
    EMaterialParameterType_MAX = 256,
};

enum class EMaterialPositionTransformSource {
    TRANSFORMPOSSOURCE_Local = 0,
    TRANSFORMPOSSOURCE_World = 1,
    TRANSFORMPOSSOURCE_PeriodicWorld = 2,
    TRANSFORMPOSSOURCE_TranslatedWorld = 3,
    TRANSFORMPOSSOURCE_FirstPersonTranslatedWorld = 4,
    TRANSFORMPOSSOURCE_View = 5,
    TRANSFORMPOSSOURCE_Camera = 6,
    TRANSFORMPOSSOURCE_Particle = 7,
    TRANSFORMPOSSOURCE_Instance = 8,
    TRANSFORMPOSSOURCE_MAX = 9,
};

enum class EMaterialProperty {
    MP_EmissiveColor = 0,
    MP_Opacity = 1,
    MP_OpacityMask = 2,
    MP_DiffuseColor = 3,
    MP_SpecularColor = 4,
    MP_BaseColor = 5,
    MP_Metallic = 6,
    MP_Specular = 7,
    MP_Roughness = 8,
    MP_Anisotropy = 9,
    MP_Normal = 10,
    MP_Tangent = 11,
    MP_WorldPositionOffset = 12,
    MP_WorldDisplacement_DEPRECATED = 13,
    MP_TessellationMultiplier_DEPRECATED = 14,
    MP_SubsurfaceColor = 15,
    MP_CustomData0 = 16,
    MP_CustomData1 = 17,
    MP_AmbientOcclusion = 18,
    MP_Refraction = 19,
    MP_CustomizedUVs0 = 20,
    MP_CustomizedUVs1 = 21,
    MP_CustomizedUVs2 = 22,
    MP_CustomizedUVs3 = 23,
    MP_CustomizedUVs4 = 24,
    MP_CustomizedUVs5 = 25,
    MP_CustomizedUVs6 = 26,
    MP_CustomizedUVs7 = 27,
    MP_PixelDepthOffset = 28,
    MP_ShadingModel = 29,
    MP_FrontMaterial = 30,
    MP_SurfaceThickness = 31,
    MP_Displacement = 32,
    MP_MaterialAttributes = 33,
    MP_CustomOutput = 34,
    MP_MAX = 35,
};

enum class EMaterialSamplerType {
    SAMPLERTYPE_Color = 0,
    SAMPLERTYPE_Grayscale = 1,
    SAMPLERTYPE_Alpha = 2,
    SAMPLERTYPE_Normal = 3,
    SAMPLERTYPE_Masks = 4,
    SAMPLERTYPE_DistanceFieldFont = 5,
    SAMPLERTYPE_LinearColor = 6,
    SAMPLERTYPE_LinearGrayscale = 7,
    SAMPLERTYPE_Data = 8,
    SAMPLERTYPE_External = 9,
    SAMPLERTYPE_VirtualColor = 10,
    SAMPLERTYPE_VirtualGrayscale = 11,
    SAMPLERTYPE_VirtualAlpha = 12,
    SAMPLERTYPE_VirtualNormal = 13,
    SAMPLERTYPE_VirtualMasks = 14,
    SAMPLERTYPE_VirtualLinearColor = 15,
    SAMPLERTYPE_VirtualLinearGrayscale = 16,
    SAMPLERTYPE_MAX = 17,
};

enum class EMaterialSceneAttributeInputMode {
    Coordinates = 0,
    OffsetFraction = 1,
    EMaterialSceneAttributeInputMode_MAX = 2,
};

enum class EMaterialShaderFrequency {
    Vertex = 1,
    Pixel = 8,
    Compute = 32,
    Any = 41,
    EMaterialShaderFrequency_MAX = 42,
};

enum class EMaterialShadingModel {
    MSM_Unlit = 0,
    MSM_DefaultLit = 1,
    MSM_Subsurface = 2,
    MSM_PreintegratedSkin = 3,
    MSM_ClearCoat = 4,
    MSM_SubsurfaceProfile = 5,
    MSM_TwoSidedFoliage = 6,
    MSM_Hair = 7,
    MSM_Cloth = 8,
    MSM_Eye = 9,
    MSM_SingleLayerWater = 10,
    MSM_ThinTranslucent = 11,
    MSM_Strata = 12,
    MSM_NUM = 13,
    MSM_FromMaterialExpression = 14,
    MSM_MAX = 15,
};

enum class EMaterialShadingRate {
    MSR_1x1 = 0,
    MSR_2x1 = 1,
    MSR_1x2 = 2,
    MSR_2x2 = 3,
    MSR_4x2 = 4,
    MSR_2x4 = 5,
    MSR_4x4 = 6,
    MSR_Count = 7,
    MSR_MAX = 8,
};

enum class EMaterialStencilCompare {
    MSC_Less = 0,
    MSC_LessEqual = 1,
    MSC_Greater = 2,
    MSC_GreaterEqual = 3,
    MSC_Equal = 4,
    MSC_NotEqual = 5,
    MSC_Never = 6,
    MSC_Always = 7,
    MSC_Count = 8,
    MSC_MAX = 9,
};

enum class EMaterialSubSurfaceType {
    MSS_None = 0,
    MSS_Wrap = 1,
    MSS_TwoSidedWrap = 2,
    MSS_Diffusion = 3,
    MSS_DiffusionProfile = 4,
    MSS_SimpleVolume = 5,
    MSS_MAX = 6,
};

enum class EMaterialTranslucencyPass {
    MTP_BeforeDOF = 0,
    MTP_AfterDOF = 1,
    MTP_AfterMotionBlur = 2,
    MTP_MAX = 3,
};

enum class EMaterialUsage {
    MATUSAGE_SkeletalMesh = 0,
    MATUSAGE_ParticleSprites = 1,
    MATUSAGE_BeamTrails = 2,
    MATUSAGE_MeshParticles = 3,
    MATUSAGE_StaticLighting = 4,
    MATUSAGE_MorphTargets = 5,
    MATUSAGE_SplineMesh = 6,
    MATUSAGE_InstancedStaticMeshes = 7,
    MATUSAGE_GeometryCollections = 8,
    MATUSAGE_Clothing = 9,
    MATUSAGE_NiagaraSprites = 10,
    MATUSAGE_NiagaraRibbons = 11,
    MATUSAGE_NiagaraMeshParticles = 12,
    MATUSAGE_GeometryCache = 13,
    MATUSAGE_Water = 14,
    MATUSAGE_HairStrands = 15,
    MATUSAGE_LidarPointCloud = 16,
    MATUSAGE_VirtualHeightfieldMesh = 17,
    MATUSAGE_Nanite = 18,
    MATUSAGE_VolumetricCloud = 19,
    MATUSAGE_HeterogeneousVolumes = 20,
    MATUSAGE_MaterialCache = 21,
    MATUSAGE_StaticMesh = 22,
    MATUSAGE_MAX = 23,
};

enum class EMaterialValueTypeBridge {
    Float1 = 1,
    Float2 = 2,
    Float3 = 4,
    Float4 = 8,
    Texture2D = 16,
    TextureCube = 32,
    Texture2DArray = 64,
    TextureCubeArray = 128,
    VolumeTexture = 256,
    StaticBool = 512,
    Unknown = 1024,
    MaterialAttributes = 2048,
    TextureExternal = 4096,
    TextureVirtual = 8192,
    SparseVolumeTexture = 16384,
    VTPageTableResult = 32768,
    ShadingModel = 65536,
    Substrate = 131072,
    LWCScalar = 262144,
    LWCVector2 = 524288,
    LWCVector3 = 1048576,
    LWCVector4 = 2097152,
    Execution = 4194304,
    VoidStatement = 8388608,
    Bool = 16777216,
    UInt1 = 33554432,
    UInt2 = 67108864,
    UInt3 = 134217728,
    UInt4 = 268435456,
    TextureCollection = 536870912,
    TextureMeshPaint = 1073741824,
    TextureMaterialCache = 2147483648,
    Texture = 3221238256,
    Float = 15,
    UInt = 503316480,
    LWCType = 3932160,
    Numeric = 20709391,
    EMaterialValueTypeBridge_MAX = 4294967296,
};

enum class EMaterialVectorCoordTransform {
    TRANSFORM_Tangent = 0,
    TRANSFORM_Local = 1,
    TRANSFORM_World = 2,
    TRANSFORM_View = 3,
    TRANSFORM_Camera = 4,
    TRANSFORM_ParticleWorld = 5,
    TRANSFORM_Instance = 6,
    TRANSFORM_MAX = 7,
};

enum class EMaterialVectorCoordTransformSource {
    TRANSFORMSOURCE_Tangent = 0,
    TRANSFORMSOURCE_Local = 1,
    TRANSFORMSOURCE_World = 2,
    TRANSFORMSOURCE_View = 3,
    TRANSFORMSOURCE_Camera = 4,
    TRANSFORMSOURCE_ParticleWorld = 5,
    TRANSFORMSOURCE_Instance = 6,
    TRANSFORMSOURCE_MAX = 7,
};

enum class EMatrixColumns {
    First = 0,
    Second = 1,
    Third = 2,
    Fourth = 3,
    EMatrixColumns_MAX = 4,
};

enum class EMaxConcurrentResolutionRule {
    PreventNew = 0,
    StopOldest = 1,
    StopFarthestThenPreventNew = 2,
    StopFarthestThenOldest = 3,
    StopLowestPriority = 4,
    StopQuietest = 5,
    StopLowestPriorityThenPreventNew = 6,
    Count = 7,
    EMaxConcurrentResolutionRule_MAX = 8,
};

enum class EMegaLightsShadowMethod {
    Default = 0,
    RayTracing = 1,
    VirtualShadowMap = 2,
    EMegaLightsShadowMethod_MAX = 3,
};

enum class EMemoryUnitStandard {
    IEC = 0,
    SI = 1,
    EMemoryUnitStandard_MAX = 2,
};

enum class EMeshApproximationBaseCappingType {
    NoBaseCapping = 0,
    ConvexPolygon = 1,
    ConvexSolid = 2,
    EMeshApproximationBaseCappingType_MAX = 3,
};

enum class EMeshApproximationGroundPlaneClippingPolicy {
    NoGroundClipping = 0,
    DiscardWithZPlane = 1,
    CutWithZPlane = 2,
    CutAndFillWithZPlane = 3,
    EMeshApproximationGroundPlaneClippingPolicy_MAX = 4,
};

enum class EMeshApproximationSimplificationPolicy {
    FixedTriangleCount = 0,
    TrianglesPerArea = 1,
    GeometricTolerance = 2,
    EMeshApproximationSimplificationPolicy_MAX = 3,
};

enum class EMeshApproximationType {
    MeshAndMaterials = 0,
    MeshShapeOnly = 1,
    EMeshApproximationType_MAX = 2,
};

enum class EMeshApproximationUVGenerationPolicy {
    PreferUVAtlas = 0,
    PreferXAtlas = 1,
    PreferPatchBuilder = 2,
    EMeshApproximationUVGenerationPolicy_MAX = 3,
};

enum class EMeshBufferAccess {
    Default = 0,
    ForceCPUAndGPU = 1,
    EMeshBufferAccess_MAX = 2,
};

enum class EMeshCameraFacingOptions {
    XAxisFacing_NoUp = 0,
    XAxisFacing_ZUp = 1,
    XAxisFacing_NegativeZUp = 2,
    XAxisFacing_YUp = 3,
    XAxisFacing_NegativeYUp = 4,
    LockedAxis_ZAxisFacing = 5,
    LockedAxis_NegativeZAxisFacing = 6,
    LockedAxis_YAxisFacing = 7,
    LockedAxis_NegativeYAxisFacing = 8,
    VelocityAligned_ZAxisFacing = 9,
    VelocityAligned_NegativeZAxisFacing = 10,
    VelocityAligned_YAxisFacing = 11,
    VelocityAligned_NegativeYAxisFacing = 12,
    EMeshCameraFacingOptions_MAX = 13,
};

enum class EMeshCameraFacingUpAxis {
    CameraFacing_NoneUP = 0,
    CameraFacing_ZUp = 1,
    CameraFacing_NegativeZUp = 2,
    CameraFacing_YUp = 3,
    CameraFacing_NegativeYUp = 4,
    CameraFacing_MAX = 5,
};

enum class EMeshFeatureImportance {
    Off = 0,
    Lowest = 1,
    Low = 2,
    Normal = 3,
    High = 4,
    Highest = 5,
    EMeshFeatureImportance_MAX = 6,
};

enum class EMeshLODSelectionType {
    AllLODs = 0,
    SpecificLOD = 1,
    CalculateLOD = 2,
    LowestDetailLOD = 3,
    EMeshLODSelectionType_MAX = 4,
};

enum class EMeshMergeType {
    MeshMergeType_Default = 0,
    MeshMergeType_MergeActor = 1,
    MeshMergeType_MAX = 2,
};

enum class EMeshScreenAlignment {
    PSMA_MeshFaceCameraWithRoll = 0,
    PSMA_MeshFaceCameraWithSpin = 1,
    PSMA_MeshFaceCameraWithLockedAxis = 2,
    PSMA_MAX = 3,
};

enum class EMicroTransactionDelegate {
    MTD_PurchaseQueryComplete = 0,
    MTD_PurchaseComplete = 1,
    MTD_MAX = 2,
};

enum class EMicroTransactionResult {
    MTR_Succeeded = 0,
    MTR_Failed = 1,
    MTR_Canceled = 2,
    MTR_RestoredFromServer = 3,
    MTR_MAX = 4,
};

enum class EMirrorFindReplaceMethod {
    Prefix = 0,
    Suffix = 1,
    RegularExpression = 2,
    EMirrorFindReplaceMethod_MAX = 3,
};

enum class EMirrorRowType {
    Bone = 0,
    AnimationNotify = 1,
    Curve = 2,
    SyncMarker = 3,
    Custom = 4,
    EMirrorRowType_MAX = 5,
};

enum class EMobileAntiAliasingMethod {
    None = 0,
    FXAA = 1,
    TemporalAA = 2,
    MSAA = 3,
    EMobileAntiAliasingMethod_MAX = 4,
};

enum class EMobileFloatPrecisionMode {
    Half = 0,
    Full_MaterialExpressionOnly = 1,
    Full = 2,
    EMobileFloatPrecisionMode_MAX = 3,
};

enum class EMobileLocalLightSetting {
    LOCAL_LIGHTS_DISABLED = 0,
    LOCAL_LIGHTS_ENABLED = 1,
    LOCAL_LIGHTS_BUFFER = 2,
    LOCAL_LIGHTS_MAX = 3,
};

enum class EMobileShadingPath {
    Forward = 0,
    Deferred = 1,
    EMobileShadingPath_MAX = 2,
};

enum class EModulationDestination {
    Volume = 0,
    Pitch = 1,
    Lowpass = 2,
    Highpass = 3,
    Count = 4,
    EModulationDestination_MAX = 5,
};

enum class EModulationRouting {
    Disable = 0,
    Inherit = 1,
    Override = 2,
    Union = 3,
    EModulationRouting_MAX = 4,
};

enum class EModuleType {
    EPMT_General = 0,
    EPMT_TypeData = 1,
    EPMT_Beam = 2,
    EPMT_Trail = 3,
    EPMT_Spawn = 4,
    EPMT_Required = 5,
    EPMT_Event = 6,
    EPMT_Light = 7,
    EPMT_SubUV = 8,
    EPMT_MAX = 9,
};

enum class EMonoChannelUpmixMethod {
    Linear = 0,
    EqualPower = 1,
    FullVolume = 2,
    EMonoChannelUpmixMethod_MAX = 3,
};

enum class EMontageBlendMode {
    Standard = 0,
    Inertialization = 1,
    EMontageBlendMode_MAX = 2,
};

enum class EMontageNotifyTickType {
    Queued = 0,
    BranchingPoint = 1,
    EMontageNotifyTickType_MAX = 2,
};

enum class EMontagePlayReturnType {
    MontageLength = 0,
    Duration = 1,
    EMontagePlayReturnType_MAX = 2,
};

enum class EMontageSubStepResult {
    Moved = 0,
    NotMoved = 1,
    InvalidSection = 2,
    InvalidMontage = 3,
    EMontageSubStepResult_MAX = 4,
};

enum class EMouseCaptureMode {
    NoCapture = 0,
    CapturePermanently = 1,
    CapturePermanently_IncludingInitialMouseDown = 2,
    CaptureDuringMouseDown = 3,
    CaptureDuringRightMouseDown = 4,
    EMouseCaptureMode_MAX = 5,
};

enum class EMouseLockMode {
    DoNotLock = 0,
    LockOnCapture = 1,
    LockAlways = 2,
    LockInFullscreen = 3,
    EMouseLockMode_MAX = 4,
};

enum class EMoveComponentAction {
    Move = 0,
    Stop = 1,
    Return = 2,
    EMoveComponentAction_MAX = 3,
};

enum class EMovementMode {
    MOVE_None = 0,
    MOVE_Walking = 1,
    MOVE_NavWalking = 2,
    MOVE_Falling = 3,
    MOVE_Swimming = 4,
    MOVE_Flying = 5,
    MOVE_Custom = 6,
    MOVE_MAX = 7,
};

enum class ENaniteFallbackTarget {
    Auto = 0,
    PercentTriangles = 1,
    RelativeError = 2,
    ENaniteFallbackTarget_MAX = 3,
};

enum class ENaniteGenerateFallback {
    PlatformDefault = 0,
    Enabled = 1,
    ENaniteGenerateFallback_MAX = 2,
};

enum class ENaturalSoundFalloffMode {
    Continues = 0,
    Silent = 1,
    Hold = 2,
    ENaturalSoundFalloffMode_MAX = 3,
};

enum class ENavDataGatheringMode {
    Default = 0,
    Instant = 1,
    Lazy = 2,
    ENavDataGatheringMode_MAX = 3,
};

enum class ENavDataGatheringModeConfig {
    Invalid = 0,
    Instant = 1,
    Lazy = 2,
    ENavDataGatheringModeConfig_MAX = 3,
};

enum class ENavLinkDirection {
    BothWays = 0,
    LeftToRight = 1,
    RightToLeft = 2,
    ENavLinkDirection_MAX = 3,
};

enum class ENavPathEvent {
    Cleared = 0,
    NewPath = 1,
    UpdatedDueToGoalMoved = 2,
    UpdatedDueToNavigationChanged = 3,
    Invalidated = 4,
    RePathFailed = 5,
    MetaPathUpdate = 6,
    Custom = 7,
    ENavPathEvent_MAX = 8,
};

enum class ENavigationDataResolution {
    Low = 0,
    Default = 1,
    High = 2,
    Invalid = 3,
    MAX = 3,
};

enum class ENavigationInvokerPriority {
    VeryLow = 1,
    Low = 2,
    Default = 3,
    High = 4,
    VeryHigh = 5,
    MAX = 6,
};

enum class ENavigationOptionFlag {
    Default = 0,
    Enable = 1,
    Disable = 2,
    MAX = 3,
};

enum class ENavigationQueryResult {
    Invalid = 0,
    Error = 1,
    Fail = 2,
    Success = 3,
    ENavigationQueryResult_MAX = 4,
};

enum class ENavigationSortPendingTilesMethod {
    SortWithSeedLocations = 0,
    SortByPriority = 1,
    None = 2,
    ENavigationSortPendingTilesMethod_MAX = 3,
};

enum class ENetDormancy {
    DORM_Never = 0,
    DORM_Awake = 1,
    DORM_DormantAll = 2,
    DORM_DormantPartial = 3,
    DORM_Initial = 4,
    DORM_MAX = 5,
};

enum class ENetRole {
    ROLE_None = 0,
    ROLE_SimulatedProxy = 1,
    ROLE_AutonomousProxy = 2,
    ROLE_Authority = 3,
    ROLE_MAX = 4,
};

enum class ENetworkLagState {
    NotLagging = 0,
    Lagging = 1,
    ENetworkLagState_MAX = 2,
};

enum class ENetworkMetricEnableMode {
    EnableForAllReplication = 0,
    EnableForIrisOnly = 1,
    EnableForNonIrisOnly = 2,
    ENetworkMetricEnableMode_MAX = 3,
};

enum class ENetworkSmoothingMode {
    Disabled = 0,
    Linear = 1,
    Exponential = 2,
    ENetworkSmoothingMode_MAX = 3,
};

enum class ENeuralIndexType {
    NIT_TextureIndex = 0,
    NIT_BufferIndex = 1,
    NIT_MAX = 2,
};

enum class ENeuralModelTileType {
    OneByOne = 0,
    TwoByTwo = 1,
    FourByFour = 2,
    EightByEight = 3,
    Auto = 4,
    ENeuralModelTileType_MAX = 5,
};

enum class ENeuralProfileFormat {
    Type32 = 0,
    Type16 = 1,
    ENeuralProfileFormat_MAX = 2,
};

enum class ENeuralProfileRuntimeType {
    NNERuntimeORTDml = 0,
    NNERuntimeRDGHlsl = 1,
    MAX = 2,
};

enum class ENodeAdvancedPins {
    NoPins = 0,
    Shown = 1,
    Hidden = 2,
    ENodeAdvancedPins_MAX = 3,
};

enum class ENodeEnabledState {
    Enabled = 0,
    Disabled = 1,
    DevelopmentOnly = 2,
    ENodeEnabledState_MAX = 3,
};

enum class ENodeTitleType {
    FullTitle = 0,
    ListView = 1,
    EditableTitle = 2,
    MenuTitle = 3,
    MAX_TitleTypes = 4,
    ENodeTitleType_MAX = 5,
};

enum class ENoiseFunction {
    NOISEFUNCTION_SimplexTex = 0,
    NOISEFUNCTION_GradientTex = 1,
    NOISEFUNCTION_GradientTex3D = 2,
    NOISEFUNCTION_GradientALU = 3,
    NOISEFUNCTION_ValueALU = 4,
    NOISEFUNCTION_VoronoiALU = 5,
    NOISEFUNCTION_MAX = 6,
};

enum class ENonSpatializedRadiusSpeakerMapMode {
    OmniDirectional = 0,
    Direct2D = 1,
    Surround2D = 2,
    ENonSpatializedRadiusSpeakerMapMode_MAX = 3,
};

enum class ENormalMode {
    NM_PreserveSmoothingGroups = 0,
    NM_RecalculateNormals = 1,
    NM_RecalculateNormalsSmooth = 2,
    NM_RecalculateNormalsHard = 3,
    TEMP_BROKEN = 4,
    ENormalMode_MAX = 5,
};

enum class ENotifyFilterType {
    NoFiltering = 0,
    LOD = 1,
    ENotifyFilterType_MAX = 2,
};

enum class ENotifyTriggerMode {
    AllAnimations = 0,
    HighestWeightedAnimation = 1,
    None = 2,
    ENotifyTriggerMode_MAX = 3,
};

enum class EObjectTypeQuery {
    ObjectTypeQuery1 = 0,
    ObjectTypeQuery2 = 1,
    ObjectTypeQuery3 = 2,
    ObjectTypeQuery4 = 3,
    ObjectTypeQuery5 = 4,
    ObjectTypeQuery6 = 5,
    ObjectTypeQuery7 = 6,
    ObjectTypeQuery8 = 7,
    ObjectTypeQuery9 = 8,
    ObjectTypeQuery10 = 9,
    ObjectTypeQuery11 = 10,
    ObjectTypeQuery12 = 11,
    ObjectTypeQuery13 = 12,
    ObjectTypeQuery14 = 13,
    ObjectTypeQuery15 = 14,
    ObjectTypeQuery16 = 15,
    ObjectTypeQuery17 = 16,
    ObjectTypeQuery18 = 17,
    ObjectTypeQuery19 = 18,
    ObjectTypeQuery20 = 19,
    ObjectTypeQuery21 = 20,
    ObjectTypeQuery22 = 21,
    ObjectTypeQuery23 = 22,
    ObjectTypeQuery24 = 23,
    ObjectTypeQuery25 = 24,
    ObjectTypeQuery26 = 25,
    ObjectTypeQuery27 = 26,
    ObjectTypeQuery28 = 27,
    ObjectTypeQuery29 = 28,
    ObjectTypeQuery30 = 29,
    ObjectTypeQuery31 = 30,
    ObjectTypeQuery32 = 31,
    ObjectTypeQuery_MAX = 32,
    EObjectTypeQuery_MAX = 33,
};

enum class EOccludedGeometryFilteringPolicy {
    NoOcclusionFiltering = 0,
    VisibilityBasedFiltering = 1,
    EOccludedGeometryFilteringPolicy_MAX = 2,
};

enum class EOcclusionCombineMode {
    OCM_Minimum = 0,
    OCM_Multiply = 1,
    OCM_MAX = 2,
};

enum class EOpacitySourceMode {
    OSM_Alpha = 0,
    OSM_ColorBrightness = 1,
    OSM_RedChannel = 2,
    OSM_GreenChannel = 3,
    OSM_BlueChannel = 4,
    OSM_MAX = 5,
};

enum class EOptimizationType {
    OT_NumOfTriangles = 0,
    OT_MaxDeviation = 1,
    OT_MAX = 2,
};

enum class EOrbitChainMode {
    EOChainMode_Add = 0,
    EOChainMode_Scale = 1,
    EOChainMode_Link = 2,
    EOChainMode_MAX = 3,
};

enum class EOverlapFilterOption {
    OverlapFilter_All = 0,
    OverlapFilter_DynamicOnly = 1,
    OverlapFilter_StaticOnly = 2,
    OverlapFilter_MAX = 3,
};

enum class EOverrideBlockOnSlowStreaming {
    NoOverride = 0,
    Blocking = 1,
    NotBlocking = 2,
    EOverrideBlockOnSlowStreaming_MAX = 3,
};

enum class EPSCPoolMethod {
    None = 0,
    AutoRelease = 1,
    ManualRelease = 2,
    ManualRelease_OnComplete = 3,
    FreeInPool = 4,
    EPSCPoolMethod_MAX = 5,
};

enum class EPanningMethod {
    Linear = 0,
    EqualPower = 1,
    EPanningMethod_MAX = 2,
};

enum class EParameterCollectionTransformType {
    Position = 0,
    Vector = 1,
    Projection = 2,
    LocalToWorld = 3,
    WorldToLocal = 4,
    EParameterCollectionTransformType_MAX = 5,
};

enum class EParticleAxisLock {
    EPAL_NONE = 0,
    EPAL_X = 1,
    EPAL_Y = 2,
    EPAL_Z = 3,
    EPAL_NEGATIVE_X = 4,
    EPAL_NEGATIVE_Y = 5,
    EPAL_NEGATIVE_Z = 6,
    EPAL_ROTATE_X = 7,
    EPAL_ROTATE_Y = 8,
    EPAL_ROTATE_Z = 9,
    EPAL_MAX = 10,
};

enum class EParticleBurstMethod {
    EPBM_Instant = 0,
    EPBM_Interpolated = 1,
    EPBM_MAX = 2,
};

enum class EParticleCameraOffsetUpdateMethod {
    EPCOUM_DirectSet = 0,
    EPCOUM_Additive = 1,
    EPCOUM_Scalar = 2,
    EPCOUM_MAX = 3,
};

enum class EParticleCollisionComplete {
    EPCC_Kill = 0,
    EPCC_Freeze = 1,
    EPCC_HaltCollisions = 2,
    EPCC_FreezeTranslation = 3,
    EPCC_FreezeRotation = 4,
    EPCC_FreezeMovement = 5,
    EPCC_MAX = 6,
};

enum class EParticleCollisionMode {
    SceneDepth = 0,
    DistanceField = 1,
    EParticleCollisionMode_MAX = 2,
};

enum class EParticleCollisionResponse {
    Bounce = 0,
    Stop = 1,
    Kill = 2,
    EParticleCollisionResponse_MAX = 3,
};

enum class EParticleDetailMode {
    PDM_Low = 0,
    PDM_Medium = 1,
    PDM_High = 2,
    PDM_Epic = 3,
    PDM_MAX = 4,
};

enum class EParticleEventType {
    EPET_Any = 0,
    EPET_Spawn = 1,
    EPET_Death = 2,
    EPET_Collision = 3,
    EPET_Burst = 4,
    EPET_Blueprint = 5,
    EPET_MAX = 6,
};

enum class EParticleScreenAlignment {
    PSA_FacingCameraPosition = 0,
    PSA_Square = 1,
    PSA_Rectangle = 2,
    PSA_Velocity = 3,
    PSA_AwayFromCenter = 4,
    PSA_TypeSpecific = 5,
    PSA_FacingCameraDistanceBlend = 6,
    PSA_MAX = 7,
};

enum class EParticleSignificanceLevel {
    Low = 0,
    Medium = 1,
    High = 2,
    Critical = 3,
    Num = 4,
    EParticleSignificanceLevel_MAX = 5,
};

enum class EParticleSortMode {
    PSORTMODE_None = 0,
    PSORTMODE_ViewProjDepth = 1,
    PSORTMODE_DistanceToView = 2,
    PSORTMODE_Age_OldestFirst = 3,
    PSORTMODE_Age_NewestFirst = 4,
    PSORTMODE_MAX = 5,
};

enum class EParticleSourceSelectionMethod {
    EPSSM_Random = 0,
    EPSSM_Sequential = 1,
    EPSSM_MAX = 2,
};

enum class EParticleSubUVInterpMethod {
    PSUVIM_None = 0,
    PSUVIM_Linear = 1,
    PSUVIM_Linear_Blend = 2,
    PSUVIM_Random = 3,
    PSUVIM_Random_Blend = 4,
    PSUVIM_MAX = 5,
};

enum class EParticleSysParamType {
    PSPT_None = 0,
    PSPT_Scalar = 1,
    PSPT_ScalarRand = 2,
    PSPT_Vector = 3,
    PSPT_VectorRand = 4,
    PSPT_Color = 5,
    PSPT_Actor = 6,
    PSPT_Material = 7,
    PSPT_VectorUnitRand = 8,
    PSPT_MAX = 9,
};

enum class EParticleSystemInsignificanceReaction {
    Auto = 0,
    Complete = 1,
    DisableTick = 2,
    DisableTickAndKill = 3,
    Num = 4,
    EParticleSystemInsignificanceReaction_MAX = 5,
};

enum class EParticleSystemOcclusionBoundsMethod {
    EPSOBM_None = 0,
    EPSOBM_ParticleBounds = 1,
    EPSOBM_CustomBounds = 2,
    EPSOBM_MAX = 3,
};

enum class EParticleSystemUpdateMode {
    EPSUM_RealTime = 0,
    EPSUM_FixedTime = 1,
    EPSUM_MAX = 2,
};

enum class EParticleUVFlipMode {
    None = 0,
    FlipUV = 1,
    FlipUOnly = 2,
    FlipVOnly = 3,
    RandomFlipUV = 4,
    RandomFlipUOnly = 5,
    RandomFlipVOnly = 6,
    RandomFlipUVIndependent = 7,
    EParticleUVFlipMode_MAX = 8,
};

enum class EPathTracingBufferTextureId {
    PTBT_Radiance = 0,
    PTBT_DenoisedRadiance = 1,
    PTBT_Albedo = 2,
    PTBT_Normal = 3,
    PTBT_Variance = 4,
    PTBT_MAX = 5,
};

enum class EPerQualityLevels {
    Low = 0,
    Medium = 1,
    High = 2,
    Epic = 3,
    Cinematic = 4,
    Num = 5,
    EPerQualityLevels_MAX = 6,
};

enum class EPhysBodyOp {
    PBO_None = 0,
    PBO_Term = 1,
    PBO_MAX = 2,
};

enum class EPhysicalMaterialMaskColor {
    Red = 0,
    Green = 1,
    Blue = 2,
    Cyan = 3,
    Magenta = 4,
    Yellow = 5,
    White = 6,
    Black = 7,
    MAX = 8,
};

enum class EPhysicsAssetSolverType {
    RBAN = 0,
    World = 1,
    EPhysicsAssetSolverType_MAX = 2,
};

enum class EPhysicsQueryKind {
    Test = 0,
    Single = 1,
    Multi = 2,
    EPhysicsQueryKind_MAX = 3,
};

enum class EPhysicsReplicationMode {
    Default = 0,
    PredictiveInterpolation = 1,
    Resimulation = 2,
    EPhysicsReplicationMode_MAX = 3,
};

enum class EPhysicsStateAction {
    AddForce = 0,
    AddTorque = 1,
    AddForceAtPosition = 2,
    AddLinearVelocity = 3,
    AddAngularVelocity = 4,
    AddVelocityAtPosition = 5,
    AddLinearImpulse = 6,
    AddAngularImpulse = 7,
    AddImpulseAtPosition = 8,
    AddAcceleration = 9,
    NumActions = 10,
    EPhysicsStateAction_MAX = 11,
};

enum class EPhysicsTransformUpdateMode {
    SimulationUpatesComponentTransform = 0,
    ComponentTransformIsKinematic = 1,
    EPhysicsTransformUpdateMode_MAX = 2,
};

enum class EPinContainerType {
    None = 0,
    Array = 1,
    Set = 2,
    Map = 3,
    EPinContainerType_MAX = 4,
};

enum class EPinHidingMode {
    NeverAsPin = 0,
    PinHiddenByDefault = 1,
    PinShownByDefault = 2,
    AlwaysAsPin = 3,
    EPinHidingMode_MAX = 4,
};

enum class EPingAverageType {
    None = 0,
    MovingAverage = 1,
    PlayerStateAvg = 2,
    EPingAverageType_MAX = 3,
};

enum class EPingType {
    None = 0,
    RoundTrip = 1,
    RoundTripExclFrame = 2,
    ICMP = 4,
    UDPQoS = 8,
    Max = 8,
    Count = 4,
};

enum class EPixelDepthOffsetMode {
    PDOM_Legacy = 0,
    PDOM_AlongCameraVector = 1,
    PDOM_MAX = 2,
};

enum class EPlaneConstraintAxisSetting {
    Custom = 0,
    X = 1,
    Y = 2,
    Z = 3,
    UseGlobalPhysicsSetting = 4,
    EPlaneConstraintAxisSetting_MAX = 5,
};

enum class EPlatformInterfaceDataType {
    PIDT_None = 0,
    PIDT_Int = 1,
    PIDT_Float = 2,
    PIDT_String = 3,
    PIDT_Object = 4,
    PIDT_Custom = 5,
    PIDT_MAX = 6,
};

enum class EPositionIncludedOffsets {
    IncludeOffsets = 0,
    ExcludeOffsets = 1,
    EPositionIncludedOffsets_MAX = 2,
};

enum class EPositionOrigin {
    Absolute = 0,
    CameraRelative = 1,
    EPositionOrigin_MAX = 2,
};

enum class EPostCopyOperation {
    None = 0,
    LogicalNegateBool = 1,
    EPostCopyOperation_MAX = 2,
};

enum class EPreferredTriangulationDirection {
    None = 0,
    Tangential = 1,
    Radial = 2,
    EPreferredTriangulationDirection_MAX = 3,
};

enum class EPreviewAnimationBlueprintApplicationMethod {
    LinkedLayers = 0,
    LinkedAnimGraph = 1,
    EPreviewAnimationBlueprintApplicationMethod_MAX = 2,
};

enum class EPrimaryAssetCookRule {
    Unknown = 0,
    NeverCook = 1,
    ProductionNeverCook = 2,
    DevelopmentCook = 2,
    DevelopmentAlwaysProductionNeverCook = 3,
    DevelopmentAlwaysCook = 3,
    DevelopmentAlwaysProductionUnknownCook = 4,
    AlwaysCook = 5,
    EPrimaryAssetCookRule_MAX = 6,
};

enum class EPriorityAttenuationMethod {
    Linear = 0,
    CustomCurve = 1,
    Manual = 2,
    EPriorityAttenuationMethod_MAX = 3,
};

enum class EPropertyAccessCopyBatch {
    InternalUnbatched = 0,
    ExternalUnbatched = 1,
    InternalBatched = 2,
    ExternalBatched = 3,
    Count = 4,
    EPropertyAccessCopyBatch_MAX = 5,
};

enum class EPropertyAccessCopyType {
    None = 0,
    Plain = 1,
    Complex = 2,
    Bool = 3,
    Struct = 4,
    Object = 5,
    Name = 6,
    Array = 7,
    PromoteBoolToByte = 8,
    PromoteBoolToInt32 = 9,
    PromoteBoolToInt64 = 10,
    PromoteBoolToFloat = 11,
    PromoteBoolToDouble = 12,
    PromoteByteToInt32 = 13,
    PromoteByteToInt64 = 14,
    PromoteByteToFloat = 15,
    PromoteByteToDouble = 16,
    PromoteInt32ToInt64 = 17,
    PromoteInt32ToFloat = 18,
    PromoteInt32ToDouble = 19,
    PromoteFloatToDouble = 20,
    DemoteDoubleToFloat = 21,
    PromoteArrayFloatToDouble = 22,
    DemoteArrayDoubleToFloat = 23,
    PromoteMapValueFloatToDouble = 24,
    DemoteMapValueDoubleToFloat = 25,
    EPropertyAccessCopyType_MAX = 26,
};

enum class EPropertyAccessIndirectionType {
    Offset = 0,
    Object = 1,
    Array = 2,
    ScriptFunction = 3,
    NativeFunction = 4,
    EPropertyAccessIndirectionType_MAX = 5,
};

enum class EPropertyAccessObjectType {
    None = 0,
    Object = 1,
    WeakObject = 2,
    SoftObject = 3,
    EPropertyAccessObjectType_MAX = 4,
};

enum class EProxyNormalComputationMethod {
    AngleWeighted = 0,
    AreaWeighted = 1,
    EqualWeighted = 2,
    EProxyNormalComputationMethod_MAX = 3,
};

enum class EQuartzCommandDelegateSubType {
    CommandOnFailedToQueue = 0,
    CommandOnQueued = 1,
    CommandOnCanceled = 2,
    CommandOnAboutToStart = 3,
    CommandOnStarted = 4,
    Count = 5,
    EQuartzCommandDelegateSubType_MAX = 6,
};

enum class EQuartzCommandQuantization {
    Bar = 0,
    Beat = 1,
    ThirtySecondNote = 2,
    SixteenthNote = 3,
    EighthNote = 4,
    QuarterNote = 5,
    HalfNote = 6,
    WholeNote = 7,
    DottedSixteenthNote = 8,
    DottedEighthNote = 9,
    DottedQuarterNote = 10,
    DottedHalfNote = 11,
    DottedWholeNote = 12,
    SixteenthNoteTriplet = 13,
    EighthNoteTriplet = 14,
    QuarterNoteTriplet = 15,
    HalfNoteTriplet = 16,
    Tick = 17,
    Count = 18,
    None = 19,
    EQuartzCommandQuantization_MAX = 20,
};

enum class EQuartzCommandType {
    PlaySound = 0,
    QueueSoundToPlay = 1,
    RetriggerSound = 2,
    TickRateChange = 3,
    TransportReset = 4,
    StartOtherClock = 5,
    Notify = 6,
    Custom = 7,
    EQuartzCommandType_MAX = 8,
};

enum class EQuartzDelegateType {
    MetronomeTick = 0,
    CommandEvent = 1,
    Count = 2,
    EQuartzDelegateType_MAX = 3,
};

enum class EQuartzTimeSignatureQuantization {
    HalfNote = 0,
    QuarterNote = 1,
    EighthNote = 2,
    SixteenthNote = 3,
    ThirtySecondNote = 4,
    Count = 5,
    EQuartzTimeSignatureQuantization_MAX = 6,
};

enum class EQuarztQuantizationReference {
    BarRelative = 0,
    TransportRelative = 1,
    CurrentTimeRelative = 2,
    Count = 3,
    EQuarztQuantizationReference_MAX = 4,
};

enum class EQuitPreference {
    Quit = 0,
    Background = 1,
    EQuitPreference_MAX = 2,
};

enum class ERawCurveTrackTypes {
    RCT_Float = 0,
    RCT_Vector = 1,
    RCT_Transform = 2,
    RCT_MAX = 3,
};

enum class ERayTracingGroupCullingPriority {
    CP_0_NEVER_CULL = 0,
    CP_1 = 1,
    CP_2 = 2,
    CP_3 = 3,
    CP_4_DEFAULT = 4,
    CP_5 = 5,
    CP_6 = 6,
    CP_7 = 7,
    CP_8_QUICKLY_CULL = 8,
    CP_MAX = 9,
};

enum class EReflectedAndRefractedRayTracedShadows {
    Disabled = 0,
    Hard_shadows = 1,
    Area_shadows = 2,
    EReflectedAndRefractedRayTracedShadows_MAX = 3,
};

enum class EReflectionMethod {
    None = 0,
    Lumen = 1,
    ScreenSpace = 2,
    EReflectionMethod_MAX = 3,
};

enum class EReflectionSourceType {
    CapturedScene = 0,
    SpecifiedCubemap = 1,
    EReflectionSourceType_MAX = 2,
};

enum class EReflectionsType {
    ScreenSpace = 0,
    RayTracing = 1,
    EReflectionsType_MAX = 2,
};

enum class ERefractionCoverageMode {
    RCM_CoverageIgnored = 0,
    RCM_CoverageAccountedFor = 1,
    RCM_MAX = 2,
};

enum class ERefractionMode {
    RM_IndexOfRefraction = 0,
    RM_PixelNormalOffset = 1,
    RM_2DOffset = 2,
    RM_None = 3,
    RM_MAX = 4,
};

enum class ERelativeTransformSpace {
    RTS_World = 0,
    RTS_Actor = 1,
    RTS_Component = 2,
    RTS_ParentBoneSpace = 3,
    RTS_MAX = 4,
};

enum class ERenderFocusRule {
    Always = 0,
    NonPointer = 1,
    NavigationOnly = 2,
    Never = 3,
    ERenderFocusRule_MAX = 4,
};

enum class ERendererStencilMask {
    ERSM_Default = 0,
    ERSM_255 = 1,
    ERSM_1 = 2,
    ERSM_2 = 3,
    ERSM_4 = 4,
    ERSM_8 = 5,
    ERSM_16 = 6,
    ERSM_32 = 7,
    ERSM_64 = 8,
    ERSM_128 = 9,
    ERSM_MAX = 10,
};

enum class EReplayResult {
    Success = 0,
    ReplayNotFound = 1,
    Corrupt = 2,
    UnsupportedCheckpoint = 3,
    GameSpecific = 4,
    InitConnect = 5,
    LoadMap = 6,
    Serialization = 7,
    StreamerError = 8,
    ConnectionClosed = 9,
    MissingArchive = 10,
    Unknown = 11,
    EReplayResult_MAX = 12,
};

enum class EReporterLineStyle {
    Line = 0,
    Dash = 1,
    EReporterLineStyle_MAX = 2,
};

enum class EReverbSendMethod {
    Linear = 0,
    CustomCurve = 1,
    Manual = 2,
    EReverbSendMethod_MAX = 3,
};

enum class ERichCurveCompressionFormat {
    RCCF_Empty = 0,
    RCCF_Constant = 1,
    RCCF_Linear = 2,
    RCCF_Cubic = 3,
    RCCF_Mixed = 4,
    RCCF_Weighted = 5,
    RCCF_MAX = 6,
};

enum class ERichCurveExtrapolation {
    RCCE_Cycle = 0,
    RCCE_CycleWithOffset = 1,
    RCCE_Oscillate = 2,
    RCCE_Linear = 3,
    RCCE_Constant = 4,
    RCCE_None = 5,
    RCCE_MAX = 6,
};

enum class ERichCurveInterpMode {
    RCIM_Linear = 0,
    RCIM_Constant = 1,
    RCIM_Cubic = 2,
    RCIM_None = 3,
    RCIM_MAX = 4,
};

enum class ERichCurveKeyTimeCompressionFormat {
    RCKTCF_uint16 = 0,
    RCKTCF_float32 = 1,
    RCKTCF_MAX = 2,
};

enum class ERichCurveTangentMode {
    RCTM_Auto = 0,
    RCTM_User = 1,
    RCTM_Break = 2,
    RCTM_None = 3,
    RCTM_SmartAuto = 4,
    RCTM_MAX = 5,
};

enum class ERichCurveTangentWeightMode {
    RCTWM_WeightedNone = 0,
    RCTWM_WeightedArrive = 1,
    RCTWM_WeightedLeave = 2,
    RCTWM_WeightedBoth = 3,
    RCTWM_MAX = 4,
};

enum class ERootMotionAccumulateMode {
    Override = 0,
    Additive = 1,
    ERootMotionAccumulateMode_MAX = 2,
};

enum class ERootMotionFinishVelocityMode {
    MaintainLastRootMotionVelocity = 0,
    SetVelocity = 1,
    ClampVelocity = 2,
    ERootMotionFinishVelocityMode_MAX = 3,
};

enum class ERootMotionMode {
    NoRootMotionExtraction = 0,
    IgnoreRootMotion = 1,
    RootMotionFromEverything = 2,
    RootMotionFromMontagesOnly = 3,
    ERootMotionMode_MAX = 4,
};

enum class ERootMotionRootLock {
    RefPose = 0,
    AnimFirstFrame = 1,
    Zero = 2,
    ERootMotionRootLock_MAX = 3,
};

enum class ERootMotionSourceSettingsFlags {
    UseSensitiveLiftoffCheck = 1,
    DisablePartialEndTick = 2,
    IgnoreZAccumulate = 4,
    ERootMotionSourceSettingsFlags_MAX = 5,
};

enum class ERootMotionSourceStatusFlags {
    Prepared = 1,
    Finished = 2,
    MarkedForRemoval = 4,
    ERootMotionSourceStatusFlags_MAX = 5,
};

enum class ERotatorQuantization {
    ByteComponents = 0,
    ShortComponents = 1,
    ERotatorQuantization_MAX = 2,
};

enum class ERoundingMode {
    HalfToEven = 0,
    HalfFromZero = 1,
    HalfToZero = 2,
    FromZero = 3,
    ToZero = 4,
    ToNegativeInfinity = 5,
    ToPositiveInfinity = 6,
    ERoundingMode_MAX = 7,
};

enum class ERuntimePartitionCellBoundsMethod {
    UseContent = 0,
    UseCellBounds = 1,
    UseMinContentCellBounds = 2,
    ERuntimePartitionCellBoundsMethod_MAX = 3,
};

enum class ERuntimeVirtualTextureMainPassType {
    Never = 0,
    Exclusive = 1,
    Always = 2,
    ERuntimeVirtualTextureMainPassType_MAX = 3,
};

enum class ERuntimeVirtualTextureMaterialQuality {
    Low = 0,
    Medium = 1,
    High = 2,
    Epic = 3,
    ERuntimeVirtualTextureMaterialQuality_MAX = 4,
};

enum class ERuntimeVirtualTextureMaterialType {
    BaseColor = 0,
    Mask4 = 1,
    BaseColor_Normal_Roughness = 2,
    BaseColor_Normal_Specular = 3,
    BaseColor_Normal_Specular_YCoCg = 4,
    BaseColor_Normal_Specular_Mask_YCoCg = 5,
    WorldHeight = 6,
    Displacement = 7,
    Count = 8,
    ERuntimeVirtualTextureMaterialType_MAX = 9,
};

enum class ERuntimeVirtualTextureMipValueMode {
    RVTMVM_None = 0,
    RVTMVM_MipLevel = 1,
    RVTMVM_MipBias = 2,
    RVTMVM_RecalculateDerivatives = 3,
    RVTMVM_DerivativeUV = 4,
    RVTMVM_DerivativeWorld = 5,
    RVTMVM_MAX = 6,
};

enum class ERuntimeVirtualTextureTextureAddressMode {
    RVTTA_Clamp = 0,
    RVTTA_Wrap = 1,
    RVTTA_MAX = 2,
};

enum class ERuntimeVirtualTextureUseStreamingMipsInEditorMode {
    Never = 0,
    PIEOnly = 1,
    Always = 2,
    ERuntimeVirtualTextureUseStreamingMipsInEditorMode_MAX = 3,
};

enum class ESRB {
    Everyone = 0,
    Everyone10Plus = 1,
    Teen = 2,
    Mature = 3,
    AdultsOnly = 4,
    RatingPending = 5,
    RatingPending17Plus = 6,
    ESRB_MAX = 7,
};

enum class ESamplerSourceMode {
    SSM_FromTextureAsset = 0,
    SSM_Wrap_WorldGroupSettings = 1,
    SSM_Clamp_WorldGroupSettings = 2,
    SSM_TerrainWeightmapGroupSettings = 3,
    SSM_MAX = 4,
};

enum class ESceneCaptureCompositeMode {
    SCCM_Overwrite = 0,
    SCCM_Additive = 1,
    SCCM_Composite = 2,
    SCCM_MAX = 3,
};

enum class ESceneCapturePrimitiveRenderMode {
    PRM_LegacySceneCapture = 0,
    PRM_RenderScenePrimitives = 1,
    PRM_UseShowOnlyList = 2,
    PRM_MAX = 3,
};

enum class ESceneCaptureSource {
    SCS_SceneColorHDR = 0,
    SCS_SceneColorHDRNoAlpha = 1,
    SCS_FinalColorLDR = 2,
    SCS_SceneColorSceneDepth = 3,
    SCS_SceneDepth = 4,
    SCS_DeviceDepth = 5,
    SCS_Normal = 6,
    SCS_BaseColor = 7,
    SCS_FinalColorHDR = 8,
    SCS_FinalToneCurveHDR = 9,
    SCS_MAX = 10,
};

enum class ESceneCaptureUnlitViewmode {
    Disabled = 0,
    Capture = 1,
    CaptureOrCustomRenderPass = 2,
    ESceneCaptureUnlitViewmode_MAX = 3,
};

enum class ESceneDepthPriorityGroup {
    SDPG_World = 0,
    SDPG_Foreground = 1,
    SDPG_MAX = 2,
};

enum class ESceneTextureId {
    PPI_SceneColor = 0,
    PPI_SceneDepth = 1,
    PPI_DiffuseColor = 2,
    PPI_SpecularColor = 3,
    PPI_SubsurfaceColor = 4,
    PPI_BaseColor = 5,
    PPI_Specular = 6,
    PPI_Metallic = 7,
    PPI_WorldNormal = 8,
    PPI_SeparateTranslucency = 9,
    PPI_Opacity = 10,
    PPI_Roughness = 11,
    PPI_MaterialAO = 12,
    PPI_CustomDepth = 13,
    PPI_PostProcessInput0 = 14,
    PPI_PostProcessInput1 = 15,
    PPI_PostProcessInput2 = 16,
    PPI_PostProcessInput3 = 17,
    PPI_PostProcessInput4 = 18,
    PPI_PostProcessInput5 = 19,
    PPI_PostProcessInput6 = 20,
    PPI_DecalMask = 21,
    PPI_ShadingModelColor = 22,
    PPI_ShadingModelID = 23,
    PPI_AmbientOcclusion = 24,
    PPI_CustomStencil = 25,
    PPI_StoredBaseColor = 26,
    PPI_StoredSpecular = 27,
    PPI_Velocity = 28,
    PPI_WorldTangent = 29,
    PPI_Anisotropy = 30,
    PPI_IsFirstPerson = 31,
    PPI_UserSceneTexture0 = 32,
    PPI_UserSceneTexture1 = 33,
    PPI_UserSceneTexture2 = 34,
    PPI_UserSceneTexture3 = 35,
    PPI_UserSceneTexture4 = 36,
    PPI_UserSceneTexture5 = 37,
    PPI_UserSceneTexture6 = 38,
    PPI_MAX = 39,
};

enum class EScreenOrientation {
    Unknown = 0,
    Portrait = 1,
    PortraitUpsideDown = 2,
    LandscapeLeft = 3,
    LandscapeRight = 4,
    FaceUp = 5,
    FaceDown = 6,
    PortraitSensor = 7,
    LandscapeSensor = 8,
    FullSensor = 9,
    EScreenOrientation_MAX = 10,
};

enum class EScreenPercentageMode {
    Manual = 0,
    BasedOnDisplayResolution = 1,
    BasedOnDPIScale = 2,
    EScreenPercentageMode_MAX = 3,
};

enum class ESendLevelControlMethod {
    Linear = 0,
    CustomCurve = 1,
    Manual = 2,
    ESendLevelControlMethod_MAX = 3,
};

enum class ESettingsDOF {
    Full3D = 0,
    YZPlane = 1,
    XZPlane = 2,
    XYPlane = 3,
    ESettingsDOF_MAX = 4,
};

enum class ESettingsLockedAxis {
    None = 0,
    X = 1,
    Y = 2,
    Z = 3,
    Invalid = 4,
    ESettingsLockedAxis_MAX = 5,
};

enum class EShaderCompressionFormat {
    None = 0,
    LZ4 = 1,
    Oodle = 2,
    Zlib = 3,
    EShaderCompressionFormat_MAX = 4,
};

enum class EShadowCacheInvalidationBehavior {
    Auto = 0,
    Always = 1,
    Rigid = 2,
    Static = 3,
    EShadowCacheInvalidationBehavior_MAX = 4,
};

enum class EShadowMapFlags {
    SMF_None = 0,
    SMF_Streamed = 1,
    SMF_MAX = 2,
};

enum class EShadowMapMethod {
    ShadowMaps = 0,
    VirtualShadowMaps = 1,
    EShadowMapMethod_MAX = 2,
};

enum class EShouldCookBlueprintPropertyGuids {
    No = 0,
    Yes = 1,
    Inherit = 2,
    EShouldCookBlueprintPropertyGuids_MAX = 3,
};

enum class ESkeletalMeshAsyncProperties {
    None = 0,
    Materials = 1,
    Skeleton = 2,
    RefSkeleton = 4,
    RetargetBasePose = 8,
    RefBasesInvMatrix = 16,
    MeshClothingAssets = 32,
    SourceModels = 64,
    HasActiveClothingAssets = 128,
    LODSettings = 256,
    HasVertexColors = 512,
    VertexColorGuid = 1024,
    MorphTargets = 2048,
    SkeletalMeshRenderData = 4096,
    MeshEditorDataObject = 8192,
    NeverStream = 16384,
    OverrideLODStreamingSettings = 32768,
    SupportLODStreaming = 65536,
    MaxNumStreamedLODs = 131072,
    MaxNumOptionalLODs = 262144,
    ImportedModel = 524288,
    LODInfo = 1048576,
    SkinWeightProfiles = 2097152,
    CachedComposedRefPoseMatrices = 4194304,
    SamplingInfo = 8388608,
    NodeMappingData = 16777216,
    ShadowPhysicsAsset = 33554432,
    SkelMirrorTable = 67108864,
    MinLod = 134217728,
    DisableBelowMinLodStripping = 268435456,
    SkelMirrorAxis = 536870912,
    SkelMirrorFlipAxis = 1073741824,
    DefaultAnimationRig = 2147483648,
    NegativeBoundsExtension = 4294967296,
    PositiveBoundsExtension = 8589934592,
    ExtendedBounds = 17179869184,
    EnablePerPolyCollision = 68719476736,
    BodySetup = 137438953472,
    MorphTargetIndexMap = 274877906944,
    FloorOffset = 549755813888,
    ImportedBounds = 1099511627776,
    PhysicsAsset = 2199023255552,
    AssetImportData = 4398046511104,
    ThumbnailInfo = 8796093022208,
    HasCustomDefaultEditorCamera = 17592186044416,
    DefaultEditorCameraLocation = 35184372088832,
    DefaultEditorCameraRotation = 70368744177664,
    RequiresLODScreenSizeConversion = 140737488355328,
    PostProcessAnimBlueprint = 281474976710656,
    DefaultEditorCameraLookAt = 562949953421312,
    PreviewAttachedAssetContainer = 1125899906842624,
    DefaultEditorCameraOrthoZoom = 2251799813685248,
    RequiresLODHysteresisConversion = 4503599627370496,
    bSupportRayTracing = 9007199254740992,
    RayTracingMinLOD = 18014398509481984,
    ClothLODBiasMode = 36028797018963968,
    DefaultMeshDeformer = 72057594037927936,
    OverlayMaterial = 144115188075855872,
    OverlayMaterialMaxDrawDistance = 288230376151711744,
    TargetMeshDeformers = 576460752303423488,
    All = -1,
    ESkeletalMeshAsyncProperties_MAX = 576460752303423489,
};

enum class ESkeletalMeshVertexAttributeDataType {
    Float = 0,
    HalfFloat = 1,
    NUInt8 = 2,
    ESkeletalMeshVertexAttributeDataType_MAX = 3,
};

enum class ESkinCacheDefaultBehavior {
    Exclusive = 0,
    Inclusive = 1,
    ESkinCacheDefaultBehavior_MAX = 2,
};

enum class ESkinCacheUsage {
    Auto = 0,
    Disabled = 255,
    Enabled = 1,
    ESkinCacheUsage_MAX = 256,
};

enum class ESkinWeightProfileLayer {
    Primary = 0,
    Secondary = 1,
    ESkinWeightProfileLayer_MAX = 2,
};

enum class ESkyAtmosphereTransformMode {
    PlanetTopAtAbsoluteWorldOrigin = 0,
    PlanetTopAtComponentTransform = 1,
    PlanetCenterAtComponentTransform = 2,
    ESkyAtmosphereTransformMode_MAX = 3,
};

enum class ESkyLightSourceType {
    SLS_CapturedScene = 0,
    SLS_SpecifiedCubemap = 1,
    SLS_MAX = 2,
};

enum class ESlateGesture {
    None = 0,
    Scroll = 1,
    Magnify = 2,
    Swipe = 3,
    Rotate = 4,
    LongPress = 5,
    ESlateGesture_MAX = 6,
};

enum class ESoundAssetCompressionType {
    BinkAudio = 0,
    ADPCM = 1,
    PCM = 2,
    Opus = 3,
    PlatformSpecific = 4,
    ProjectDefined = 5,
    RADAudio = 6,
    ESoundAssetCompressionType_MAX = 7,
};

enum class ESoundDistanceCalc {
    SOUNDDISTANCE_Normal = 0,
    SOUNDDISTANCE_InfiniteXYPlane = 1,
    SOUNDDISTANCE_InfiniteXZPlane = 2,
    SOUNDDISTANCE_InfiniteYZPlane = 3,
    SOUNDDISTANCE_MAX = 4,
};

enum class ESoundGroup {
    SOUNDGROUP_Default = 0,
    SOUNDGROUP_Effects = 1,
    SOUNDGROUP_UI = 2,
    SOUNDGROUP_Music = 3,
    SOUNDGROUP_Voice = 4,
    SOUNDGROUP_GameSoundGroup1 = 5,
    SOUNDGROUP_GameSoundGroup2 = 6,
    SOUNDGROUP_GameSoundGroup3 = 7,
    SOUNDGROUP_GameSoundGroup4 = 8,
    SOUNDGROUP_GameSoundGroup5 = 9,
    SOUNDGROUP_GameSoundGroup6 = 10,
    SOUNDGROUP_GameSoundGroup7 = 11,
    SOUNDGROUP_GameSoundGroup8 = 12,
    SOUNDGROUP_GameSoundGroup9 = 13,
    SOUNDGROUP_GameSoundGroup10 = 14,
    SOUNDGROUP_GameSoundGroup11 = 15,
    SOUNDGROUP_GameSoundGroup12 = 16,
    SOUNDGROUP_GameSoundGroup13 = 17,
    SOUNDGROUP_GameSoundGroup14 = 18,
    SOUNDGROUP_GameSoundGroup15 = 19,
    SOUNDGROUP_GameSoundGroup16 = 20,
    SOUNDGROUP_GameSoundGroup17 = 21,
    SOUNDGROUP_GameSoundGroup18 = 22,
    SOUNDGROUP_GameSoundGroup19 = 23,
    SOUNDGROUP_GameSoundGroup20 = 24,
    SOUNDGROUP_MAX = 25,
};

enum class ESoundSpatializationAlgorithm {
    SPATIALIZATION_Default = 0,
    SPATIALIZATION_HRTF = 1,
    SPATIALIZATION_MAX = 2,
};

enum class ESoundWaveCuePointOrigin {
    WaveFile = 0,
    MarkerTransformation = 1,
    ESoundWaveCuePointOrigin_MAX = 2,
};

enum class ESoundWaveFFTSize {
    VerySmall_64 = 0,
    Small_256 = 1,
    Medium_512 = 2,
    Large_1024 = 3,
    VeryLarge_2048 = 4,
    ESoundWaveFFTSize_MAX = 5,
};

enum class ESoundWaveLoadingBehavior {
    Inherited = 0,
    RetainOnLoad = 1,
    PrimeOnLoad = 2,
    LoadOnDemand = 3,
    ForceInline = 4,
    Uninitialized = 255,
    ESoundWaveLoadingBehavior_MAX = 256,
};

enum class ESourceBusChannels {
    Mono = 0,
    Stereo = 1,
    ESourceBusChannels_MAX = 2,
};

enum class ESourceBusSendLevelControlMethod {
    Linear = 0,
    CustomCurve = 1,
    Manual = 2,
    ESourceBusSendLevelControlMethod_MAX = 3,
};

enum class ESpawnActorCollisionHandlingMethod {
    Undefined = 0,
    AlwaysSpawn = 1,
    AdjustIfPossibleButAlwaysSpawn = 2,
    AdjustIfPossibleButDontSpawnIfColliding = 3,
    DontSpawnIfColliding = 4,
    ESpawnActorCollisionHandlingMethod_MAX = 5,
};

enum class ESpawnActorScaleMethod {
    OverrideRootScale = 0,
    MultiplyWithRoot = 1,
    SelectDefaultAtRuntime = 2,
    ESpawnActorScaleMethod_MAX = 3,
};

enum class ESpecularProfileFormat {
    ViewLightVector = 0,
    HalfVector = 1,
    ESpecularProfileFormat_MAX = 2,
};

enum class ESpeedTreeGeometryType {
    STG_Branch = 0,
    STG_Frond = 1,
    STG_Leaf = 2,
    STG_FacingLeaf = 3,
    STG_Billboard = 4,
    STG_MAX = 5,
};

enum class ESpeedTreeLODType {
    STLOD_Pop = 0,
    STLOD_Smooth = 1,
    STLOD_MAX = 2,
};

enum class ESpeedTreeWindType {
    STW_None = 0,
    STW_Fastest = 1,
    STW_Fast = 2,
    STW_Better = 3,
    STW_Best = 4,
    STW_Palm = 5,
    STW_BestPlus = 6,
    STW_MAX = 7,
};

enum class ESplineCoordinateSpace {
    Local = 0,
    World = 1,
    ESplineCoordinateSpace_MAX = 2,
};

enum class ESplineMeshAxis {
    X = 0,
    Y = 1,
    Z = 2,
    ESplineMeshAxis_MAX = 3,
};

enum class ESplinePointType {
    Linear = 0,
    Curve = 1,
    Constant = 2,
    CurveClamped = 3,
    CurveCustomTangent = 4,
    ESplinePointType_MAX = 5,
};

enum class ESplitScreenType {
    None = 0,
    TwoPlayer_Horizontal = 1,
    TwoPlayer_Vertical = 2,
    ThreePlayer_FavorTop = 3,
    ThreePlayer_FavorBottom = 4,
    ThreePlayer_Vertical = 5,
    ThreePlayer_Horizontal = 6,
    FourPlayer_Grid = 7,
    FourPlayer_Vertical = 8,
    FourPlayer_Horizontal = 9,
    SplitTypeCount = 10,
    ESplitScreenType_MAX = 11,
};

enum class EStandbyType {
    STDBY_Rx = 0,
    STDBY_Tx = 1,
    STDBY_BadPing = 2,
    STDBY_MAX = 3,
};

enum class EStaticMeshPaintSupport {
    Default = 0,
    Enabled = 1,
    Disabled = 2,
    EStaticMeshPaintSupport_MAX = 3,
};

enum class EStaticMeshReductionTerimationCriterion {
    Triangles = 0,
    Vertices = 1,
    Any = 2,
    EStaticMeshReductionTerimationCriterion_MAX = 3,
};

enum class EStereoLayerShape {
    SLSH_QuadLayer = 0,
    SLSH_CylinderLayer = 1,
    SLSH_CubemapLayer = 2,
    SLSH_EquirectLayer = 3,
    SLSH_MAX = 4,
};

enum class EStereoLayerType {
    SLT_WorldLocked = 0,
    SLT_TrackerLocked = 1,
    SLT_FaceLocked = 2,
    SLT_MAX = 3,
};

enum class EStreamingSourcePriority {
    Highest = 0,
    High = 64,
    Normal = 128,
    Low = 192,
    Lowest = 255,
    Default = 128,
    EStreamingSourcePriority_MAX = 256,
};

enum class EStreamingSourceTargetBehavior {
    Include = 0,
    Exclude = 1,
    EStreamingSourceTargetBehavior_MAX = 2,
};

enum class EStreamingSourceTargetState {
    Loaded = 0,
    Activated = 1,
    EStreamingSourceTargetState_MAX = 2,
};

enum class EStreamingVolumeUsage {
    SVB_Loading = 0,
    SVB_LoadingAndVisibility = 1,
    SVB_VisibilityBlockingOnLoad = 2,
    SVB_BlockingOnLoad = 3,
    SVB_LoadingNotVisible = 4,
    SVB_MAX = 5,
};

enum class EStripAnimDataOnDedicatedServerSettings {
    UseProjectSetting = 0,
    StripAnimDataOnDedicatedServer = 1,
    DoNotStripAnimDataOnDedicatedServer = 2,
    EStripAnimDataOnDedicatedServerSettings_MAX = 3,
};

enum class EStructUtilsResult {
    Valid = 0,
    NotValid = 1,
    EStructUtilsResult_MAX = 2,
};

enum class ESubUVBoundingVertexCount {
    BVC_FourVertices = 0,
    BVC_EightVertices = 1,
    BVC_MAX = 2,
};

enum class ESubmixSendStage {
    PostDistanceAttenuation = 0,
    PreDistanceAttenuation = 1,
    ESubmixSendStage_MAX = 2,
};

enum class ESubsurfaceImplementationTechniqueHint {
    SIH_AFIS = 0,
    SIH_Separable = 1,
    SIH_MAX = 2,
};

enum class ESubtitleTiming {
    InternallyTimed = 0,
    ExternallyTimed = 1,
    ESubtitleTiming_MAX = 2,
};

enum class ESubtitleType {
    Subtitle = 0,
    ClosedCaption = 1,
    AudioDescription = 2,
    ESubtitleType_MAX = 3,
};

enum class ESuggestProjVelocityTraceOption {
    DoNotTrace = 0,
    TraceFullPath = 1,
    OnlyTraceWhileAscending = 2,
    ESuggestProjVelocityTraceOption_MAX = 3,
};

enum class ESwitchMaterialOutputType {
    TMMOT_Float1 = 0,
    TMMOT_Float2 = 1,
    TMMOT_Float3 = 2,
    TMMOT_Float4 = 3,
    TMMOT_MAX = 4,
};

enum class ESyncOption {
    Drive = 0,
    Passive = 1,
    Disabled = 2,
    ESyncOption_MAX = 3,
};

enum class ESyncPointActivationRules {
    Invalid = 0,
    AlwaysActivate = 1,
    WaitForTrigger = 2,
    WaitForAllWork = 3,
    ActivateForAnyWork = 4,
    ESyncPointActivationRules_MAX = 5,
};

enum class ESyncPointEventType {
    Invalid = 0,
    SimpleEvent = 1,
    GameThreadTask = 2,
    GameThreadTask_HighPriority = 3,
    WorkerThreadTask = 4,
    WorkerThreadTask_HighPriority = 5,
    ESyncPointEventType_MAX = 6,
};

enum class ETeleportType {
    None = 0,
    TeleportPhysics = 1,
    ResetPhysics = 2,
    ETeleportType_MAX = 3,
};

enum class ETemperatureMethod {
    TEMP_WhiteBalance = 0,
    TEMP_ColorTemperature = 1,
    TEMP_MAX = 2,
};

enum class ETemperatureSeverityType {
    Unknown = 0,
    Good = 1,
    Bad = 2,
    Serious = 3,
    Critical = 4,
    NumSeverities = 5,
    ETemperatureSeverityType_MAX = 6,
};

enum class ETextGender {
    Masculine = 0,
    Feminine = 1,
    Neuter = 2,
    ETextGender_MAX = 3,
};

enum class ETextImportTestFlags {
    Default = 0,
    FlagA = 1,
    FlagB = 2,
    FlagC = 4,
    FlagD = 8,
    FlagE = 16,
    TestStructDefault = 32,
    ETextImportTestFlags_MAX = 64,
};

enum class ETextureAvailability {
    GPU = 0,
    CPU = 1,
    ETextureAvailability_MAX = 2,
};

enum class ETextureChromaticAdaptationMethod {
    TCAM_None = 0,
    TCAM_Bradford = 1,
    TCAM_CAT02 = 2,
    TCAM_MAX = 3,
};

enum class ETextureClass {
    Invalid = 0,
    TwoD = 1,
    Cube = 2,
    Array = 3,
    CubeArray = 4,
    Volume = 5,
    TwoDDynamic = 6,
    RenderTarget = 7,
    Other2DNoSource = 8,
    OtherUnknown = 9,
    ETextureClass_MAX = 10,
};

enum class ETextureCollectionMemberType {
    Texture2D = 0,
    TextureCube = 1,
    Texture2DArray = 2,
    TextureCubeArray = 3,
    TextureVolume = 4,
    Max = 5,
};

enum class ETextureColorChannel {
    TCC_Red = 0,
    TCC_Green = 1,
    TCC_Blue = 2,
    TCC_Alpha = 3,
    TCC_MAX = 4,
};

enum class ETextureColorSpace {
    TCS_None = 0,
    TCS_sRGB = 1,
    TCS_Rec2020 = 2,
    TCS_ACESAP0 = 3,
    TCS_ACESAP1 = 4,
    TCS_P3DCI = 5,
    TCS_P3D65 = 6,
    TCS_REDWideGamut = 7,
    TCS_SonySGamut3 = 8,
    TCS_SonySGamut3Cine = 9,
    TCS_AlexaWideGamut = 10,
    TCS_CanonCinemaGamut = 11,
    TCS_GoProProtuneNative = 12,
    TCS_PanasonicVGamut = 13,
    TCS_Custom = 99,
    TCS_MAX = 100,
};

enum class ETextureCompressionQuality {
    TCQ_Default = 0,
    TCQ_Lowest = 1,
    TCQ_Low = 2,
    TCQ_Medium = 3,
    TCQ_High = 4,
    TCQ_Highest = 5,
    TCQ_MAX = 6,
};

enum class ETextureDownscaleOptions {
    Default = 0,
    Unfiltered = 1,
    SimpleAverage = 2,
    Sharpen0 = 3,
    Sharpen1 = 4,
    Sharpen2 = 5,
    Sharpen3 = 6,
    Sharpen4 = 7,
    Sharpen5 = 8,
    Sharpen6 = 9,
    Sharpen7 = 10,
    Sharpen8 = 11,
    Sharpen9 = 12,
    Sharpen10 = 13,
    ETextureDownscaleOptions_MAX = 14,
};

enum class ETextureEncodeEffort {
    Default = 0,
    Low = 10,
    Normal = 20,
    High = 30,
    ETextureEncodeEffort_MAX = 31,
};

enum class ETextureEncodeSpeed {
    Final = 0,
    FinalIfAvailable = 1,
    Fast = 2,
    ETextureEncodeSpeed_MAX = 3,
};

enum class ETextureEncodeSpeedOverride {
    Disabled = 255,
    Final = 0,
    FinalIfAvailable = 1,
    Fast = 2,
    ETextureEncodeSpeedOverride_MAX = 256,
};

enum class ETextureGatherMode {
    TGM_None = 0,
    TGM_Red = 1,
    TGM_Green = 2,
    TGM_Blue = 3,
    TGM_Alpha = 4,
    TGM_MAX = 5,
};

enum class ETextureLossyCompressionAmount {
    TLCA_Default = 0,
    TLCA_None = 1,
    TLCA_Lowest = 2,
    TLCA_Low = 3,
    TLCA_Medium = 4,
    TLCA_High = 5,
    TLCA_Highest = 6,
    TLCA_MAX = 7,
};

enum class ETextureMipCount {
    TMC_ResidentMips = 0,
    TMC_AllMips = 1,
    TMC_AllMipsBiased = 2,
    TMC_MAX = 3,
};

enum class ETextureMipLoadOptions {
    Default = 0,
    AllMips = 1,
    OnlyFirstMip = 2,
    ETextureMipLoadOptions_MAX = 3,
};

enum class ETextureMipValueMode {
    TMVM_None = 0,
    TMVM_MipLevel = 1,
    TMVM_MipBias = 2,
    TMVM_Derivative = 3,
    TMVM_MAX = 4,
};

enum class ETexturePowerOfTwoSetting {
    None = 0,
    PadToPowerOfTwo = 1,
    PadToSquarePowerOfTwo = 2,
    StretchToPowerOfTwo = 3,
    StretchToSquarePowerOfTwo = 4,
    ResizeToSpecificResolution = 5,
    ETexturePowerOfTwoSetting_MAX = 6,
};

enum class ETextureRenderTargetFormat {
    RTF_R8 = 0,
    RTF_RG8 = 1,
    RTF_RGBA8 = 2,
    RTF_RGBA8_SRGB = 3,
    RTF_R16f = 4,
    RTF_RG16f = 5,
    RTF_RGBA16f = 6,
    RTF_R32f = 7,
    RTF_RG32f = 8,
    RTF_RGBA32f = 9,
    RTF_RGB10A2 = 10,
    RTF_MAX = 11,
};

enum class ETextureRenderTargetSampleCount {
    RTSC_1 = 0,
    RTSC_2 = 1,
    RTSC_4 = 2,
    RTSC_8 = 3,
    RTSC_MAX = 4,
};

enum class ETextureSamplerFilter {
    Point = 0,
    Bilinear = 1,
    Trilinear = 2,
    AnisotropicPoint = 3,
    AnisotropicLinear = 4,
    ETextureSamplerFilter_MAX = 5,
};

enum class ETextureSizingType {
    TextureSizingType_UseSingleTextureSize = 0,
    TextureSizingType_UseAutomaticBiasedSizes = 1,
    TextureSizingType_UseManualOverrideTextureSize = 2,
    TextureSizingType_UseSimplygonAutomaticSizing = 3,
    TextureSizingType_AutomaticFromTexelDensity = 4,
    TextureSizingType_AutomaticFromMeshScreenSize = 5,
    TextureSizingType_AutomaticFromMeshDrawDistance = 6,
    TextureSizingType_MAX = 7,
};

enum class ETextureSourceCompressionFormat {
    TSCF_None = 0,
    TSCF_PNG = 1,
    TSCF_JPEG = 2,
    TSCF_UEJPEG = 3,
    TSCF_UEDELTA = 4,
    TSCF_MAX = 5,
};

enum class ETextureSourceEncoding {
    TSE_None = 0,
    TSE_Linear = 1,
    TSE_sRGB = 2,
    TSE_ST2084 = 3,
    TSE_Gamma22 = 4,
    TSE_BT1886 = 5,
    TSE_Gamma26 = 6,
    TSE_Cineon = 7,
    TSE_REDLog = 8,
    TSE_REDLog3G10 = 9,
    TSE_SLog1 = 10,
    TSE_SLog2 = 11,
    TSE_SLog3 = 12,
    TSE_AlexaV3LogC = 13,
    TSE_CanonLog = 14,
    TSE_ProTune = 15,
    TSE_VLog = 16,
    TSE_MAX = 17,
};

enum class ETextureSourceFormat {
    TSF_Invalid = 0,
    TSF_G8 = 1,
    TSF_BGRA8 = 2,
    TSF_BGRE8 = 3,
    TSF_RGBA16 = 4,
    TSF_RGBA16F = 5,
    TSF_RGBA8_DEPRECATED = 6,
    TSF_RGBE8_DEPRECATED = 7,
    TSF_G16 = 8,
    TSF_RGBA32F = 9,
    TSF_R16F = 10,
    TSF_R32F = 11,
    TSF_MAX = 12,
};

enum class ETextureUniversalTiling {
    Disabled = 0,
    Enabled_256KB = 1,
    Enabled_64KB = 2,
    ETextureUniversalTiling_MAX = 3,
};

enum class ETickingGroup {
    TG_PrePhysics = 0,
    TG_StartPhysics = 1,
    TG_DuringPhysics = 2,
    TG_EndPhysics = 3,
    TG_PostPhysics = 4,
    TG_PostUpdateWork = 5,
    TG_LastDemotable = 6,
    TG_NewlySpawned = 7,
    TG_MAX = 8,
};

enum class ETileOverlapResolveType {
    Ignore = 0,
    Feathering = 1,
    ETileOverlapResolveType_MAX = 2,
};

enum class ETimeStretchCurveMapping {
    T_Original = 0,
    T_TargetMin = 1,
    T_TargetMax = 2,
    MAX = 3,
};

enum class ETimecodeProviderSynchronizationState {
    Closed = 0,
    Error = 1,
    Synchronized = 2,
    Synchronizing = 3,
    ETimecodeProviderSynchronizationState_MAX = 4,
};

enum class ETimelineDirection {
    Forward = 0,
    Backward = 1,
    ETimelineDirection_MAX = 2,
};

enum class ETimelineLengthMode {
    TL_TimelineLength = 0,
    TL_LastKeyFrame = 1,
    TL_MAX = 2,
};

enum class ETimelineSigType {
    ETS_EventSignature = 0,
    ETS_FloatSignature = 1,
    ETS_VectorSignature = 2,
    ETS_LinearColorSignature = 3,
    ETS_InvalidSignature = 4,
    ETS_MAX = 5,
};

enum class ETraceTypeQuery {
    TraceTypeQuery1 = 0,
    TraceTypeQuery2 = 1,
    TraceTypeQuery3 = 2,
    TraceTypeQuery4 = 3,
    TraceTypeQuery5 = 4,
    TraceTypeQuery6 = 5,
    TraceTypeQuery7 = 6,
    TraceTypeQuery8 = 7,
    TraceTypeQuery9 = 8,
    TraceTypeQuery10 = 9,
    TraceTypeQuery11 = 10,
    TraceTypeQuery12 = 11,
    TraceTypeQuery13 = 12,
    TraceTypeQuery14 = 13,
    TraceTypeQuery15 = 14,
    TraceTypeQuery16 = 15,
    TraceTypeQuery17 = 16,
    TraceTypeQuery18 = 17,
    TraceTypeQuery19 = 18,
    TraceTypeQuery20 = 19,
    TraceTypeQuery21 = 20,
    TraceTypeQuery22 = 21,
    TraceTypeQuery23 = 22,
    TraceTypeQuery24 = 23,
    TraceTypeQuery25 = 24,
    TraceTypeQuery26 = 25,
    TraceTypeQuery27 = 26,
    TraceTypeQuery28 = 27,
    TraceTypeQuery29 = 28,
    TraceTypeQuery30 = 29,
    TraceTypeQuery31 = 30,
    TraceTypeQuery32 = 31,
    TraceTypeQuery_MAX = 32,
    ETraceTypeQuery_MAX = 33,
};

enum class ETrail2SourceMethod {
    PET2SRCM_Default = 0,
    PET2SRCM_Particle = 1,
    PET2SRCM_Actor = 2,
    PET2SRCM_MAX = 3,
};

enum class ETrailWidthMode {
    ETrailWidthMode_FromCentre = 0,
    ETrailWidthMode_FromFirst = 1,
    ETrailWidthMode_FromSecond = 2,
    ETrailWidthMode_MAX = 3,
};

enum class ETrailsRenderAxisOption {
    Trails_CameraUp = 0,
    Trails_SourceUp = 1,
    Trails_WorldUp = 2,
    Trails_MAX = 3,
};

enum class ETransformCurveChannel {
    Position = 0,
    Rotation = 1,
    Scale = 2,
    Invalid = 3,
    ETransformCurveChannel_MAX = 4,
};

enum class ETransitionBlendMode {
    TBM_Linear = 0,
    TBM_Cubic = 1,
    TBM_MAX = 2,
};

enum class ETransitionLogicType {
    TLT_StandardBlend = 0,
    TLT_Inertialization = 1,
    TLT_Custom = 2,
    TLT_MAX = 3,
};

enum class ETransitionRequestOverwriteMode {
    Append = 0,
    Ignore = 1,
    Overwrite = 2,
    ETransitionRequestOverwriteMode_MAX = 3,
};

enum class ETransitionRequestQueueMode {
    Shared = 0,
    Unique = 1,
    ETransitionRequestQueueMode_MAX = 2,
};

enum class ETransitionType {
    None = 0,
    Paused = 1,
    Loading = 2,
    Saving = 3,
    Connecting = 4,
    Precaching = 5,
    WaitingToConnect = 6,
    MAX = 7,
};

enum class ETranslucencyLightingMode {
    TLM_VolumetricNonDirectional = 0,
    TLM_VolumetricDirectional = 1,
    TLM_VolumetricPerVertexNonDirectional = 2,
    TLM_VolumetricPerVertexDirectional = 3,
    TLM_Surface = 4,
    TLM_SurfacePerPixelLighting = 5,
    TLM_MAX = 6,
};

enum class ETranslucencyType {
    Raster = 0,
    RayTraced_Deprecated = 1,
    RayTracing = 1,
    RayTraced = 2,
    ETranslucencyType_MAX = 3,
};

enum class ETranslucentSortPolicy {
    SortByDistance = 0,
    SortByProjectedZ = 1,
    SortAlongAxis = 2,
    ETranslucentSortPolicy_MAX = 3,
};

enum class ETravelFailure {
    NoLevel = 0,
    LoadMapFailure = 1,
    InvalidURL = 2,
    PackageMissing = 3,
    PackageVersion = 4,
    NoDownload = 5,
    TravelFailure = 6,
    CheatCommands = 7,
    PendingNetGameCreateFailure = 8,
    CloudSaveFailure = 9,
    ServerTravelFailure = 10,
    ClientTravelFailure = 11,
    ETravelFailure_MAX = 12,
};

enum class ETravelType {
    TRAVEL_Absolute = 0,
    TRAVEL_Partial = 1,
    TRAVEL_Relative = 2,
    TRAVEL_MAX = 3,
};

enum class ETwitterIntegrationDelegate {
    TID_AuthorizeComplete = 0,
    TID_TweetUIComplete = 1,
    TID_RequestComplete = 2,
    TID_MAX = 3,
};

enum class ETwitterRequestMethod {
    TRM_Get = 0,
    TRM_Post = 1,
    TRM_Delete = 2,
    TRM_MAX = 3,
};

enum class ETypeAdvanceAnim {
    ETAA_Default = 0,
    ETAA_Finished = 1,
    ETAA_Looped = 2,
    ETAA_MAX = 3,
};

enum class ETypedElementWorldType {
    Game = 0,
    Editor = 1,
    ETypedElementWorldType_MAX = 2,
};

enum class EUIScalingRule {
    ShortestSide = 0,
    LongestSide = 1,
    Horizontal = 2,
    Vertical = 3,
    ScaleToFit = 4,
    Custom = 5,
    EUIScalingRule_MAX = 6,
};

enum class EUVOutput {
    DoNotOutputChannel = 0,
    OutputChannel = 1,
    EUVOutput_MAX = 2,
};

enum class EUpdateRateShiftBucket {
    ShiftBucket0 = 0,
    ShiftBucket1 = 1,
    ShiftBucket2 = 2,
    ShiftBucket3 = 3,
    ShiftBucket4 = 4,
    ShiftBucket5 = 5,
    ShiftBucketMax = 6,
    EUpdateRateShiftBucket_MAX = 7,
};

enum class EVectorCurveChannel {
    X = 0,
    Y = 1,
    Z = 2,
    Invalid = 3,
    EVectorCurveChannel_MAX = 4,
};

enum class EVectorFieldConstructionOp {
    VFCO_Extrude = 0,
    VFCO_Revolve = 1,
    VFCO_MAX = 2,
};

enum class EVectorNoiseFunction {
    VNF_CellnoiseALU = 0,
    VNF_VectorALU = 1,
    VNF_GradientALU = 2,
    VNF_CurlALU = 3,
    VNF_VoronoiALU = 4,
    VNF_MAX = 5,
};

enum class EVectorQuantization {
    RoundWholeNumber = 0,
    RoundOneDecimal = 1,
    RoundTwoDecimals = 2,
    EVectorQuantization_MAX = 3,
};

enum class EVelocityOutputPass {
    DepthPass = 0,
    BasePass = 1,
    AfterBasePass = 2,
    EVelocityOutputPass_MAX = 3,
};

enum class EVertexDeformationOutputsVelocity {
    Off = 0,
    On = 1,
    Auto = 2,
    EVertexDeformationOutputsVelocity_MAX = 3,
};

enum class EVertexPaintAxis {
    X = 0,
    Y = 1,
    Z = 2,
    EVertexPaintAxis_MAX = 3,
};

enum class EVerticalTextAligment {
    EVRTA_TextTop = 0,
    EVRTA_TextCenter = 1,
    EVRTA_TextBottom = 2,
    EVRTA_QuadTop = 3,
    EVRTA_MAX = 4,
};

enum class EViewModeIndex {
    VMI_BrushWireframe = 0,
    VMI_Wireframe = 1,
    VMI_Unlit = 2,
    VMI_Lit = 3,
    VMI_Lit_DetailLighting = 4,
    VMI_LightingOnly = 5,
    VMI_LightComplexity = 6,
    VMI_ShaderComplexity = 8,
    VMI_LightmapDensity = 9,
    VMI_LitLightmapDensity = 10,
    VMI_ReflectionOverride = 11,
    VMI_VisualizeBuffer = 12,
    VMI_StationaryLightOverlap = 14,
    VMI_CollisionPawn = 15,
    VMI_CollisionVisibility = 16,
    VMI_LODColoration = 18,
    VMI_QuadOverdraw = 19,
    VMI_PrimitiveDistanceAccuracy = 20,
    VMI_MeshUVDensityAccuracy = 21,
    VMI_ShaderComplexityWithQuadOverdraw = 22,
    VMI_HLODColoration = 23,
    VMI_GroupLODColoration = 24,
    VMI_MaterialTextureScaleAccuracy = 25,
    VMI_RequiredTextureResolution = 26,
    VMI_PathTracing = 27,
    VMI_RayTracingDebug = 28,
    VMI_VisualizeNanite = 29,
    VMI_VisualizeVirtualTexture = 30,
    VMI_VisualizeLumen = 31,
    VMI_VisualizeVirtualShadowMap = 32,
    VMI_VisualizeGPUSkinCache = 33,
    VMI_VisualizeSubstrate = 34,
    VMI_VisualizeGroom = 35,
    VMI_LWCComplexity = 36,
    VMI_Lit_Wireframe = 37,
    VMI_VisualizeActorColoration = 38,
    VMI_Max = 39,
    VMI_Unknown = 255,
};

enum class EViewStatusForScreenPercentage {
    NonRealtime = 0,
    Desktop = 1,
    Mobile = 2,
    VR = 3,
    PathTracer = 4,
    EViewStatusForScreenPercentage_MAX = 5,
};

enum class EViewTargetBlendFunction {
    VTBlend_Linear = 0,
    VTBlend_Cubic = 1,
    VTBlend_EaseIn = 2,
    VTBlend_EaseOut = 3,
    VTBlend_EaseInOut = 4,
    VTBlend_PreBlended = 5,
    VTBlend_MAX = 6,
};

enum class EViewTargetBlendOrder {
    VTBlendOrder_Base = 0,
    VTBlendOrder_Override = 1,
    VTBlendOrder_MAX = 2,
};

enum class EVirtualizationMode {
    Disabled = 0,
    PlayWhenSilent = 1,
    Restart = 2,
    SeekRestart = 3,
    EVirtualizationMode_MAX = 4,
};

enum class EVisibilityAggressiveness {
    VIS_LeastAggressive = 0,
    VIS_ModeratelyAggressive = 1,
    VIS_MostAggressive = 2,
    VIS_Max = 3,
};

enum class EVisibilityBasedAnimTickOption {
    AlwaysTickPoseAndRefreshBones = 0,
    AlwaysTickPose = 1,
    OnlyTickMontagesAndRefreshBonesWhenPlayingMontages = 2,
    OnlyTickMontagesWhenNotRendered = 3,
    OnlyTickPoseWhenRendered = 4,
    EVisibilityBasedAnimTickOption_MAX = 5,
};

enum class EVoiceBlockReasons {
    None = 0,
    Muted = 1,
    Gameplay = 2,
    Blocked = 4,
    BlockedBy = 8,
    EVoiceBlockReasons_MAX = 9,
};

enum class EVoiceSampleRate {
    Low16000Hz = 16000,
    Normal24000Hz = 24000,
    EVoiceSampleRate_MAX = 24001,
};

enum class EVolumeLightingMethod {
    VLM_VolumetricLightmap = 0,
    VLM_SparseVolumeLightingSamples = 1,
    VLM_MAX = 2,
};

enum class EVolumetricCloudTracingMaxDistanceMode {
    DistanceFromCloudLayerEntryPoint = 0,
    DistanceFromPointOfView = 1,
    EVolumetricCloudTracingMaxDistanceMode_MAX = 2,
};

enum class EWalkableSlopeBehavior {
    WalkableSlope_Default = 0,
    WalkableSlope_Increase = 1,
    WalkableSlope_Decrease = 2,
    WalkableSlope_Unwalkable = 3,
    WalkableSlope_Max = 4,
};

enum class EWindSourceType {
    Directional = 0,
    Point = 1,
    EWindSourceType_MAX = 2,
};

enum class EWindowMode {
    Fullscreen = 0,
    WindowedFullscreen = 1,
    Windowed = 2,
    EWindowMode_MAX = 3,
};

enum class EWindowTitleBarMode {
    Overlay = 0,
    VerticalBox = 1,
    EWindowTitleBarMode_MAX = 2,
};

enum class EWorkingColorSpace {
    sRGB = 1,
    Rec2020 = 2,
    ACESAP0 = 3,
    ACESAP1 = 4,
    P3DCI = 5,
    P3D65 = 6,
    Custom = 7,
    EWorkingColorSpace_MAX = 8,
};

enum class EWorldContentState {
    NoContent = 0,
    ContentBundleInjected = 1,
    EWorldContentState_MAX = 2,
};

enum class EWorldPartitionCVarProjectDefaultOverride {
    ProjectDefault = 0,
    Disabled = 1,
    Enabled = 2,
    EWorldPartitionCVarProjectDefaultOverride_MAX = 3,
};

enum class EWorldPartitionDataLayersLogicOperator {
    Or = 0,
    And = 1,
    EWorldPartitionDataLayersLogicOperator_MAX = 2,
};

enum class EWorldPartitionRuntimeCellState {
    Unloaded = 0,
    Loaded = 1,
    Activated = 2,
    EWorldPartitionRuntimeCellState_MAX = 3,
};

enum class EWorldPartitionServerStreamingMode {
    ProjectDefault = 0,
    Disabled = 1,
    Enabled = 2,
    EnabledInPIE = 3,
    EWorldPartitionServerStreamingMode_MAX = 4,
};

enum class EWorldPartitionServerStreamingOutMode {
    ProjectDefault = 0,
    Disabled = 1,
    Enabled = 2,
    EWorldPartitionServerStreamingOutMode_MAX = 3,
};

enum class EWorldPartitionStreamingPerformance {
    Good = 0,
    Slow = 1,
    Critical = 2,
    Immediate = 3,
    EWorldPartitionStreamingPerformance_MAX = 4,
};

enum class EWorldPositionIncludedOffsets {
    WPT_Default = 0,
    WPT_ExcludeAllShaderOffsets = 1,
    WPT_CameraRelative = 2,
    WPT_CameraRelativeNoOffsets = 3,
    WPT_MAX = 4,
};

// Size: 0x60
class UEdGraph : public UObject {
    /* 0x0028 */ UClass* Schema;
    /* 0x0030 */ TArray<UEdGraphNode*> Nodes;
    /* 0x0040 */ bool bEditable;
    /* 0x0040 */ bool bAllowDeletion;
    /* 0x0040 */ bool bAllowRenaming;
};

// Size: 0x98
class UEdGraphNode : public UObject {
    /* 0x0038 */ TArray<UEdGraphPin_Deprecated*> DeprecatedPins;
    /* 0x0048 */ int32_t NodePosX;
    /* 0x004c */ int32_t NodePosY;
    /* 0x0050 */ int32_t NodeWidth;
    /* 0x0054 */ int32_t NodeHeight;
    /* 0x0058 */ uint8_t AdvancedPinDisplay;
    /* 0x0059 */ ENodeEnabledState EnabledState;
    /* 0x005b */ bool bDisplayAsDisabled;
    /* 0x005b */ bool bUserSetEnabledState;
    /* 0x005b */ bool bIsIntermediateNode;
    /* 0x005b */ bool bHasCompilerMessage;
    /* 0x0060 */ FString NodeComment;
    /* 0x0070 */ int32_t ErrorType;
    /* 0x0078 */ FString ErrorMsg;
    /* 0x0088 */ FGuid NodeGuid;
};

// Size: 0xb8
class UEdGraphNode_Documentation : public UEdGraphNode {
    /* 0x0098 */ FString Link;
    /* 0x00a8 */ FString Excerpt;
};

// Size: 0x18
struct FEdGraphPinReference {
    /* 0x0000 */ TWeakObjectPtr<UEdGraphNode> OwningNode;
    /* 0x0008 */ FGuid PinId;
};

// Size: 0x58
struct FEdGraphPinType {
    /* 0x0000 */ FName PinCategory;
    /* 0x0008 */ FName PinSubCategory;
    /* 0x0010 */ TWeakObjectPtr<UObject> PinSubCategoryObject;
    /* 0x0018 */ FSimpleMemberReference PinSubCategoryMemberReference;
    /* 0x0038 */ FEdGraphTerminalType PinValueType;
    /* 0x0054 */ EPinContainerType ContainerType;
    /* 0x0055 */ bool bIsArray;
    /* 0x0055 */ bool bIsReference;
    /* 0x0055 */ bool bIsConst;
    /* 0x0055 */ bool bIsWeakPointer;
    /* 0x0055 */ bool bIsUObjectWrapper;
    /* 0x0055 */ bool bSerializeAsSinglePrecisionFloat;
};

// Size: 0x110
class UEdGraphPin_Deprecated : public UObject {
    /* 0x0028 */ FString PinName;
    /* 0x0038 */ FString PinToolTip;
    /* 0x0048 */ uint8_t Direction;
    /* 0x0050 */ FEdGraphPinType PinType;
    /* 0x00a8 */ FString DefaultValue;
    /* 0x00b8 */ FString AutogeneratedDefaultValue;
    /* 0x00c8 */ UObject* DefaultObject;
    /* 0x00d0 */ FText DefaultTextValue;
    /* 0x00e0 */ TArray<UEdGraphPin_Deprecated*> LinkedTo;
    /* 0x00f0 */ TArray<UEdGraphPin_Deprecated*> SubPins;
    /* 0x0100 */ UEdGraphPin_Deprecated* ParentPin;
    /* 0x0108 */ UEdGraphPin_Deprecated* ReferencePassThroughConnection;
};

// Size: 0x28
class UEdGraphSchema : public UObject {
};

// Size: 0xe0
struct FEdGraphSchemaAction {
    /* 0x0008 */ FText MenuDescription;
    /* 0x0018 */ FText TooltipDescription;
    /* 0x0028 */ FText Category;
    /* 0x0038 */ FText Keywords;
    /* 0x0048 */ int32_t Grouping;
    /* 0x004c */ int32_t SectionID;
    /* 0x0050 */ TArray<FString> MenuDescriptionArray;
    /* 0x0060 */ TArray<FString> FullSearchTitlesArray;
    /* 0x0070 */ TArray<FString> FullSearchKeywordsArray;
    /* 0x0080 */ TArray<FString> FullSearchCategoryArray;
    /* 0x0090 */ TArray<FString> LocalizedMenuDescriptionArray;
    /* 0x00a0 */ TArray<FString> LocalizedFullSearchTitlesArray;
    /* 0x00b0 */ TArray<FString> LocalizedFullSearchKeywordsArray;
    /* 0x00c0 */ TArray<FString> LocalizedFullSearchCategoryArray;
    /* 0x00d0 */ FString SearchText;
};

// Size: 0xe8
struct FEdGraphSchemaAction_NewNode : public FEdGraphSchemaAction {
    /* 0x00e0 */ UEdGraphNode* NodeTemplate;
};

// Size: 0x1c
struct FEdGraphTerminalType {
    /* 0x0000 */ FName TerminalCategory;
    /* 0x0008 */ FName TerminalSubCategory;
    /* 0x0010 */ TWeakObjectPtr<UObject> TerminalSubCategoryObject;
    /* 0x0018 */ bool bTerminalIsConst;
    /* 0x0019 */ bool bTerminalIsWeakPointer;
    /* 0x001a */ bool bTerminalIsUObjectWrapper;
};

// Size: 0x38
struct FEditedDocumentInfo {
    /* 0x0000 */ FSoftObjectPath EditedObjectPath;
    /* 0x0020 */ FDeprecateSlateVector2D SavedViewOffset;
    /* 0x0028 */ float SavedZoomAmount;
    /* 0x0030 */ UObject* EditedObject;
};

// Size: 0x18
struct FEditorElement {
    /* 0x0000 */ int32_t Indices[3];
    /* 0x000c */ float Weights[3];
};

// Size: 0x28
class UEditorFlagCollector : public UObject {

    static TArray<FName> GetFlagNames();
};

// Size: 0x38
struct FEditorImportExportTestDefinition {
    /* 0x0000 */ FFilePath ImportFilePath;
    /* 0x0010 */ FString ExportFileExtension;
    /* 0x0020 */ bool bSkipExport;
    /* 0x0028 */ TArray<FImportFactorySettingValues> FactorySettings;
};

// Size: 0x20
struct FEditorImportWorkflowDefinition {
    /* 0x0000 */ FFilePath ImportFilePath;
    /* 0x0010 */ TArray<FImportFactorySettingValues> FactorySettings;
};

// Size: 0x28
struct FEditorMapPerformanceTestDefinition {
    /* 0x0000 */ FSoftObjectPath PerformanceTestmap;
    /* 0x0020 */ int32_t TestTimer;
};

// Size: 0x2f8
class AEmitter : public AActor {
    /* 0x02a8 */ UParticleSystemComponent* ParticleSystemComponent;
    /* 0x02b0 */ bool bDestroyOnSystemFinish;
    /* 0x02b0 */ bool bPostUpdateTickGroup;
    /* 0x02b0 */ bool bCurrentlyActive;
    /* 0x02b8 */ FMulticastInlineDelegate OnParticleSpawn;
    /* 0x02c8 */ FMulticastInlineDelegate OnParticleBurst;
    /* 0x02d8 */ FMulticastInlineDelegate OnParticleDeath;
    /* 0x02e8 */ FMulticastInlineDelegate OnParticleCollide;

    void Activate();
    void Deactivate();
    bool IsActive() const;
    void OnParticleSystemFinished(UParticleSystemComponent* FinishedComponent);
    void OnRep_bCurrentlyActive();
    void SetActorParameter(FName ParameterName, AActor* Param);
    void SetColorParameter(FName ParameterName, FLinearColor Param);
    void SetFloatParameter(FName ParameterName, float Param);
    void SetMaterialParameter(FName ParameterName, UMaterialInterface* Param);
    void SetTemplate(UParticleSystem* NewTemplate);
    void SetVectorParameter(FName ParameterName, FVector Param);
    void ToggleActive();
};

// Size: 0x390
class AEmitterCameraLensEffectBase : public AEmitter {
    /* 0x0300 */ UParticleSystem* PS_CameraEffect;
    /* 0x0308 */ APlayerCameraManager* BaseCamera;
    /* 0x0310 */ FTransform RelativeTransform;
    /* 0x0370 */ float BaseFOV;
    /* 0x0374 */ bool bAllowMultipleInstances;
    /* 0x0374 */ bool bResetWhenRetriggered;
    /* 0x0378 */ TArray<UClass*> EmittersToTreatAsSame;
    /* 0x0388 */ float DistFromCamera;
};

// Size: 0x48
struct FEmitterDynamicParameter {
    /* 0x0000 */ FName paramName;
    /* 0x0008 */ bool bUseEmitterTime;
    /* 0x0008 */ bool bSpawnTimeOnly;
    /* 0x000c */ uint8_t ValueMethod;
    /* 0x0010 */ bool bScaleVelocityByParamValue;
    /* 0x0018 */ FRawDistributionFloat ParamValue;
};

// Size: 0x1
struct FEmptyPayload {
};

// Size: 0x30
struct FEncounteredStateMachineStack {
};

// Size: 0x30
struct FEndPhysicsTickFunction : public FTickFunction {
};

// Size: 0xa8
class UEndpointSubmix : public USoundSubmixBase {
    /* 0x0090 */ FName EndpointType;
    /* 0x0098 */ UClass* EndpointSettingsClass;
    /* 0x00a0 */ UAudioEndpointSettingsBase* EndpointSettings;
};

// Size: 0x1240
class UEngine : public UObject {
    /* 0x0030 */ UFont* TinyFont;
    /* 0x0038 */ FSoftObjectPath TinyFontName;
    /* 0x0058 */ UFont* SmallFont;
    /* 0x0060 */ FSoftObjectPath SmallFontName;
    /* 0x0080 */ UFont* MediumFont;
    /* 0x0088 */ FSoftObjectPath MediumFontName;
    /* 0x00a8 */ UFont* LargeFont;
    /* 0x00b0 */ FSoftObjectPath LargeFontName;
    /* 0x00d0 */ UFont* SubtitleFont;
    /* 0x00d8 */ FSoftObjectPath SubtitleFontName;
    /* 0x00f8 */ TArray<UFont*> AdditionalFonts;
    /* 0x0108 */ TArray<FString> AdditionalFontNames;
    /* 0x0118 */ UClass* ConsoleClass;
    /* 0x0120 */ FSoftClassPath ConsoleClassName;
    /* 0x0140 */ UClass* GameViewportClientClass;
    /* 0x0148 */ FSoftClassPath GameViewportClientClassName;
    /* 0x0168 */ UClass* LocalPlayerClass;
    /* 0x0170 */ FSoftClassPath LocalPlayerClassName;
    /* 0x0190 */ UClass* WorldSettingsClass;
    /* 0x0198 */ FSoftClassPath WorldSettingsClassName;
    /* 0x01b8 */ FSoftClassPath NavigationSystemClassName;
    /* 0x01d8 */ UClass* NavigationSystemClass;
    /* 0x01e0 */ FSoftClassPath NavigationSystemConfigClassName;
    /* 0x0200 */ UClass* NavigationSystemConfigClass;
    /* 0x0208 */ FSoftClassPath AvoidanceManagerClassName;
    /* 0x0228 */ UClass* AvoidanceManagerClass;
    /* 0x0230 */ FSoftClassPath AIControllerClassName;
    /* 0x0250 */ UClass* PhysicsCollisionHandlerClass;
    /* 0x0258 */ FSoftClassPath PhysicsCollisionHandlerClassName;
    /* 0x0278 */ FSoftClassPath GameUserSettingsClassName;
    /* 0x0298 */ UClass* GameUserSettingsClass;
    /* 0x02a0 */ UGameUserSettings* GameUserSettings;
    /* 0x02a8 */ UClass* LevelScriptActorClass;
    /* 0x02b0 */ FSoftClassPath LevelScriptActorClassName;
    /* 0x02d0 */ FSoftClassPath DefaultBlueprintBaseClassName;
    /* 0x02f0 */ FSoftClassPath GameSingletonClassName;
    /* 0x0310 */ UObject* GameSingleton;
    /* 0x0318 */ FSoftClassPath AssetManagerClassName;
    /* 0x0338 */ UAssetManager* AssetManager;
    /* 0x0340 */ UTexture2D* DefaultTexture;
    /* 0x0348 */ FSoftObjectPath DefaultTextureName;
    /* 0x0368 */ UTexture* DefaultDiffuseTexture;
    /* 0x0370 */ FSoftObjectPath DefaultDiffuseTextureName;
    /* 0x0390 */ UTexture2D* DefaultBSPVertexTexture;
    /* 0x0398 */ FSoftObjectPath DefaultBSPVertexTextureName;
    /* 0x03b8 */ UTexture2D* HighFrequencyNoiseTexture;
    /* 0x03c0 */ FSoftObjectPath HighFrequencyNoiseTextureName;
    /* 0x03e0 */ UTexture2D* DefaultBokehTexture;
    /* 0x03e8 */ FSoftObjectPath DefaultBokehTextureName;
    /* 0x0408 */ UTexture2D* DefaultBloomKernelTexture;
    /* 0x0410 */ FSoftObjectPath DefaultBloomKernelTextureName;
    /* 0x0430 */ UTexture2D* DefaultFilmGrainTexture;
    /* 0x0438 */ FSoftObjectPath DefaultFilmGrainTextureName;
    /* 0x0458 */ UMaterial* WireframeMaterial;
    /* 0x0460 */ FString WireframeMaterialName;
    /* 0x0470 */ UMaterial* DebugMeshMaterial;
    /* 0x0478 */ FSoftObjectPath DebugMeshMaterialName;
    /* 0x0498 */ UMaterial* NaniteHiddenSectionMaterial;
    /* 0x04a0 */ FString NaniteHiddenSectionMaterialName;
    /* 0x04b0 */ UMaterial* EmissiveMeshMaterial;
    /* 0x04b8 */ FSoftObjectPath EmissiveMeshMaterialName;
    /* 0x04d8 */ UMaterial* LevelColorationLitMaterial;
    /* 0x04e0 */ FString LevelColorationLitMaterialName;
    /* 0x04f0 */ UMaterial* LevelColorationUnlitMaterial;
    /* 0x04f8 */ FString LevelColorationUnlitMaterialName;
    /* 0x0508 */ UMaterial* LightingTexelDensityMaterial;
    /* 0x0510 */ FString LightingTexelDensityName;
    /* 0x0520 */ UMaterial* ShadedLevelColorationLitMaterial;
    /* 0x0528 */ FString ShadedLevelColorationLitMaterialName;
    /* 0x0538 */ UMaterial* ShadedLevelColorationUnlitMaterial;
    /* 0x0540 */ FString ShadedLevelColorationUnlitMaterialName;
    /* 0x0550 */ UMaterial* RemoveSurfaceMaterial;
    /* 0x0558 */ FSoftObjectPath RemoveSurfaceMaterialName;
    /* 0x0578 */ UMaterial* VertexColorMaterial;
    /* 0x0580 */ FString VertexColorMaterialName;
    /* 0x0590 */ UMaterial* VertexColorViewModeMaterial_ColorOnly;
    /* 0x0598 */ FString VertexColorViewModeMaterialName_ColorOnly;
    /* 0x05a8 */ UMaterial* VertexColorViewModeMaterial_AlphaAsColor;
    /* 0x05b0 */ FString VertexColorViewModeMaterialName_AlphaAsColor;
    /* 0x05c0 */ UMaterial* VertexColorViewModeMaterial_RedOnly;
    /* 0x05c8 */ FString VertexColorViewModeMaterialName_RedOnly;
    /* 0x05d8 */ UMaterial* VertexColorViewModeMaterial_GreenOnly;
    /* 0x05e0 */ FString VertexColorViewModeMaterialName_GreenOnly;
    /* 0x05f0 */ UMaterial* VertexColorViewModeMaterial_BlueOnly;
    /* 0x05f8 */ FString VertexColorViewModeMaterialName_BlueOnly;
    /* 0x0608 */ UMaterial* TextureColorViewModeMaterial;
    /* 0x0610 */ FString TextureColorViewModeMaterialName;
    /* 0x0620 */ FSoftObjectPath DefaultZenStreamingTextureName;
    /* 0x0640 */ FSoftObjectPath DebugEditorMaterialName;
    /* 0x0660 */ UMaterial* ConstraintLimitMaterial;
    /* 0x0668 */ UMaterialInstanceDynamic* ConstraintLimitMaterialX;
    /* 0x0670 */ UMaterialInstanceDynamic* ConstraintLimitMaterialXAxis;
    /* 0x0678 */ UMaterialInstanceDynamic* ConstraintLimitMaterialY;
    /* 0x0680 */ UMaterialInstanceDynamic* ConstraintLimitMaterialYAxis;
    /* 0x0688 */ UMaterialInstanceDynamic* ConstraintLimitMaterialZ;
    /* 0x0690 */ UMaterialInstanceDynamic* ConstraintLimitMaterialZAxis;
    /* 0x0698 */ UMaterialInstanceDynamic* ConstraintLimitMaterialPrismatic;
    /* 0x06a0 */ UMaterial* InvalidLightmapSettingsMaterial;
    /* 0x06a8 */ FSoftObjectPath InvalidLightmapSettingsMaterialName;
    /* 0x06c8 */ UMaterial* PreviewShadowsIndicatorMaterial;
    /* 0x06d0 */ FSoftObjectPath PreviewShadowsIndicatorMaterialName;
    /* 0x06f0 */ UMaterial* ArrowMaterial;
    /* 0x06f8 */ UMaterialInstanceDynamic* ArrowMaterialYellow;
    /* 0x0700 */ FSoftObjectPath ArrowMaterialName;
    /* 0x0720 */ FLinearColor LightingOnlyBrightness;
    /* 0x0730 */ TArray<FLinearColor> ShaderComplexityColors;
    /* 0x0740 */ TArray<FLinearColor> QuadComplexityColors;
    /* 0x0750 */ TArray<FLinearColor> LightComplexityColors;
    /* 0x0760 */ TArray<FLinearColor> StationaryLightOverlapColors;
    /* 0x0770 */ TArray<FLinearColor> LODColorationColors;
    /* 0x0780 */ TArray<FLinearColor> HLODColorationColors;
    /* 0x0790 */ TArray<FLinearColor> StreamingAccuracyColors;
    /* 0x07a0 */ FLinearColor GPUSkinCacheVisualizationExcludedColor;
    /* 0x07b0 */ FLinearColor GPUSkinCacheVisualizationIncludedColor;
    /* 0x07c0 */ FLinearColor GPUSkinCacheVisualizationRecomputeTangentsColor;
    /* 0x07d0 */ float GPUSkinCacheVisualizationLowMemoryThresholdInMB;
    /* 0x07d4 */ float GPUSkinCacheVisualizationHighMemoryThresholdInMB;
    /* 0x07d8 */ FLinearColor GPUSkinCacheVisualizationLowMemoryColor;
    /* 0x07e8 */ FLinearColor GPUSkinCacheVisualizationMidMemoryColor;
    /* 0x07f8 */ FLinearColor GPUSkinCacheVisualizationHighMemoryColor;
    /* 0x0808 */ TArray<FLinearColor> GPUSkinCacheVisualizationRayTracingLODOffsetColors;
    /* 0x0818 */ float MaxPixelShaderAdditiveComplexityCount;
    /* 0x081c */ float MaxES3PixelShaderAdditiveComplexityCount;
    /* 0x0820 */ float MinLightMapDensity;
    /* 0x0824 */ float IdealLightMapDensity;
    /* 0x0828 */ float MaxLightMapDensity;
    /* 0x082c */ bool bRenderLightMapDensityGrayscale;
    /* 0x0830 */ float RenderLightMapDensityGrayscaleScale;
    /* 0x0834 */ float RenderLightMapDensityColorScale;
    /* 0x0838 */ FLinearColor LightMapDensityVertexMappedColor;
    /* 0x0848 */ FLinearColor LightMapDensitySelectedColor;
    /* 0x0858 */ TArray<FStatColorMapping> StatColorMappings;
    /* 0x0868 */ UPhysicalMaterial* DefaultPhysMaterial;
    /* 0x0870 */ FSoftObjectPath DefaultPhysMaterialName;
    /* 0x0890 */ UPhysicalMaterial* DefaultDestructiblePhysMaterial;
    /* 0x0898 */ FSoftObjectPath DefaultDestructiblePhysMaterialName;
    /* 0x08b8 */ TArray<FGameNameRedirect> ActiveGameNameRedirects;
    /* 0x08c8 */ TArray<FClassRedirect> ActiveClassRedirects;
    /* 0x08d8 */ TArray<FPluginRedirect> ActivePluginRedirects;
    /* 0x08e8 */ TArray<FStructRedirect> ActiveStructRedirects;
    /* 0x08f8 */ UTexture2D* PreIntegratedSkinBRDFTexture;
    /* 0x0900 */ FSoftObjectPath PreIntegratedSkinBRDFTextureName;
    /* 0x0920 */ UTexture2D* BlueNoiseScalarTexture;
    /* 0x0928 */ UTexture2D* BlueNoiseVec2Texture;
    /* 0x0930 */ FSoftObjectPath BlueNoiseScalarTextureName;
    /* 0x0950 */ FSoftObjectPath BlueNoiseScalarMobileTextureName;
    /* 0x0970 */ FSoftObjectPath BlueNoiseVec2TextureName;
    /* 0x0990 */ UTexture2D* GGXLTCAmpTexture;
    /* 0x0998 */ FSoftObjectPath GGXLTCAmpTextureName;
    /* 0x09b8 */ UTexture2D* GGXLTCMatTexture;
    /* 0x09c0 */ FSoftObjectPath GGXLTCMatTextureName;
    /* 0x09e0 */ UTexture2D* SheenLTCTexture;
    /* 0x09e8 */ FSoftObjectPath SheenLTCTextureName;
    /* 0x0a08 */ UTexture2D* GGXReflectionEnergyTexture;
    /* 0x0a10 */ FSoftObjectPath GGXReflectionEnergyTextureName;
    /* 0x0a30 */ UTexture2D* GGXTransmissionEnergyTexture;
    /* 0x0a38 */ FSoftObjectPath GGXTransmissionEnergyTextureName;
    /* 0x0a58 */ UTexture2D* SheenEnergyTexture;
    /* 0x0a60 */ FSoftObjectPath SheenLegacyEnergyTextureName;
    /* 0x0a80 */ FSoftObjectPath SheenEnergyTextureName;
    /* 0x0aa0 */ UTexture2D* DiffuseEnergyTexture;
    /* 0x0aa8 */ FSoftObjectPath DiffuseEnergyTextureName;
    /* 0x0ac8 */ UTexture2DArray* GlintTexture;
    /* 0x0ad0 */ UTexture2DArray* GlintTexture2;
    /* 0x0ad8 */ FSoftObjectPath GlintTextureName;
    /* 0x0af8 */ FSoftObjectPath GlintTexture2Name;
    /* 0x0b18 */ UVolumeTexture* SimpleVolumeTexture;
    /* 0x0b20 */ FSoftObjectPath SimpleVolumeTextureName;
    /* 0x0b40 */ UVolumeTexture* SimpleVolumeEnvTexture;
    /* 0x0b48 */ FSoftObjectPath SimpleVolumeEnvTextureName;
    /* 0x0b68 */ UTexture2D* MiniFontTexture;
    /* 0x0b70 */ FSoftObjectPath MiniFontTextureName;
    /* 0x0b90 */ UTexture* WeightMapPlaceholderTexture;
    /* 0x0b98 */ UTexture* WeightMapArrayPlaceholderTexture;
    /* 0x0ba0 */ FSoftObjectPath WeightMapPlaceholderTextureName;
    /* 0x0bc0 */ FSoftObjectPath WeightMapArrayPlaceholderTextureName;
    /* 0x0be0 */ UTexture2D* LightMapDensityTexture;
    /* 0x0be8 */ FSoftObjectPath LightMapDensityTextureName;
    /* 0x0c10 */ UGameViewportClient* GameViewport;
    /* 0x0c18 */ TArray<FString> DeferredCommands;
    /* 0x0c28 */ float NearClipPlane;
    /* 0x0c2c */ bool bSubtitlesEnabled;
    /* 0x0c2c */ bool bSubtitlesForcedOff;
    /* 0x0c30 */ int32_t MaximumLoopIterationCount;
    /* 0x0c34 */ bool bCanBlueprintsTickByDefault;
    /* 0x0c34 */ bool bOptimizeAnimBlueprintMemberVariableAccess;
    /* 0x0c34 */ bool bAllowMultiThreadedAnimationUpdate;
    /* 0x0c34 */ bool bEnableEditorPSysRealtimeLOD;
    /* 0x0c34 */ bool bSmoothFrameRate;
    /* 0x0c34 */ bool bUseFixedFrameRate;
    /* 0x0c38 */ float FixedFrameRate;
    /* 0x0c3c */ FFloatRange SmoothedFrameRateRange;
    /* 0x0c50 */ UEngineCustomTimeStep* CustomTimeStep;
    /* 0x0c78 */ FSoftClassPath CustomTimeStepClassName;
    /* 0x0c98 */ UTimecodeProvider* TimecodeProvider;
    /* 0x0cc0 */ FSoftClassPath TimecodeProviderClassName;
    /* 0x0ce0 */ bool bGenerateDefaultTimecode;
    /* 0x0ce4 */ FFrameRate GenerateDefaultTimecodeFrameRate;
    /* 0x0cec */ float GenerateDefaultTimecodeFrameDelay;
    /* 0x0cf0 */ bool bCheckForMultiplePawnsSpawnedInAFrame;
    /* 0x0cf4 */ int32_t NumPawnsAllowedToBeSpawnedInAFrame;
    /* 0x0cf8 */ bool bShouldGenerateLowQualityLightmaps;
    /* 0x0cfc */ FColor C_WorldBox;
    /* 0x0d00 */ FColor C_BrushWire;
    /* 0x0d04 */ FColor C_AddWire;
    /* 0x0d08 */ FColor C_SubtractWire;
    /* 0x0d0c */ FColor C_SemiSolidWire;
    /* 0x0d10 */ FColor C_NonSolidWire;
    /* 0x0d14 */ FColor C_WireBackground;
    /* 0x0d18 */ FColor C_ScaleBoxHi;
    /* 0x0d1c */ FColor C_VolumeCollision;
    /* 0x0d20 */ FColor C_BSPCollision;
    /* 0x0d24 */ FColor C_OrthoBackground;
    /* 0x0d28 */ FColor C_Volume;
    /* 0x0d2c */ FColor C_BrushShape;
    /* 0x0d30 */ FDirectoryPath GameScreenshotSaveDirectory;
    /* 0x0d40 */ bool UseStaticMeshMinLODPerQualityLevels;
    /* 0x0d41 */ bool UseSkeletalMeshMinLODPerQualityLevels;
    /* 0x0d42 */ bool UseClothAssetMinLODPerQualityLevels;
    /* 0x0d43 */ bool UseGrassVarityPerQualityLevels;
    /* 0x0d44 */ ETransitionType TransitionType;
    /* 0x0d48 */ FString TransitionDescription;
    /* 0x0d58 */ FString TransitionGameMode;
    /* 0x0d68 */ bool bAllowMatureLanguage;
    /* 0x0d6c */ float CameraRotationThreshold;
    /* 0x0d70 */ float CameraTranslationThreshold;
    /* 0x0d74 */ float PrimitiveProbablyVisibleTime;
    /* 0x0d78 */ float MaxOcclusionPixelsFraction;
    /* 0x0d7c */ bool bPauseOnLossOfFocus;
    /* 0x0d80 */ int32_t MaxParticleResize;
    /* 0x0d84 */ int32_t MaxParticleResizeWarn;
    /* 0x0d88 */ TArray<FDropNoteInfo> PendingDroppedNotes;
    /* 0x0d98 */ float NetClientTicksPerSecond;
    /* 0x0d9c */ float DisplayGamma;
    /* 0x0da0 */ float MinDesiredFrameRate;
    /* 0x0da4 */ FLinearColor DefaultSelectedMaterialColor;
    /* 0x0db4 */ FLinearColor SelectedMaterialColor;
    /* 0x0dc4 */ FLinearColor SelectionOutlineColor;
    /* 0x0dd4 */ FLinearColor SubduedSelectionOutlineColor;
    /* 0x0de4 */ FLinearColor SelectedMaterialColorOverride;
    /* 0x0df4 */ bool bIsOverridingSelectedColor;
    /* 0x0df8 */ bool bEnableOnScreenDebugMessages;
    /* 0x0df8 */ bool bEnableOnScreenDebugMessagesDisplay;
    /* 0x0df8 */ bool bSuppressMapWarnings;
    /* 0x0df8 */ bool bDisableAILogging;
    /* 0x0dfc */ uint32_t bEnableVisualLogRecordingOnStart;
    /* 0x0e00 */ int32_t ScreenSaverInhibitorSemaphore;
    /* 0x0e04 */ bool bLockReadOnlyLevels;
    /* 0x0e08 */ FString ParticleEventManagerClassPath;
    /* 0x0e18 */ float SelectionHighlightIntensity;
    /* 0x0e1c */ float BSPSelectionHighlightIntensity;
    /* 0x0e20 */ float SelectionHighlightIntensityBillboards;
    /* 0x10b8 */ uint32_t GlobalNetTravelCount;
    /* 0x10c0 */ TArray<FNetDriverDefinition> NetDriverDefinitions;
    /* 0x10d0 */ TArray<FIrisNetDriverConfig> IrisNetDriverConfigs;
    /* 0x10e0 */ TArray<FString> ServerActors;
    /* 0x10f0 */ TArray<FString> RuntimeServerActors;
    /* 0x1100 */ float NetErrorLogInterval;
    /* 0x1104 */ bool bStartedLoadMapMovie;
    /* 0x1158 */ int32_t NextWorldContextHandle;
};

// Size: 0x28
class UEngineBaseTypes : public UObject {
};

// Size: 0x28
class UEngineCustomTimeStep : public UObject {
};

// Size: 0x28
class UEngineElementsLibrary : public UBlueprintFunctionLibrary {
};

// Size: 0x28
class UEngineHandlerComponentFactory : public UHandlerComponentFactory {
};

// Size: 0xa8
class UEngineMessage : public ULocalMessage {
    /* 0x0028 */ FString FailedPlaceMessage;
    /* 0x0038 */ FString MaxedOutMessage;
    /* 0x0048 */ FString EnteredMessage;
    /* 0x0058 */ FString LeftMessage;
    /* 0x0068 */ FString GlobalNameChange;
    /* 0x0078 */ FString SpecEnteredMessage;
    /* 0x0088 */ FString NewPlayerMessage;
    /* 0x0098 */ FString NewSpecMessage;
};

// Size: 0x650
class UEngineReplicationBridge : public UObjectReplicationBridge {
    /* 0x0648 */ UIrisObjectReferencePackageMap* ObjectReferencePackageMap;
};

// Size: 0x18
struct FEngineShowFlagsSetting {
    /* 0x0000 */ FString ShowFlagName;
    /* 0x0010 */ bool Enabled;
};

// Size: 0x30
class UEngineSubsystem : public UDynamicSubsystem {
};

// Size: 0x28
class UEngineTypes : public UObject {
};

// Size: 0x98
struct FEquirectProps {
    /* 0x0000 */ FBox2D LeftUVRect;
    /* 0x0028 */ FBox2D RightUVRect;
    /* 0x0050 */ FVector2D LeftScale;
    /* 0x0060 */ FVector2D RightScale;
    /* 0x0070 */ FVector2D LeftBias;
    /* 0x0080 */ FVector2D RightBias;
    /* 0x0090 */ float Radius;
};

// Size: 0x10
struct FEventGraphFastCallPair {
    /* 0x0000 */ UFunction* FunctionToPatch;
    /* 0x0008 */ int32_t EventGraphCallOffset;
};

// Size: 0x2b8
class AExponentialHeightFog : public AInfo {
    /* 0x02a8 */ UExponentialHeightFogComponent* Component;
    /* 0x02b0 */ bool bEnabled;

    void OnRep_bEnabled();
};

// Size: 0x320
class UExponentialHeightFogComponent : public USceneComponent {
    /* 0x0240 */ float FogDensity;
    /* 0x0244 */ float FogHeightFalloff;
    /* 0x0248 */ FExponentialHeightFogData SecondFogData;
    /* 0x0254 */ FLinearColor FogInscatteringColor;
    /* 0x0264 */ FLinearColor FogInscatteringLuminance;
    /* 0x0274 */ FLinearColor SkyAtmosphereAmbientContributionColorScale;
    /* 0x0288 */ UTextureCube* InscatteringColorCubemap;
    /* 0x0290 */ float InscatteringColorCubemapAngle;
    /* 0x0294 */ FLinearColor InscatteringTextureTint;
    /* 0x02a4 */ float FullyDirectionalInscatteringColorDistance;
    /* 0x02a8 */ float NonDirectionalInscatteringColorDistance;
    /* 0x02ac */ float DirectionalInscatteringExponent;
    /* 0x02b0 */ float DirectionalInscatteringStartDistance;
    /* 0x02b4 */ FLinearColor DirectionalInscatteringColor;
    /* 0x02c4 */ FLinearColor DirectionalInscatteringLuminance;
    /* 0x02d4 */ float FogMaxOpacity;
    /* 0x02d8 */ float StartDistance;
    /* 0x02dc */ float EndDistance;
    /* 0x02e0 */ float FogCutoffDistance;
    /* 0x02e4 */ bool bEnableVolumetricFog;
    /* 0x02e8 */ float VolumetricFogScatteringDistribution;
    /* 0x02ec */ FColor VolumetricFogAlbedo;
    /* 0x02f0 */ FLinearColor VolumetricFogEmissive;
    /* 0x0300 */ float VolumetricFogExtinctionScale;
    /* 0x0304 */ float VolumetricFogDistance;
    /* 0x0308 */ float VolumetricFogStartDistance;
    /* 0x030c */ float VolumetricFogNearFadeInDistance;
    /* 0x0310 */ float VolumetricFogStaticLightingScatteringIntensity;
    /* 0x0314 */ bool bOverrideLightColorsWithFogInscatteringColors;
    /* 0x0315 */ bool bHoldout;
    /* 0x0315 */ bool bRenderInMainPass;
    /* 0x0315 */ bool bVisibleInReflectionCaptures;
    /* 0x0315 */ bool bVisibleInRealTimeSkyCaptures;

    void SetDirectionalInscatteringColor(FLinearColor Value);
    void SetDirectionalInscatteringExponent(float Value);
    void SetDirectionalInscatteringStartDistance(float Value);
    void SetEndDistance(float Value);
    void SetFogCutoffDistance(float Value);
    void SetFogDensity(float Value);
    void SetFogHeightFalloff(float Value);
    void SetFogInscatteringColor(FLinearColor Value);
    void SetFogMaxOpacity(float Value);
    void SetFullyDirectionalInscatteringColorDistance(float Value);
    void SetHoldout(bool bNewHoldout);
    void SetInscatteringColorCubemap(UTextureCube* Value);
    void SetInscatteringColorCubemapAngle(float Value);
    void SetInscatteringTextureTint(FLinearColor Value);
    void SetNonDirectionalInscatteringColorDistance(float Value);
    void SetRenderInMainPass(bool bValue);
    void SetSecondFogData(FExponentialHeightFogData NewValue);
    void SetSecondFogDensity(float Value);
    void SetSecondFogHeightFalloff(float Value);
    void SetSecondFogHeightOffset(float Value);
    void SetSkyAtmosphereAmbientContributionColorScale(FLinearColor NewValue);
    void SetStartDistance(float Value);
    void SetVolumetricFog(bool bNewValue);
    void SetVolumetricFogAlbedo(FColor NewValue);
    void SetVolumetricFogDistance(float NewValue);
    void SetVolumetricFogEmissive(FLinearColor NewValue);
    void SetVolumetricFogExtinctionScale(float NewValue);
    void SetVolumetricFogNearFadeInDistance(float NewValue);
    void SetVolumetricFogScatteringDistribution(float NewValue);
    void SetVolumetricFogStartDistance(float NewValue);
};

// Size: 0xc
struct FExponentialHeightFogData {
    /* 0x0000 */ float FogDensity;
    /* 0x0004 */ float FogHeightFalloff;
    /* 0x0008 */ float FogHeightOffset;
};

// Size: 0xc0
struct FExponentialHeightFogDynamicState {
    /* 0x0004 */ float FogDensity;
    /* 0x0008 */ float FogHeightFalloff;
    /* 0x000c */ FExponentialHeightFogData SecondFogData;
    /* 0x0018 */ FLinearColor FogInscatteringLuminance;
    /* 0x0028 */ FLinearColor SkyAtmosphereAmbientContributionColorScale;
    /* 0x0038 */ UTextureCube* InscatteringColorCubemap;
    /* 0x0040 */ float InscatteringColorCubemapAngle;
    /* 0x0044 */ FLinearColor InscatteringTextureTint;
    /* 0x0054 */ float FullyDirectionalInscatteringColorDistance;
    /* 0x0058 */ float NonDirectionalInscatteringColorDistance;
    /* 0x005c */ float DirectionalInscatteringExponent;
    /* 0x0060 */ float DirectionalInscatteringStartDistance;
    /* 0x0064 */ FLinearColor DirectionalInscatteringLuminance;
    /* 0x0074 */ float FogMaxOpacity;
    /* 0x0078 */ float StartDistance;
    /* 0x007c */ float EndDistance;
    /* 0x0080 */ float FogCutoffDistance;
    /* 0x0084 */ bool bEnableVolumetricFog;
    /* 0x0088 */ float VolumetricFogScatteringDistribution;
    /* 0x008c */ FColor VolumetricFogAlbedo;
    /* 0x0090 */ FLinearColor VolumetricFogEmissive;
    /* 0x00a0 */ float VolumetricFogExtinctionScale;
    /* 0x00a4 */ float VolumetricFogDistance;
    /* 0x00a8 */ float VolumetricFogStartDistance;
    /* 0x00ac */ float VolumetricFogNearFadeInDistance;
    /* 0x00b0 */ float VolumetricFogStaticLightingScatteringIntensity;
    /* 0x00b4 */ bool bOverrideLightColorsWithFogInscatteringColors;
    /* 0x00b5 */ bool bHoldout;
    /* 0x00b5 */ bool bRenderInMainPass;
    /* 0x00b5 */ bool bVisibleInReflectionCaptures;
    /* 0x00b5 */ bool bVisibleInRealTimeSkyCaptures;
    /* 0x00b8 */ float Height;
};

// Size: 0x10
struct FExponentialHeightFogHandle : public FStateStreamHandle {
};

// Size: 0x4
struct FExponentialHeightFogStaticState {
};

// Size: 0x78
class UExporter : public UObject {
    /* 0x0028 */ UClass* SupportedClass;
    /* 0x0030 */ UObject* ExportRootScope;
    /* 0x0038 */ TArray<FString> FormatExtension;
    /* 0x0048 */ TArray<FString> FormatDescription;
    /* 0x0058 */ int32_t PreferredFormatIndex;
    /* 0x005c */ int32_t TextIndent;
    /* 0x0060 */ bool bText;
    /* 0x0060 */ bool bSelectedOnly;
    /* 0x0060 */ bool bForceFileOperations;
    /* 0x0068 */ UAssetExportTask* ExportTask;

    static bool RunAssetExportTask(UAssetExportTask* Task);
    static bool RunAssetExportTasks(const TArray<UAssetExportTask*>& ExportTasks);
    bool ScriptRunAssetExportTask(UAssetExportTask* Task);
};

// Size: 0x8
struct FExposedValueCopyRecord {
    /* 0x0000 */ int32_t CopyIndex;
    /* 0x0004 */ EPostCopyOperation PostCopyOperation;
    /* 0x0005 */ bool bOnlyUpdateWhenActive;
};

// Size: 0x10
struct FExposedValueHandler {
};

// Size: 0x8
struct FExposureSettings {
    /* 0x0000 */ float FixedEV100;
    /* 0x0004 */ bool bFixed;
};

// Size: 0x28
struct FExpressionInput {
    /* 0x0000 */ UMaterialExpression* Expression;
    /* 0x0008 */ int32_t OutputIndex;
    /* 0x000c */ FName InputName;
    /* 0x0014 */ int32_t Mask;
    /* 0x0018 */ int32_t MaskR;
    /* 0x001c */ int32_t MaskG;
    /* 0x0020 */ int32_t MaskB;
    /* 0x0024 */ int32_t MaskA;
};

// Size: 0x1c
struct FExpressionOutput {
    /* 0x0000 */ FName OutputName;
    /* 0x0008 */ int32_t Mask;
    /* 0x000c */ int32_t MaskR;
    /* 0x0010 */ int32_t MaskG;
    /* 0x0014 */ int32_t MaskB;
    /* 0x0018 */ int32_t MaskA;
};

// Size: 0x48
class UExternalDataLayerAsset : public UDataLayerAsset {
    /* 0x0040 */ FExternalDataLayerUID UID;
};

// Size: 0xb8
class UExternalDataLayerEngineSubsystem : public UEngineSubsystem {
};

// Size: 0x28
class UExternalDataLayerInjectionPolicy : public UObject {
};

// Size: 0x50
class UExternalDataLayerInstance : public UDataLayerInstanceWithAsset {
};

// Size: 0x80
class UExternalDataLayerManager : public UObject {
    /* 0x0030 */ TMap<UExternalDataLayerAsset*, URuntimeHashExternalStreamingObjectBase*> ExternalStreamingObjects;
};

// Size: 0x4
struct FExternalDataLayerUID {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x10
struct FExternalSpatialAccelerationPayload {
};

// Size: 0x60
struct FExternalToolDefinition {
    /* 0x0000 */ FString ToolName;
    /* 0x0010 */ FFilePath ExecutablePath;
    /* 0x0020 */ FString CommandLineOptions;
    /* 0x0030 */ FDirectoryPath WorkingDirectory;
    /* 0x0040 */ FString ScriptExtension;
    /* 0x0050 */ FDirectoryPath ScriptDirectory;
};

enum class FDataDrivenCVarType {
    CVarFloat = 0,
    CVarInt = 1,
    CVarBool = 2,
    FDataDrivenCVarType_MAX = 3,
};

enum class FNavigationSystemRunMode {
    InvalidMode = 0,
    GameMode = 1,
    EditorMode = 2,
    SimulationMode = 3,
    PIEMode = 4,
    InferFromWorldMode = 5,
    EditorWorldPartitionBuildMode = 6,
    FNavigationSystemRunMode_MAX = 7,
};

// Size: 0x50
class UFXSystemAsset : public UObject {
    /* 0x0028 */ uint32_t MaxPoolSize;
    /* 0x002c */ uint32_t PoolPrimeSize;
};

// Size: 0x520
class UFXSystemComponent : public UPrimitiveComponent {

    UFXSystemAsset* GetFXSystemAsset() const;
    void ReleaseToPool();
    void SetActorParameter(FName ParameterName, AActor* Param);
    void SetAutoAttachmentParameters(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule);
    void SetBoolParameter(FName ParameterName, bool Param);
    void SetColorParameter(FName ParameterName, FLinearColor Param);
    void SetEmitterEnable(FName EmitterName, bool bNewEnableState);
    void SetFloatParameter(FName ParameterName, float Param);
    void SetIntParameter(FName ParameterName, int32_t Param);
    void SetUseAutoManageAttachment(bool bAutoManage);
    void SetVectorParameter(FName ParameterName, FVector Param);
};

// Size: 0x70
struct FFXSystemSpawnParameters {
    /* 0x0000 */ UObject* WorldContextObject;
    /* 0x0008 */ UFXSystemAsset* SystemTemplate;
    /* 0x0010 */ FVector Location;
    /* 0x0028 */ FRotator Rotation;
    /* 0x0040 */ FVector Scale;
    /* 0x0058 */ USceneComponent* AttachToComponent;
    /* 0x0060 */ FName AttachPointName;
    /* 0x0068 */ uint8_t LocationType;
    /* 0x0069 */ bool bAutoDestroy;
    /* 0x006a */ bool bAutoActivate;
    /* 0x006b */ EPSCPoolMethod PoolingMethod;
    /* 0x006c */ bool bPreCullCheck;
    /* 0x006d */ bool bIsPlayerEffect;
};

// Size: 0x28
class UFieldNotificationLibrary : public UBlueprintFunctionLibrary {

    static void BroadcastFieldValueChanged(UObject* Object, FFieldNotificationId FieldId);
    static void BroadcastFieldsValueChanged(UObject* Object, TArray<FFieldNotificationId> FieldIds);
    static bool SetPropertyValueAndBroadcast(bool NewValueByRef, const int32_t& OldValue, const int32_t& NewValue, UObject* Object, UObject* NetOwner, bool bHasLocalRepNotify, bool bShouldFlushDormancyOnSet, bool bIsNetProperty);
    static bool SetPropertyValueAndBroadcastFields(bool NewValueByRef, const int32_t& OldValue, const int32_t& NewValue, UObject* Object, UObject* NetOwner, bool bHasLocalRepNotify, bool bShouldFlushDormancyOnSet, bool bIsNetProperty, TArray<FFieldNotificationId> ExtraFieldIds);
};

// Size: 0x14
struct FFilmStockSettings {
    /* 0x0000 */ float Slope;
    /* 0x0004 */ float Toe;
    /* 0x0008 */ float Shoulder;
    /* 0x000c */ float BlackClip;
    /* 0x0010 */ float WhiteClip;
};

// Size: 0x110
struct FFindFloorResult {
    /* 0x0000 */ bool bBlockingHit;
    /* 0x0000 */ bool bWalkableFloor;
    /* 0x0000 */ bool bLineTrace;
    /* 0x0004 */ float FloorDist;
    /* 0x0008 */ float LineDist;
    /* 0x0010 */ FHitResult HitResult;
};

// Size: 0x4
struct FFloatAnimationAttribute {
    /* 0x0000 */ float Value;
};

// Size: 0x90
struct FFloatCurve : public FAnimCurveBase {
    /* 0x0010 */ FRichCurve FloatCurve;
};

// Size: 0x20
struct FFloatDistribution {
    /* 0x0000 */ FDistributionLookupTable Table;
};

// Size: 0x8
struct FFloatRK4SpringInterpolator {
    /* 0x0000 */ float StiffnessConstant;
    /* 0x0004 */ float DampeningRatio;
};

// Size: 0xc
struct FFloatSpringState {
};

// Size: 0x1a0
class UFloatingPawnMovement : public UPawnMovementComponent {
    /* 0x0188 */ float MaxSpeed;
    /* 0x018c */ float Acceleration;
    /* 0x0190 */ float Deceleration;
    /* 0x0194 */ float TurningBoost;
    /* 0x0198 */ bool bPositionCorrected;
};

// Size: 0x1d8
class UFont : public UObject {
    /* 0x0030 */ EFontCacheType FontCacheType;
    /* 0x0038 */ TArray<FFontCharacter> Characters;
    /* 0x0048 */ TArray<UTexture2D*> Textures;
    /* 0x0058 */ int32_t IsRemapped;
    /* 0x005c */ float EmScale;
    /* 0x0060 */ float Ascent;
    /* 0x0064 */ float Descent;
    /* 0x0068 */ float Leading;
    /* 0x006c */ int32_t Kerning;
    /* 0x0070 */ FFontImportOptionsData ImportOptions;
    /* 0x0120 */ int32_t NumCharacters;
    /* 0x0128 */ TArray<int32_t> MaxCharHeight;
    /* 0x0138 */ float ScalingFactor;
    /* 0x013c */ int32_t LegacyFontSize;
    /* 0x0140 */ FName LegacyFontName;
    /* 0x0148 */ FCompositeFont CompositeFont;
};

// Size: 0x18
struct FFontCharacter {
    /* 0x0000 */ int32_t StartU;
    /* 0x0004 */ int32_t StartV;
    /* 0x0008 */ int32_t USize;
    /* 0x000c */ int32_t VSize;
    /* 0x0010 */ uint8_t TextureIndex;
    /* 0x0014 */ int32_t VerticalOffset;
};

// Size: 0x90
class UFontFace : public UObject {
    /* 0x0030 */ FString SourceFilename;
    /* 0x0040 */ EFontHinting Hinting;
    /* 0x0041 */ EFontLoadingPolicy LoadingPolicy;
    /* 0x0042 */ EFontLayoutMethod LayoutMethod;
    /* 0x0044 */ int32_t AscendOverriddenValue;
    /* 0x0048 */ bool bIsAscendOverridden;
    /* 0x004c */ int32_t DescendOverriddenValue;
    /* 0x0050 */ bool bIsDescendOverridden;
    /* 0x0054 */ int32_t StrikeBrushHeightPercentage;
    /* 0x0068 */ bool bEnableDistanceFieldRendering;
    /* 0x006c */ int32_t MinDistanceFieldPpem;
    /* 0x0070 */ int32_t MidDistanceFieldPpem;
    /* 0x0074 */ int32_t MaxDistanceFieldPpem;
    /* 0x0078 */ int32_t MinMultiDistanceFieldPpem;
    /* 0x007c */ int32_t MidMultiDistanceFieldPpem;
    /* 0x0080 */ int32_t MaxMultiDistanceFieldPpem;
    /* 0x0084 */ TOptional<FFontFacePlatformRasterizationOverrides> PlatformRasterizationModeOverrides;
};

// Size: 0x3
struct FFontFacePlatformRasterizationOverrides {
    /* 0x0000 */ EFontRasterizationMode MsdfOverride;
    /* 0x0001 */ EFontRasterizationMode SdfOverride;
    /* 0x0002 */ EFontRasterizationMode SdfApproximationOverride;
};

// Size: 0xd8
class UFontImportOptions : public UObject {
    /* 0x0028 */ FFontImportOptionsData Data;
};

// Size: 0xb0
struct FFontImportOptionsData {
    /* 0x0000 */ FString FontName;
    /* 0x0010 */ float Height;
    /* 0x0014 */ bool bEnableAntialiasing;
    /* 0x0014 */ bool bEnableBold;
    /* 0x0014 */ bool bEnableItalic;
    /* 0x0014 */ bool bEnableUnderline;
    /* 0x0014 */ bool bAlphaOnly;
    /* 0x0018 */ uint8_t CharacterSet;
    /* 0x0020 */ FString Chars;
    /* 0x0030 */ FString UnicodeRange;
    /* 0x0040 */ FString CharsFilePath;
    /* 0x0050 */ FString CharsFileWildcard;
    /* 0x0060 */ bool bCreatePrintableOnly;
    /* 0x0060 */ bool bIncludeASCIIRange;
    /* 0x0064 */ FLinearColor ForegroundColor;
    /* 0x0074 */ bool bEnableDropShadow;
    /* 0x0078 */ int32_t TexturePageWidth;
    /* 0x007c */ int32_t TexturePageMaxHeight;
    /* 0x0080 */ int32_t XPadding;
    /* 0x0084 */ int32_t YPadding;
    /* 0x0088 */ int32_t ExtendBoxTop;
    /* 0x008c */ int32_t ExtendBoxBottom;
    /* 0x0090 */ int32_t ExtendBoxRight;
    /* 0x0094 */ int32_t ExtendBoxLeft;
    /* 0x0098 */ bool bEnableLegacyMode;
    /* 0x009c */ int32_t Kerning;
    /* 0x00a0 */ bool bUseDistanceFieldAlpha;
    /* 0x00a4 */ int32_t DistanceFieldScaleFactor;
    /* 0x00a8 */ float DistanceFieldScanRadiusScale;
};

// Size: 0x30
struct FFontParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ UFont* FontValue;
    /* 0x0018 */ int32_t FontPage;
    /* 0x001c */ FGuid ExpressionGUID;
};

// Size: 0x40
struct FFontRenderInfo {
    /* 0x0000 */ bool bClipText;
    /* 0x0000 */ bool bEnableShadow;
    /* 0x0008 */ FDepthFieldGlowInfo GlowInfo;
};

// Size: 0xe8
class UForceFeedbackAttenuation : public UObject {
    /* 0x0028 */ FForceFeedbackAttenuationSettings Attenuation;
};

// Size: 0xc0
struct FForceFeedbackAttenuationSettings : public FBaseAttenuationSettings {
};

// Size: 0x90
struct FForceFeedbackChannelDetails {
    /* 0x0000 */ bool bAffectsLeftLarge;
    /* 0x0000 */ bool bAffectsLeftSmall;
    /* 0x0000 */ bool bAffectsRightLarge;
    /* 0x0000 */ bool bAffectsRightSmall;
    /* 0x0008 */ FRuntimeFloatCurve Curve;
};

// Size: 0x330
class UForceFeedbackComponent : public USceneComponent {
    /* 0x0240 */ UForceFeedbackEffect* ForceFeedbackEffect;
    /* 0x0248 */ bool bAutoDestroy;
    /* 0x0248 */ bool bStopWhenOwnerDestroyed;
    /* 0x0248 */ bool bLooping;
    /* 0x0248 */ bool bIgnoreTimeDilation;
    /* 0x0248 */ bool bOverrideAttenuation;
    /* 0x024c */ float IntensityMultiplier;
    /* 0x0250 */ UForceFeedbackAttenuation* AttenuationSettings;
    /* 0x0258 */ FForceFeedbackAttenuationSettings AttenuationOverrides;
    /* 0x0318 */ FMulticastInlineDelegate OnForceFeedbackFinished;

    void AdjustAttenuation(const FForceFeedbackAttenuationSettings& InAttenuationSettings);
    bool BP_GetAttenuationSettingsToApply(FForceFeedbackAttenuationSettings& OutAttenuationSettings) const;
    void Play(float StartTime);
    void SetForceFeedbackEffect(UForceFeedbackEffect* NewForceFeedbackEffect);
    void SetIntensityMultiplier(float NewIntensityMultiplier);
    void Stop();
};

// Size: 0xa0
class UForceFeedbackEffect : public UObject {
    /* 0x0028 */ TArray<FForceFeedbackChannelDetails> ChannelDetails;
    /* 0x0038 */ TMap<FName, FForceFeedbackEffectOverridenChannelDetails> PerDeviceOverrides;
    /* 0x0088 */ TArray<UInputDeviceProperty*> DeviceProperties;
    /* 0x0098 */ float Duration;
};

// Size: 0x10
struct FForceFeedbackEffectOverridenChannelDetails {
    /* 0x0000 */ TArray<FForceFeedbackChannelDetails> ChannelDetails;
};

// Size: 0xc
struct FForceFeedbackParameters {
    /* 0x0000 */ FName Tag;
    /* 0x0008 */ bool bLooping;
    /* 0x0009 */ bool bIgnoreTimeDilation;
    /* 0x000a */ bool bPlayWhilePaused;
};

// Size: 0x48
struct FFormatArgumentData {
    /* 0x0000 */ FString ArgumentName;
    /* 0x0010 */ uint8_t ArgumentValueType;
    /* 0x0018 */ FText ArgumentValue;
    /* 0x0028 */ int64_t ArgumentValueInt;
    /* 0x0030 */ float ArgumentValueFloat;
    /* 0x0038 */ double ArgumentValueDouble;
    /* 0x0040 */ ETextGender ArgumentValueGender;
};

// Size: 0x10
struct FFractureEffect {
    /* 0x0000 */ UParticleSystem* ParticleSystem;
    /* 0x0008 */ USoundBase* Sound;
};

// Size: 0x8
struct FFrameRateChangedPayload : public FEmptyPayload {
    /* 0x0000 */ FFrameRate PreviousFrameRate;
};

// Size: 0x38
struct FFullyLoadedPackagesInfo {
    /* 0x0000 */ uint8_t FullyLoadType;
    /* 0x0008 */ FString Tag;
    /* 0x0018 */ TArray<FName> PackagesToLoad;
    /* 0x0028 */ TArray<UObject*> LoadedObjects;
};

// Size: 0x40
struct FFunctionExpressionInput {
    /* 0x0000 */ UMaterialExpressionFunctionInput* ExpressionInput;
    /* 0x0008 */ FGuid ExpressionInputId;
    /* 0x0018 */ FExpressionInput Input;
};

// Size: 0x38
struct FFunctionExpressionOutput {
    /* 0x0000 */ UMaterialExpressionFunctionOutput* ExpressionOutput;
    /* 0x0008 */ FGuid ExpressionOutputId;
    /* 0x0018 */ FExpressionOutput Output;
};

// Size: 0x350
struct FGPUSpriteEmitterInfo {
    /* 0x0000 */ UParticleModuleRequired* RequiredModule;
    /* 0x0008 */ UParticleModuleSpawn* SpawnModule;
    /* 0x0010 */ UParticleModuleSpawnPerUnit* SpawnPerUnitModule;
    /* 0x0018 */ TArray<UParticleModule*> SpawnModules;
    /* 0x0030 */ FGPUSpriteLocalVectorFieldInfo LocalVectorField;
    /* 0x0100 */ FFloatDistribution VectorFieldScale;
    /* 0x0120 */ FFloatDistribution DragCoefficient;
    /* 0x0140 */ FFloatDistribution PointAttractorStrength;
    /* 0x0160 */ FFloatDistribution Resilience;
    /* 0x0180 */ FVector ConstantAcceleration;
    /* 0x0198 */ FVector PointAttractorPosition;
    /* 0x01b0 */ float PointAttractorRadiusSq;
    /* 0x01b8 */ FVector OrbitOffsetBase;
    /* 0x01d0 */ FVector OrbitOffsetRange;
    /* 0x01e8 */ FVector2D InvMaxSize;
    /* 0x01f8 */ float InvRotationRateScale;
    /* 0x01fc */ float MaxLifetime;
    /* 0x0200 */ int32_t MaxParticleCount;
    /* 0x0204 */ uint8_t ScreenAlignment;
    /* 0x0205 */ uint8_t LockAxisFlag;
    /* 0x0208 */ bool bEnableCollision;
    /* 0x020c */ uint8_t CollisionMode;
    /* 0x0210 */ bool bUseVelocityForMotionBlur;
    /* 0x0210 */ bool bRemoveHMDRoll;
    /* 0x0214 */ float MinFacingCameraBlendDistance;
    /* 0x0218 */ float MaxFacingCameraBlendDistance;
    /* 0x0220 */ FRawDistributionVector DynamicColor;
    /* 0x0280 */ FRawDistributionFloat DynamicAlpha;
    /* 0x02b0 */ FRawDistributionVector DynamicColorScale;
    /* 0x0310 */ FRawDistributionFloat DynamicAlphaScale;
};

// Size: 0xd0
struct FGPUSpriteLocalVectorFieldInfo {
    /* 0x0000 */ UVectorField* Field;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FRotator MinInitialRotation;
    /* 0x0088 */ FRotator MaxInitialRotation;
    /* 0x00a0 */ FRotator RotationRate;
    /* 0x00b8 */ float Intensity;
    /* 0x00bc */ float Tightness;
    /* 0x00c0 */ bool bIgnoreComponentTransform;
    /* 0x00c0 */ bool bTileX;
    /* 0x00c0 */ bool bTileY;
    /* 0x00c0 */ bool bTileZ;
    /* 0x00c0 */ bool bUseFixDT;
};

// Size: 0x240
struct FGPUSpriteResourceData {
    /* 0x0000 */ TArray<FColor> QuantizedColorSamples;
    /* 0x0010 */ TArray<FColor> QuantizedMiscSamples;
    /* 0x0020 */ TArray<FColor> QuantizedSimulationAttrSamples;
    /* 0x0030 */ FVector4 ColorScale;
    /* 0x0050 */ FVector4 ColorBias;
    /* 0x0070 */ FVector4 MiscScale;
    /* 0x0090 */ FVector4 MiscBias;
    /* 0x00b0 */ FVector4 SimulationAttrCurveScale;
    /* 0x00d0 */ FVector4 SimulationAttrCurveBias;
    /* 0x00f0 */ FVector4 SubImageSize;
    /* 0x0110 */ FVector4 SizeBySpeed;
    /* 0x0130 */ FVector ConstantAcceleration;
    /* 0x0148 */ FVector OrbitOffsetBase;
    /* 0x0160 */ FVector OrbitOffsetRange;
    /* 0x0178 */ FVector OrbitFrequencyBase;
    /* 0x0190 */ FVector OrbitFrequencyRange;
    /* 0x01a8 */ FVector OrbitPhaseBase;
    /* 0x01c0 */ FVector OrbitPhaseRange;
    /* 0x01d8 */ float GlobalVectorFieldScale;
    /* 0x01dc */ float GlobalVectorFieldTightness;
    /* 0x01e0 */ float PerParticleVectorFieldScale;
    /* 0x01e4 */ float PerParticleVectorFieldBias;
    /* 0x01e8 */ float DragCoefficientScale;
    /* 0x01ec */ float DragCoefficientBias;
    /* 0x01f0 */ float ResilienceScale;
    /* 0x01f4 */ float ResilienceBias;
    /* 0x01f8 */ float CollisionRadiusScale;
    /* 0x01fc */ float CollisionRadiusBias;
    /* 0x0200 */ float CollisionTimeBias;
    /* 0x0204 */ float CollisionRandomSpread;
    /* 0x0208 */ float CollisionRandomDistribution;
    /* 0x020c */ float OneMinusFriction;
    /* 0x0210 */ float RotationRateScale;
    /* 0x0214 */ float CameraMotionBlurAmount;
    /* 0x0218 */ uint8_t ScreenAlignment;
    /* 0x0219 */ uint8_t LockAxisFlag;
    /* 0x0220 */ FVector2D PivotOffset;
    /* 0x0230 */ bool bUseVelocityForMotionBlur;
    /* 0x0230 */ bool bRemoveHMDRoll;
    /* 0x0234 */ float MinFacingCameraBlendDistance;
    /* 0x0238 */ float MaxFacingCameraBlendDistance;
};

// Size: 0x1298
class UGameEngine : public UEngine {
    /* 0x1240 */ float MaxDeltaTime;
    /* 0x1244 */ float ServerFlushLogInterval;
    /* 0x1248 */ UGameInstance* GameInstance;
};

// Size: 0x1c0
class UGameInstance : public UObject {
    /* 0x0038 */ TArray<ULocalPlayer*> LocalPlayers;
    /* 0x0048 */ UOnlineSession* OnlineSession;
    /* 0x0050 */ TArray<UObject*> ReferencedObjects;
    /* 0x0078 */ FMulticastInlineDelegate OnPawnControllerChangedDelegates;
    /* 0x00a0 */ FMulticastInlineDelegate OnInputDeviceConnectionChange;
    /* 0x00b0 */ FMulticastInlineDelegate OnUserInputDevicePairingChange;

    void DebugCreatePlayer(int32_t ControllerId);
    void DebugRemovePlayer(int32_t ControllerId);
    void HandleNetworkError(uint8_t FailureType, bool bIsServer);
    void HandleTravelError(uint8_t FailureType);
    void ReceiveInit();
    void ReceiveShutdown();
};

// Size: 0x30
class UGameInstanceSubsystem : public USubsystem {
};

// Size: 0x388
class AGameMode : public AGameModeBase {
    /* 0x0340 */ FName MatchState;
    /* 0x0348 */ bool bDelayedStart;
    /* 0x034c */ int32_t NumSpectators;
    /* 0x0350 */ int32_t NumPlayers;
    /* 0x0354 */ int32_t NumBots;
    /* 0x0358 */ float MinRespawnDelay;
    /* 0x035c */ int32_t NumTravellingPlayers;
    /* 0x0360 */ UClass* EngineMessageClass;
    /* 0x0368 */ TArray<APlayerState*> InactivePlayerArray;
    /* 0x0378 */ float InactivePlayerStateLifeSpan;
    /* 0x037c */ int32_t MaxInactivePlayers;
    /* 0x0380 */ bool bHandleDedicatedServerReplays;

    void AbortMatch();
    void EndMatch();
    FName GetMatchState() const;
    bool IsMatchInProgress() const;
    void K2_OnSetMatchState(FName NewState);
    bool ReadyToEndMatch();
    bool ReadyToStartMatch();
    void RestartGame();
    void Say(FString Msg);
    void StartMatch();
};

// Size: 0x340
class AGameModeBase : public AInfo {
    /* 0x02a8 */ FString OptionsString;
    /* 0x02b8 */ UClass* GameSessionClass;
    /* 0x02c0 */ UClass* GameStateClass;
    /* 0x02c8 */ UClass* PlayerControllerClass;
    /* 0x02d0 */ UClass* PlayerStateClass;
    /* 0x02d8 */ UClass* HUDClass;
    /* 0x02e0 */ UClass* DefaultPawnClass;
    /* 0x02e8 */ UClass* SpectatorClass;
    /* 0x02f0 */ UClass* ReplaySpectatorPlayerControllerClass;
    /* 0x02f8 */ UClass* ServerStatReplicatorClass;
    /* 0x0300 */ AGameSession* GameSession;
    /* 0x0308 */ AGameStateBase* GameState;
    /* 0x0310 */ AServerStatReplicator* ServerStatReplicator;
    /* 0x0318 */ FText DefaultPlayerName;
    /* 0x0328 */ bool bUseSeamlessTravel;
    /* 0x0328 */ bool bStartPlayersAsSpectators;
    /* 0x0328 */ bool bPauseable;
    /* 0x032c */ EReplicationSystem GameNetDriverReplicationSystem;

    bool CanSpectate(APlayerController* Viewer, APlayerState* ViewTarget);
    void ChangeName(AController* Controller, FString NewName, bool bNameChange);
    AActor* ChoosePlayerStart(AController* Player);
    AActor* FindPlayerStart(AController* Player, FString IncomingName);
    UClass* GetDefaultPawnClassForController(AController* InController);
    int32_t GetNumPlayers();
    int32_t GetNumSpectators();
    void HandleStartingNewPlayer(APlayerController* NewPlayer);
    bool HasMatchEnded() const;
    bool HasMatchStarted() const;
    void InitStartSpot(AActor* StartSpot, AController* NewPlayer);
    void InitializeHUDForPlayer(APlayerController* NewPlayer);
    AActor* K2_FindPlayerStart(AController* Player, FString IncomingName);
    void K2_OnChangeName(AController* Other, FString NewName, bool bNameChange);
    void K2_OnLogout(AController* ExitingController);
    void K2_OnRestartPlayer(AController* NewPlayer);
    void K2_OnSwapPlayerControllers(APlayerController* OldPC, APlayerController* NewPC);
    void K2_PostLogin(APlayerController* NewPlayer);
    bool MustSpectate(APlayerController* NewPlayerController) const;
    bool PlayerCanRestart(APlayerController* Player);
    void ResetLevel();
    void RestartPlayer(AController* NewPlayer);
    void RestartPlayerAtPlayerStart(AController* NewPlayer, AActor* StartSpot);
    void RestartPlayerAtTransform(AController* NewPlayer, const FTransform& SpawnTransform);
    void ReturnToMainMenuHost();
    bool ShouldReset(AActor* ActorToReset);
    APawn* SpawnDefaultPawnAtTransform(AController* NewPlayer, const FTransform& SpawnTransform);
    APawn* SpawnDefaultPawnFor(AController* NewPlayer, AActor* StartSpot);
    void StartPlay();
};

// Size: 0x10
struct FGameNameRedirect {
    /* 0x0000 */ FName OldGameName;
    /* 0x0008 */ FName NewGameName;
};

// Size: 0x350
class AGameNetworkManager : public AInfo {
    /* 0x02a8 */ float BadPacketLossThreshold;
    /* 0x02ac */ float SeverePacketLossThreshold;
    /* 0x02b0 */ int32_t BadPingThreshold;
    /* 0x02b4 */ int32_t SeverePingThreshold;
    /* 0x02b8 */ int32_t AdjustedNetSpeed;
    /* 0x02bc */ float LastNetSpeedUpdateTime;
    /* 0x02c0 */ int32_t TotalNetBandwidth;
    /* 0x02c4 */ int32_t MinDynamicBandwidth;
    /* 0x02c8 */ int32_t MaxDynamicBandwidth;
    /* 0x02cc */ bool bIsStandbyCheckingEnabled;
    /* 0x02cc */ bool bHasStandbyCheatTriggered;
    /* 0x02d0 */ float StandbyRxCheatTime;
    /* 0x02d4 */ float StandbyTxCheatTime;
    /* 0x02d8 */ float PercentMissingForRxStandby;
    /* 0x02dc */ float PercentMissingForTxStandby;
    /* 0x02e0 */ float PercentForBadPing;
    /* 0x02e4 */ float JoinInProgressStandbyWaitTime;
    /* 0x02e8 */ float MoveRepSize;
    /* 0x02ec */ float MAXPOSITIONERRORSQUARED;
    /* 0x02f0 */ float MAXNEARZEROVELOCITYSQUARED;
    /* 0x02f4 */ float CLIENTADJUSTUPDATECOST;
    /* 0x02f8 */ float MAXCLIENTUPDATEINTERVAL;
    /* 0x02fc */ float MaxClientForcedUpdateDuration;
    /* 0x0300 */ float ServerForcedUpdateHitchThreshold;
    /* 0x0304 */ float ServerForcedUpdateHitchCooldown;
    /* 0x0308 */ float MaxMoveDeltaTime;
    /* 0x030c */ float MaxClientSmoothingDeltaTime;
    /* 0x0310 */ float ClientNetSendMoveDeltaTime;
    /* 0x0314 */ float ClientNetSendMoveDeltaTimeThrottled;
    /* 0x0318 */ float ClientNetSendMoveDeltaTimeStationary;
    /* 0x031c */ int32_t ClientNetSendMoveThrottleAtNetSpeed;
    /* 0x0320 */ int32_t ClientNetSendMoveThrottleOverPlayerCount;
    /* 0x0324 */ float ClientErrorUpdateRateLimit;
    /* 0x0328 */ float ClientNetCamUpdateDeltaTime;
    /* 0x032c */ float ClientNetCamUpdatePositionLimit;
    /* 0x0330 */ bool ClientAuthorativePosition;
    /* 0x0331 */ bool bMovementTimeDiscrepancyDetection;
    /* 0x0332 */ bool bMovementTimeDiscrepancyResolution;
    /* 0x0334 */ float MovementTimeDiscrepancyMaxTimeMargin;
    /* 0x0338 */ float MovementTimeDiscrepancyMinTimeMargin;
    /* 0x033c */ float MovementTimeDiscrepancyResolutionRate;
    /* 0x0340 */ float MovementTimeDiscrepancyDriftAllowance;
    /* 0x0344 */ bool bMovementTimeDiscrepancyForceCorrectionsDuringResolution;
    /* 0x0345 */ bool bUseDistanceBasedRelevancy;
};

// Size: 0x2d0
class AGameSession : public AInfo {
    /* 0x02a8 */ int32_t MaxSpectators;
    /* 0x02ac */ int32_t MaxPlayers;
    /* 0x02b0 */ int32_t MaxPartySize;
    /* 0x02b4 */ uint8_t MaxSplitscreensPerConnection;
    /* 0x02b5 */ bool bRequiresPushToTalk;
    /* 0x02b8 */ FName SessionName;
};

// Size: 0x320
class AGameState : public AGameStateBase {
    /* 0x0300 */ FName MatchState;
    /* 0x0308 */ FName PreviousMatchState;
    /* 0x0310 */ int32_t ElapsedTime;

    void OnRep_ElapsedTime();
    void OnRep_MatchState();
};

// Size: 0x300
class AGameStateBase : public AInfo {
    /* 0x02a8 */ UClass* GameModeClass;
    /* 0x02b0 */ AGameModeBase* AuthorityGameMode;
    /* 0x02b8 */ UClass* SpectatorClass;
    /* 0x02c0 */ TArray<APlayerState*> PlayerArray;
    /* 0x02d0 */ bool bReplicatedHasBegunPlay;
    /* 0x02d4 */ float ReplicatedWorldTimeSeconds;
    /* 0x02d8 */ double ReplicatedWorldTimeSecondsDouble;
    /* 0x02e0 */ float ServerWorldTimeSecondsDelta;
    /* 0x02e4 */ float ServerWorldTimeSecondsUpdateFrequency;

    float GetPlayerRespawnDelay(AController* Controller) const;
    float GetPlayerStartTime(AController* Controller) const;
    double GetServerWorldTimeSeconds() const;
    bool HasBegunPlay() const;
    bool HasMatchEnded() const;
    bool HasMatchStarted() const;
    void OnRep_GameModeClass();
    void OnRep_ReplicatedHasBegunPlay();
    void OnRep_ReplicatedWorldTimeSeconds();
    void OnRep_ReplicatedWorldTimeSecondsDouble();
    void OnRep_SpectatorClass();
};

// Size: 0x158
class UGameUserSettings : public UObject {
    /* 0x0028 */ bool bUseVSync;
    /* 0x0029 */ bool bUseDynamicResolution;
    /* 0x0088 */ uint32_t ResolutionSizeX;
    /* 0x008c */ uint32_t ResolutionSizeY;
    /* 0x0090 */ uint32_t LastUserConfirmedResolutionSizeX;
    /* 0x0094 */ uint32_t LastUserConfirmedResolutionSizeY;
    /* 0x0098 */ int32_t WindowPosX;
    /* 0x009c */ int32_t WindowPosY;
    /* 0x00a0 */ TArray<FIntPoint> WindowPositions;
    /* 0x00b0 */ int32_t FullscreenMode;
    /* 0x00b4 */ int32_t LastConfirmedFullscreenMode;
    /* 0x00b8 */ int32_t PreferredFullscreenMode;
    /* 0x00bc */ uint32_t Version;
    /* 0x00c0 */ int32_t AudioQualityLevel;
    /* 0x00c4 */ int32_t LastConfirmedAudioQualityLevel;
    /* 0x00c8 */ float FrameRateLimit;
    /* 0x00d0 */ int32_t DesiredScreenWidth;
    /* 0x00d4 */ bool bUseDesiredScreenHeight;
    /* 0x00d8 */ int32_t DesiredScreenHeight;
    /* 0x00dc */ int32_t LastUserConfirmedDesiredScreenWidth;
    /* 0x00e0 */ int32_t LastUserConfirmedDesiredScreenHeight;
    /* 0x00e4 */ float LastRecommendedScreenWidth;
    /* 0x00e8 */ float LastRecommendedScreenHeight;
    /* 0x00ec */ float LastCPUBenchmarkResult;
    /* 0x00f0 */ float LastGPUBenchmarkResult;
    /* 0x00f8 */ TArray<float> LastCPUBenchmarkSteps;
    /* 0x0108 */ TArray<float> LastGPUBenchmarkSteps;
    /* 0x0118 */ float LastGPUBenchmarkMultiplier;
    /* 0x011c */ bool bUseHDRDisplayOutput;
    /* 0x0120 */ int32_t HDRDisplayOutputNits;
    /* 0x0148 */ FMulticastInlineDelegate OnGameUserSettingsUINeedsUpdate;

    void ApplyHardwareBenchmarkResults();
    void ApplyNonResolutionSettings();
    void ApplyResolutionSettings(bool bCheckForCommandLineOverrides);
    void ApplySettings(bool bCheckForCommandLineOverrides);
    void ConfirmVideoMode();
    void EnableHDRDisplayOutput(bool bEnable, int32_t DisplayNits);
    int32_t GetAntiAliasingQuality() const;
    int32_t GetAudioQualityLevel() const;
    int32_t GetCurrentHDRDisplayNits() const;
    static FIntPoint GetDefaultResolution();
    float GetDefaultResolutionScale();
    static uint8_t GetDefaultWindowMode();
    static FIntPoint GetDefaultWindowPosition();
    FIntPoint GetDesktopResolution() const;
    int32_t GetFoliageQuality() const;
    static int32_t GetFramePace();
    float GetFrameRateLimit() const;
    uint8_t GetFullscreenMode() const;
    static UGameUserSettings* GetGameUserSettings();
    int32_t GetGlobalIlluminationQuality() const;
    uint8_t GetLastConfirmedFullscreenMode() const;
    FIntPoint GetLastConfirmedScreenResolution() const;
    int32_t GetOverallScalabilityLevel() const;
    int32_t GetPostProcessingQuality() const;
    uint8_t GetPreferredFullscreenMode() const;
    float GetRecommendedResolutionScale();
    int32_t GetReflectionQuality() const;
    void GetResolutionScaleInformationEx(float& CurrentScaleNormalized, float& CurrentScaleValue, float& MinScaleValue, float& MaxScaleValue) const;
    float GetResolutionScaleNormalized() const;
    FIntPoint GetScreenResolution() const;
    int32_t GetShadingQuality() const;
    int32_t GetShadowQuality() const;
    static int32_t GetSyncInterval();
    int32_t GetTextureQuality() const;
    int32_t GetViewDistanceQuality() const;
    int32_t GetVisualEffectQuality() const;
    bool IsDirty() const;
    bool IsDynamicResolutionDirty() const;
    bool IsDynamicResolutionEnabled() const;
    bool IsFullscreenModeDirty() const;
    bool IsHDREnabled() const;
    bool IsScreenResolutionDirty() const;
    bool IsVSyncDirty() const;
    bool IsVSyncEnabled() const;
    void LoadSettings(bool bForceReload);
    void ResetToCurrentSettings();
    void RevertVideoMode();
    void RunHardwareBenchmark(int32_t WorkScale, float CPUMultiplier, float GPUMultiplier);
    void SaveSettings();
    void SetAntiAliasingQuality(int32_t Value);
    void SetAudioQualityLevel(int32_t QualityLevel);
    void SetBenchmarkFallbackValues();
    void SetDynamicResolutionEnabled(bool bEnable);
    void SetFoliageQuality(int32_t Value);
    void SetFrameRateLimit(float NewLimit);
    void SetFullscreenMode(uint8_t InFullscreenMode);
    void SetGlobalIlluminationQuality(int32_t Value);
    void SetOverallScalabilityLevel(int32_t Value);
    void SetPostProcessingQuality(int32_t Value);
    void SetReflectionQuality(int32_t Value);
    void SetResolutionScaleNormalized(float NewScaleNormalized);
    void SetResolutionScaleValueEx(float NewScaleValue);
    void SetScreenResolution(FIntPoint Resolution);
    void SetShadingQuality(int32_t Value);
    void SetShadowQuality(int32_t Value);
    void SetTextureQuality(int32_t Value);
    void SetToDefaults();
    void SetVSyncEnabled(bool bEnable);
    void SetViewDistanceQuality(int32_t Value);
    void SetVisualEffectQuality(int32_t Value);
    bool SupportsHDRDisplayOutput() const;
    void ValidateSettings();
};

// Size: 0x3c0
class UGameViewportClient : public UScriptViewportClient {
    /* 0x0040 */ UConsole* ViewportConsole;
    /* 0x0048 */ TArray<FDebugDisplayProperty> DebugProperties;
    /* 0x0068 */ int32_t MaxSplitscreenPlayers;
    /* 0x0078 */ UWorld* World;
    /* 0x0080 */ UGameInstance* GameInstance;

    void SSSwapControllers();
    void SetConsoleTarget(int32_t PlayerIndex);
    void ShowTitleSafeArea();
};

// Size: 0x28
class UGameplayStatics : public UBlueprintFunctionLibrary {

    static void ActivateReverbEffect(const UObject* WorldContextObject, UReverbEffect* ReverbEffect, FName TagName, float Priority, float Volume, float FadeTime);
    static void AnnounceAccessibleString(FString AnnouncementString);
    static float ApplyDamage(AActor* DamagedActor, float BaseDamage, AController* EventInstigator, AActor* DamageCauser, UClass* DamageTypeClass);
    static float ApplyPointDamage(AActor* DamagedActor, float BaseDamage, const FVector& HitFromDirection, const FHitResult& HitInfo, AController* EventInstigator, AActor* DamageCauser, UClass* DamageTypeClass);
    static bool ApplyRadialDamage(const UObject* WorldContextObject, float BaseDamage, const FVector& Origin, float DamageRadius, UClass* DamageTypeClass, const TArray<AActor*>& IgnoreActors, AActor* DamageCauser, AController* InstigatedByController, bool bDoFullDamage, uint8_t DamagePreventionChannel);
    static bool ApplyRadialDamageWithFalloff(const UObject* WorldContextObject, float BaseDamage, float MinimumDamage, const FVector& Origin, float DamageInnerRadius, float DamageOuterRadius, float DamageFalloff, UClass* DamageTypeClass, const TArray<AActor*>& IgnoreActors, AActor* DamageCauser, AController* InstigatedByController, uint8_t DamagePreventionChannel);
    static bool AreAnyListenersWithinRange(const UObject* WorldContextObject, const FVector& Location, float MaximumRange);
    static bool AreSubtitlesEnabled();
    static AActor* BeginDeferredActorSpawnFromClass(const UObject* WorldContextObject, UClass* ActorClass, const FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod CollisionHandlingOverride, AActor* Owner, ESpawnActorScaleMethod TransformScaleMethod);
    static AActor* BeginSpawningActorFromBlueprint(const UObject* WorldContextObject, const UBlueprint* Blueprint, const FTransform& SpawnTransform, bool bNoCollisionFail);
    static bool BlueprintSuggestProjectileVelocity(const UObject* WorldContextObject, FVector& TossVelocity, FVector StartLocation, FVector EndLocation, float LaunchSpeed, float OverrideGravityZ, uint8_t TraceOption, float collisionRadius, bool bFavorHighArc, bool bDrawDebug, bool bAcceptClosestOnNoSolutions);
    static bool Blueprint_PredictProjectilePath_Advanced(const UObject* WorldContextObject, const FPredictProjectilePathParams& PredictParams, FPredictProjectilePathResult& PredictResult);
    static bool Blueprint_PredictProjectilePath_ByObjectType(const UObject* WorldContextObject, FHitResult& OutHit, TArray<FVector>& OutPathPositions, FVector& OutLastTraceDestination, FVector StartPos, FVector LaunchVelocity, bool bTracePath, float ProjectileRadius, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, float DrawDebugTime, float SimFrequency, float MaxSimTime, float OverrideGravityZ);
    static bool Blueprint_PredictProjectilePath_ByTraceChannel(const UObject* WorldContextObject, FHitResult& OutHit, TArray<FVector>& OutPathPositions, FVector& OutLastTraceDestination, FVector StartPos, FVector LaunchVelocity, bool bTracePath, float ProjectileRadius, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, float DrawDebugTime, float SimFrequency, float MaxSimTime, float OverrideGravityZ);
    static void BreakHitResult(const FHitResult& Hit, bool& bBlockingHit, bool& bInitialOverlap, float& Time, float& Distance, FVector& Location, FVector& ImpactPoint, FVector& Normal, FVector& ImpactNormal, UPhysicalMaterial*& PhysMat, AActor*& HitActor, UPrimitiveComponent*& HitComponent, FName& HitBoneName, FName& BoneName, int32_t& HitItem, int32_t& ElementIndex, int32_t& FaceIndex, FVector& TraceStart, FVector& TraceEnd);
    static void CancelAsyncLoading();
    static void ClearSoundMixClassOverride(const UObject* WorldContextObject, USoundMix* InSoundMixModifier, USoundClass* InSoundClass, float fadeOutTime);
    static void ClearSoundMixModifiers(const UObject* WorldContextObject);
    static APlayerController* CreatePlayer(const UObject* WorldContextObject, int32_t ControllerId, bool bSpawnPlayerController);
    static APlayerController* CreatePlayerFromPlatformUser(const UObject* WorldContextObject, FPlatformUserId UserId, bool bSpawnPlayerController);
    static USaveGame* CreateSaveGameObject(UClass* SaveGameClass);
    static UAudioComponent* CreateSound2D(const UObject* WorldContextObject, USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy);
    static void DeactivateReverbEffect(const UObject* WorldContextObject, FName TagName);
    static bool DeleteGameInSlot(FString SlotName, const int32_t UserIndex);
    static bool DeprojectSceneCaptureComponentToWorld(USceneCaptureComponent2D* SceneCaptureComponent2D, const FVector2D& TargetUV, FVector& WorldPosition, FVector& WorldDirection);
    static bool DeprojectSceneCaptureToWorld(ASceneCapture2D* SceneCapture2D, const FVector2D& TargetUV, FVector& WorldPosition, FVector& WorldDirection);
    static bool DeprojectScreenToWorld(APlayerController* Player, const FVector2D& screenPosition, FVector& WorldPosition, FVector& WorldDirection);
    static bool DoesSaveGameExist(FString SlotName, const int32_t UserIndex);
    static void EnableLiveStreaming(bool Enable);
    static bool FindCollisionUV(const FHitResult& Hit, int32_t UVChannel, FVector2D& UV);
    static AActor* FindNearestActor(FVector Origin, const TArray<AActor*>& ActorsToCheck, float& Distance);
    static AActor* FinishSpawningActor(AActor* Actor, const FTransform& SpawnTransform, ESpawnActorScaleMethod TransformScaleMethod);
    static void FlushLevelStreaming(const UObject* WorldContextObject);
    static void GetAccurateRealTime(int32_t& Seconds, double& PartialSeconds);
    static FName GetActiveSpatialPluginName(const UObject* WorldContextObject);
    static FVector GetActorArrayAverageLocation(const TArray<AActor*>& Actors);
    static void GetActorArrayBounds(const TArray<AActor*>& Actors, bool bOnlyCollidingComponents, FVector& Center, FVector& BoxExtent);
    static AActor* GetActorOfClass(const UObject* WorldContextObject, UClass* ActorClass);
    static void GetAllActorsOfClass(const UObject* WorldContextObject, UClass* ActorClass, TArray<AActor*>& OutActors);
    static void GetAllActorsOfClassWithTag(const UObject* WorldContextObject, UClass* ActorClass, FName Tag, TArray<AActor*>& OutActors);
    static void GetAllActorsWithInterface(const UObject* WorldContextObject, UClass* Interface, TArray<AActor*>& OutActors);
    static void GetAllActorsWithTag(const UObject* WorldContextObject, FName Tag, TArray<AActor*>& OutActors);
    static double GetAudioTimeSeconds(const UObject* WorldContextObject);
    static TArray<FName> GetAvailableSpatialPluginNames(const UObject* WorldContextObject);
    static bool GetClosestListenerLocation(const UObject* WorldContextObject, const FVector& Location, float MaximumRange, const bool bAllowAttenuationOverride, FVector& ListenerPosition);
    static FString GetCurrentLevelName(const UObject* WorldContextObject, bool bRemovePrefixString);
    static UReverbEffect* GetCurrentReverbEffect(const UObject* WorldContextObject);
    static bool GetEnableWorldRendering(const UObject* WorldContextObject);
    static UGameInstance* GetGameInstance(const UObject* WorldContextObject);
    static AGameModeBase* GetGameMode(const UObject* WorldContextObject);
    static AGameStateBase* GetGameState(const UObject* WorldContextObject);
    static float GetGlobalTimeDilation(const UObject* WorldContextObject);
    static int32_t GetIntOption(FString Options, FString Key, int32_t DefaultValue);
    static void GetKeyValue(FString Pair, FString& Key, FString& Value);
    static int32_t GetMaxAudioChannelCount(const UObject* WorldContextObject);
    static int32_t GetNumLocalPlayerControllers(const UObject* WorldContextObject);
    static int32_t GetNumPlayerControllers(const UObject* WorldContextObject);
    static int32_t GetNumPlayerStates(const UObject* WorldContextObject);
    static UClass* GetObjectClass(const UObject* Object);
    static FString GetPlatformName();
    static APlayerCameraManager* GetPlayerCameraManager(const UObject* WorldContextObject, int32_t PlayerIndex);
    static ACharacter* GetPlayerCharacter(const UObject* WorldContextObject, int32_t PlayerIndex);
    static APlayerController* GetPlayerController(const UObject* WorldContextObject, int32_t PlayerIndex);
    static APlayerController* GetPlayerControllerFromID(const UObject* WorldContextObject, int32_t ControllerId);
    static APlayerController* GetPlayerControllerFromPlatformUser(const UObject* WorldContextObject, FPlatformUserId UserId);
    static int32_t GetPlayerControllerID(APlayerController* Player);
    static APawn* GetPlayerPawn(const UObject* WorldContextObject, int32_t PlayerIndex);
    static APlayerState* GetPlayerState(const UObject* WorldContextObject, int32_t PlayerStateIndex);
    static APlayerState* GetPlayerStateFromUniqueNetId(const UObject* WorldContextObject, const FUniqueNetIdRepl& UniqueID);
    static double GetRealTimeSeconds(const UObject* WorldContextObject);
    static ULevelStreaming* GetStreamingLevel(const UObject* WorldContextObject, FName PackageName);
    static uint8_t GetSurfaceType(const FHitResult& Hit);
    static double GetTimeSeconds(const UObject* WorldContextObject);
    static double GetUnpausedTimeSeconds(const UObject* WorldContextObject);
    static void GetViewProjectionMatrix(FMinimalViewInfo DesiredView, FMatrix& ViewMatrix, FMatrix& ProjectionMatrix, FMatrix& ViewProjectionMatrix);
    static EMouseCaptureMode GetViewportMouseCaptureMode(const UObject* WorldContextObject);
    static double GetWorldDeltaSeconds(const UObject* WorldContextObject);
    static FIntVector GetWorldOriginLocation(const UObject* WorldContextObject);
    static int32_t GrassOverlappingSphereCount(const UObject* WorldContextObject, const UStaticMesh* StaticMesh, FVector CenterPosition, float Radius);
    static bool HasLaunchOption(FString OptionToCheck);
    static bool HasOption(FString Options, FString InKey);
    static bool IsAnyLocalPlayerCameraWithinRange(const UObject* WorldContextObject, const FVector& Location, float MaximumRange);
    static bool IsGamePaused(const UObject* WorldContextObject);
    static bool IsSplitscreenForceDisabled(const UObject* WorldContextObject);
    static USaveGame* LoadGameFromSlot(FString SlotName, const int32_t UserIndex);
    static void LoadStreamLevel(const UObject* WorldContextObject, FName LevelName, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, FLatentActionInfo LatentInfo);
    static void LoadStreamLevelBySoftObjectPtr(const UObject* WorldContextObject, const TSoftObjectPtr<UWorld> Level, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, FLatentActionInfo LatentInfo);
    static FHitResult MakeHitResult(bool bBlockingHit, bool bInitialOverlap, float Time, float Distance, FVector Location, FVector ImpactPoint, FVector Normal, FVector ImpactNormal, UPhysicalMaterial* PhysMat, AActor* HitActor, UPrimitiveComponent* HitComponent, FName HitBoneName, FName BoneName, int32_t HitItem, int32_t ElementIndex, int32_t FaceIndex, FVector TraceStart, FVector TraceEnd);
    static bool ObjectIsA(const UObject* Object, UClass* ObjectClass);
    static void OpenLevel(const UObject* WorldContextObject, FName LevelName, bool bAbsolute, FString Options);
    static void OpenLevelBySoftObjectPtr(const UObject* WorldContextObject, const TSoftObjectPtr<UWorld> Level, bool bAbsolute, FString Options);
    static FString ParseOption(FString Options, FString Key);
    static void PlayDialogue2D(const UObject* WorldContextObject, UDialogueWave* Dialogue, const FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float StartTime);
    static void PlayDialogueAtLocation(const UObject* WorldContextObject, UDialogueWave* Dialogue, const FDialogueContext& Context, FVector Location, FRotator Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings);
    static void PlaySound2D(const UObject* WorldContextObject, USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundConcurrency* ConcurrencySettings, const AActor* OwningActor, bool bIsUISound);
    static void PlaySoundAtLocation(const UObject* WorldContextObject, USoundBase* Sound, FVector Location, FRotator Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings, USoundConcurrency* ConcurrencySettings, const AActor* OwningActor, const UInitialActiveSoundParams* InitialParams);
    static void PlayWorldCameraShake(const UObject* WorldContextObject, UClass* Shake, FVector Epicenter, float InnerRadius, float OuterRadius, float Falloff, bool bOrientShakeTowardsEpicenter);
    static void PopSoundMixModifier(const UObject* WorldContextObject, USoundMix* InSoundMixModifier);
    static void PrimeAllSoundsInSoundClass(USoundClass* InSoundClass);
    static void PrimeSound(USoundBase* InSound);
    static bool ProjectWorldToScreen(APlayerController* Player, const FVector& WorldPosition, FVector2D& screenPosition, bool bPlayerViewportRelative);
    static void PushSoundMixModifier(const UObject* WorldContextObject, USoundMix* InSoundMixModifier);
    static FVector RebaseLocalOriginOntoZero(UObject* WorldContextObject, FVector WorldLocation);
    static FVector RebaseZeroOriginOntoLocal(UObject* WorldContextObject, FVector WorldLocation);
    static void RemovePlayer(APlayerController* Player, bool bDestroyPawn);
    static bool SaveGameToSlot(USaveGame* SaveGameObject, FString SlotName, const int32_t UserIndex);
    static bool SetActiveSpatialPluginByName(const UObject* WorldContextObject, FName InPluginName);
    static void SetBaseSoundMix(const UObject* WorldContextObject, USoundMix* InSoundMix);
    static void SetEnableWorldRendering(const UObject* WorldContextObject, bool bEnable);
    static void SetForceDisableSplitscreen(const UObject* WorldContextObject, bool bDisable);
    static bool SetGamePaused(const UObject* WorldContextObject, bool bPaused);
    static void SetGlobalListenerFocusParameters(const UObject* WorldContextObject, float FocusAzimuthScale, float NonFocusAzimuthScale, float FocusDistanceScale, float NonFocusDistanceScale, float FocusVolumeScale, float NonFocusVolumeScale, float FocusPriorityScale, float NonFocusPriorityScale);
    static void SetGlobalPitchModulation(const UObject* WorldContextObject, float PitchModulation, float TimeSec);
    static void SetGlobalTimeDilation(const UObject* WorldContextObject, float TimeDilation);
    static void SetMaxAudioChannelsScaled(const UObject* WorldContextObject, float MaxChannelCountScale);
    static void SetPlayerControllerID(APlayerController* Player, int32_t ControllerId);
    static void SetPlayerPlatformUserId(APlayerController* PlayerController, FPlatformUserId UserId);
    static void SetSoundClassDistanceScale(const UObject* WorldContextObject, USoundClass* SoundClass, float DistanceAttenuationScale, float TimeSec);
    static void SetSoundMixClassOverride(const UObject* WorldContextObject, USoundMix* InSoundMixModifier, USoundClass* InSoundClass, float Volume, float Pitch, float fadeInTime, bool bApplyToChildren);
    static void SetSubtitlesEnabled(bool bEnabled);
    static void SetViewportMouseCaptureMode(const UObject* WorldContextObject, const EMouseCaptureMode MouseCaptureMode);
    static void SetWorldOriginLocation(const UObject* WorldContextObject, FIntVector NewLocation);
    static UDecalComponent* SpawnDecalAtLocation(const UObject* WorldContextObject, UMaterialInterface* DecalMaterial, FVector DecalSize, FVector Location, FRotator Rotation, float LifeSpan);
    static UDecalComponent* SpawnDecalAttached(UMaterialInterface* DecalMaterial, FVector DecalSize, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, uint8_t LocationType, float LifeSpan);
    static UAudioComponent* SpawnDialogue2D(const UObject* WorldContextObject, UDialogueWave* Dialogue, const FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float StartTime, bool bAutoDestroy);
    static UAudioComponent* SpawnDialogueAtLocation(const UObject* WorldContextObject, UDialogueWave* Dialogue, const FDialogueContext& Context, FVector Location, FRotator Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings, bool bAutoDestroy);
    static UAudioComponent* SpawnDialogueAttached(UDialogueWave* Dialogue, const FDialogueContext& Context, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, uint8_t LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings, bool bAutoDestroy);
    static UParticleSystemComponent* SpawnEmitterAtLocation(const UObject* WorldContextObject, UParticleSystem* EmitterTemplate, FVector Location, FRotator Rotation, FVector Scale, bool bAutoDestroy, EPSCPoolMethod PoolingMethod, bool bAutoActivateSystem);
    static UParticleSystemComponent* SpawnEmitterAttached(UParticleSystem* EmitterTemplate, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, FVector Scale, uint8_t LocationType, bool bAutoDestroy, EPSCPoolMethod PoolingMethod, bool bAutoActivate);
    static UForceFeedbackComponent* SpawnForceFeedbackAtLocation(const UObject* WorldContextObject, UForceFeedbackEffect* ForceFeedbackEffect, FVector Location, FRotator Rotation, bool bLooping, float IntensityMultiplier, float StartTime, UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy);
    static UForceFeedbackComponent* SpawnForceFeedbackAttached(UForceFeedbackEffect* ForceFeedbackEffect, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, uint8_t LocationType, bool bStopWhenAttachedToDestroyed, bool bLooping, float IntensityMultiplier, float StartTime, UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy);
    static UObject* SpawnObject(UClass* ObjectClass, UObject* Outer);
    static UAudioComponent* SpawnSound2D(const UObject* WorldContextObject, USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy);
    static UAudioComponent* SpawnSoundAtLocation(const UObject* WorldContextObject, USoundBase* Sound, FVector Location, FRotator Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings, USoundConcurrency* ConcurrencySettings, bool bAutoDestroy);
    static UAudioComponent* SpawnSoundAttached(USoundBase* Sound, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, uint8_t LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float StartTime, USoundAttenuation* AttenuationSettings, USoundConcurrency* ConcurrencySettings, bool bAutoDestroy);
    static bool SuggestProjectileVelocity_CustomArc(const UObject* WorldContextObject, FVector& OutLaunchVelocity, FVector StartPos, FVector EndPos, float OverrideGravityZ, float ArcParam);
    static bool SuggestProjectileVelocity_MovingTarget(const UObject* WorldContextObject, FVector& OutLaunchVelocity, FVector ProjectileStartLocation, AActor* TargetActor, FVector TargetLocationOffset, double GravityZOverride, double TimeToTarget, uint8_t DrawDebugType, float DrawDebugTime, FLinearColor DrawDebugColor);
    static FVector TransformWorldToFirstPerson(const FMinimalViewInfo& ViewInfo, const FVector& WorldPosition, bool bIgnoreFirstPersonScale);
    static void UnRetainAllSoundsInSoundClass(USoundClass* InSoundClass);
    static void UnloadStreamLevel(const UObject* WorldContextObject, FName LevelName, FLatentActionInfo LatentInfo, bool bShouldBlockOnUnload);
    static void UnloadStreamLevelBySoftObjectPtr(const UObject* WorldContextObject, const TSoftObjectPtr<UWorld> Level, FLatentActionInfo LatentInfo, bool bShouldBlockOnUnload);
};

// Size: 0x58
class UGarbageCollectionSettings : public UDeveloperSettings {
    /* 0x0038 */ float TimeBetweenPurgingPendingKillObjects;
    /* 0x003c */ bool FlushStreamingOnGC;
    /* 0x003c */ bool AllowParallelGC;
    /* 0x003c */ bool IncrementalBeginDestroyEnabled;
    /* 0x003c */ bool CreateGCClusters;
    /* 0x003c */ bool AssetClusteringEnabled;
    /* 0x003c */ bool ActorClusteringEnabled;
    /* 0x003c */ bool VerifyUObjectsAreNotFGCObjects;
    /* 0x003c */ bool GarbageEliminationEnabled;
    /* 0x003d */ bool DumpObjectCountsToLogWhenMaxObjectLimitExceeded;
    /* 0x0040 */ int32_t MinGCClusterSize;
    /* 0x0044 */ int32_t NumRetriesBeforeForcingGC;
    /* 0x0048 */ int32_t MaxObjectsNotConsideredByGC;
    /* 0x004c */ int32_t MaxObjectsInGame;
    /* 0x0050 */ int32_t MaxObjectsInEditor;
};

// Size: 0x84
struct FGaussianSumBloomSettings {
    /* 0x0000 */ float Intensity;
    /* 0x0004 */ float Threshold;
    /* 0x0008 */ float SizeScale;
    /* 0x000c */ float Filter1Size;
    /* 0x0010 */ float Filter2Size;
    /* 0x0014 */ float Filter3Size;
    /* 0x0018 */ float Filter4Size;
    /* 0x001c */ float Filter5Size;
    /* 0x0020 */ float Filter6Size;
    /* 0x0024 */ FLinearColor Filter1Tint;
    /* 0x0034 */ FLinearColor Filter2Tint;
    /* 0x0044 */ FLinearColor Filter3Tint;
    /* 0x0054 */ FLinearColor Filter4Tint;
    /* 0x0064 */ FLinearColor Filter5Tint;
    /* 0x0074 */ FLinearColor Filter6Tint;
};

// Size: 0x38
class UGeneratedBlueprintBinding : public UDynamicBlueprintBinding {
    /* 0x0028 */ TArray<FGeneratedBlueprintDelegateBinding> GeneratedBlueprintBindings;
};

// Size: 0x10
struct FGeneratedBlueprintDelegateBinding {
    /* 0x0000 */ FName DelegatePropertyName;
    /* 0x0008 */ FName FunctionNameToBind;
};

// Size: 0x2c0
class AGeneratedMeshAreaLight : public ASpotLight {
};

// Size: 0x4
struct FGenericStruct {
    /* 0x0000 */ int32_t Data;
};

// Size: 0xc
struct FGeomSelection {
    /* 0x0000 */ int32_t Type;
    /* 0x0004 */ int32_t Index;
    /* 0x0008 */ int32_t SelectionIndex;
};

// Size: 0x10
struct FGraphAssetPlayerInformation {
    /* 0x0000 */ TArray<int32_t> PlayerNodeIndices;
};

// Size: 0x50
class UGraphNodeContextMenuContext : public UObject {
    /* 0x0028 */ UBlueprint* Blueprint;
    /* 0x0030 */ UEdGraph* Graph;
    /* 0x0038 */ UEdGraphNode* Node;
    /* 0x0048 */ bool bIsDebugging;
};

// Size: 0x20
struct FGraphReference {
    /* 0x0000 */ UEdGraph* MacroGraph;
    /* 0x0008 */ UBlueprint* GraphBlueprint;
    /* 0x0010 */ FGuid GraphGuid;
};

// Size: 0x1c
struct FGridBlendSample {
    /* 0x0000 */ FEditorElement GridElement;
    /* 0x0018 */ float BlendWeight;
};

// Size: 0x50
struct FHLODBuildInputReferencedAssets {
    /* 0x0000 */ TMap<FTopLevelAssetPath, uint32_t> StaticMeshes;
};

// Size: 0x50
struct FHLODBuildInputStats {
    /* 0x0000 */ TMap<FName, FHLODBuildInputReferencedAssets> BuildersReferencedAssets;
};

// Size: 0x28
class UHLODBuilder : public UObject {
};

// Size: 0x28
class UHLODBuilderSettings : public UObject {
};

// Size: 0x30
class UHLODEngineSubsystem : public UEngineSubsystem {
};

// Size: 0x30
struct FHLODISMComponentDesc {
    /* 0x0000 */ UStaticMesh* StaticMesh;
    /* 0x0008 */ UMaterialInterface* Material;
    /* 0x0010 */ TArray<FTransform> Instances;
    /* 0x0020 */ TArray<FCustomPrimitiveData> InstancesCustomPrimitiveData;
};

// Size: 0x280
struct FHLODISMComponentDescriptor : public FISMComponentDescriptor {
};

// Size: 0xa80
class UHLODInstancedSkinnedMeshComponent : public UInstancedSkinnedMeshComponent {
};

// Size: 0x9b0
class UHLODInstancedStaticMeshComponent : public UInstancedStaticMeshComponent {
};

// Size: 0x10
struct FHLODInstancingKey {
    /* 0x0000 */ UStaticMesh* StaticMesh;
    /* 0x0008 */ UMaterialInterface* Material;
};

// Size: 0x68
class UHLODLayer : public UObject {
    /* 0x0028 */ EHLODLayerType LayerType;
    /* 0x0030 */ UClass* HLODBuilderClass;
    /* 0x0038 */ UHLODBuilderSettings* HLODBuilderSettings;
    /* 0x0040 */ bool bIsSpatiallyLoaded;
    /* 0x0044 */ int32_t CellSize;
    /* 0x0048 */ double LoadingRange;
    /* 0x0050 */ UHLODLayer* ParentLayer;
    /* 0x0058 */ UClass* HLODActorClass;
    /* 0x0060 */ UClass* HLODModifierClass;
};

// Size: 0xc
struct FHLODModifierScalarParameter {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ float OverrideValue;
};

// Size: 0x88
class UHLODProxy : public UObject {
    /* 0x0028 */ TArray<FHLODProxyMesh> ProxyMeshes;
    /* 0x0038 */ TMap<UHLODProxyDesc*, FHLODProxyMesh> HLODActors;
};

// Size: 0x28
class UHLODProxyDesc : public UObject {
};

// Size: 0x28
struct FHLODProxyMesh {
    /* 0x0000 */ TLazyObjectPtr<ALODActor> LODActor;
    /* 0x0018 */ UStaticMesh* StaticMesh;
    /* 0x0020 */ FName Key;
};

// Size: 0x90
struct FHLODSkinnedMeshComponentDescriptor : public FSkinnedMeshComponentDescriptor {
};

// Size: 0x398
class AHUD : public AActor {
    /* 0x02a8 */ APlayerController* PlayerOwner;
    /* 0x02b0 */ bool bLostFocusPaused;
    /* 0x02b0 */ bool bShowHUD;
    /* 0x02b0 */ bool bShowDebugInfo;
    /* 0x02b4 */ int32_t CurrentTargetIndex;
    /* 0x02b8 */ bool bShowHitBoxDebugInfo;
    /* 0x02b8 */ bool bShowOverlays;
    /* 0x02b8 */ bool bEnableDebugTextShadow;
    /* 0x02c0 */ TArray<AActor*> PostRenderedActors;
    /* 0x02d8 */ TArray<FName> DebugDisplay;
    /* 0x02e8 */ TArray<FName> ToggledDebugCategories;
    /* 0x02f8 */ UCanvas* Canvas;
    /* 0x0300 */ UCanvas* DebugCanvas;
    /* 0x0308 */ TArray<FDebugTextInfo> DebugTextList;
    /* 0x0318 */ UClass* ShowDebugTargetDesiredClass;
    /* 0x0320 */ AActor* ShowDebugTargetActor;

    void AddDebugText(FString DebugText, AActor* SrcActor, float Duration, FVector Offset, FVector DesiredOffset, FColor TextColor, bool bSkipOverwriteCheck, bool bAbsoluteLocation, bool bKeepAttachedToActor, UFont* InFont, float FontScale, bool bDrawShadow);
    void AddHitBox(FVector2D position, FVector2D Size, FName InName, bool bConsumesInput, int32_t Priority);
    void Deproject(float ScreenX, float ScreenY, FVector& WorldPosition, FVector& WorldDirection) const;
    void DrawLine(float StartScreenX, float StartScreenY, float EndScreenX, float EndScreenY, FLinearColor LineColor, float LineThickness);
    void DrawMaterial(UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float Scale, bool bScalePosition, float Rotation, FVector2D RotPivot);
    void DrawMaterialSimple(UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float Scale, bool bScalePosition);
    void DrawMaterialTriangle(UMaterialInterface* Material, FVector2D V0_Pos, FVector2D V1_Pos, FVector2D V2_Pos, FVector2D V0_UV, FVector2D V1_UV, FVector2D V2_UV, FLinearColor V0_Color, FLinearColor V1_Color, FLinearColor V2_Color);
    void DrawRect(FLinearColor RectColor, float ScreenX, float ScreenY, float ScreenW, float ScreenH);
    void DrawText(FString Text, FLinearColor TextColor, float ScreenX, float ScreenY, UFont* Font, float Scale, bool bScalePosition);
    void DrawTexture(UTexture* Texture, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float TextureU, float TextureV, float TextureUWidth, float TextureVHeight, FLinearColor TintColor, uint8_t BlendMode, float Scale, bool bScalePosition, float Rotation, FVector2D RotPivot);
    void DrawTextureSimple(UTexture* Texture, float ScreenX, float ScreenY, float Scale, bool bScalePosition);
    void GetActorsInSelectionRectangle(UClass* ClassFilter, const FVector2D& FirstPoint, const FVector2D& SecondPoint, TArray<AActor*>& OutActors, bool bIncludeNonCollidingComponents, bool bActorMustBeFullyEnclosed);
    APawn* GetOwningPawn() const;
    APlayerController* GetOwningPlayerController() const;
    void GetTextSize(FString Text, float& OutWidth, float& OutHeight, UFont* Font, float Scale) const;
    void NextDebugTarget();
    void PreviousDebugTarget();
    FVector Project(FVector Location, bool bClampToZeroPlane) const;
    void ReceiveDrawHUD(int32_t SizeX, int32_t SizeY);
    void ReceiveHitBoxBeginCursorOver(const FName BoxName);
    void ReceiveHitBoxClick(const FName BoxName);
    void ReceiveHitBoxEndCursorOver(const FName BoxName);
    void ReceiveHitBoxRelease(const FName BoxName);
    void RemoveAllDebugStrings();
    void RemoveDebugText(AActor* SrcActor, bool bLeaveDurationText);
    void ShowDebug(FName DebugType);
    void ShowDebugForReticleTargetToggle(UClass* DesiredClass);
    void ShowDebugToggleSubCategory(FName Category);
    void ShowHUD();
};

// Size: 0x110
struct FHapticFeedbackDetails_Curve {
    /* 0x0000 */ FRuntimeFloatCurve Frequency;
    /* 0x0088 */ FRuntimeFloatCurve Amplitude;
};

// Size: 0x28
class UHapticFeedbackEffect_Base : public UObject {
};

// Size: 0x40
class UHapticFeedbackEffect_Buffer : public UHapticFeedbackEffect_Base {
    /* 0x0028 */ TArray<uint8_t> Amplitudes;
    /* 0x0038 */ int32_t SampleRate;
};

// Size: 0x138
class UHapticFeedbackEffect_Curve : public UHapticFeedbackEffect_Base {
    /* 0x0028 */ FHapticFeedbackDetails_Curve HapticDetails;
};

// Size: 0x48
class UHapticFeedbackEffect_SoundWave : public UHapticFeedbackEffect_Base {
    /* 0x0028 */ USoundWave* SoundWave;
    /* 0x0030 */ bool bUseStereo;
};

// Size: 0x18
struct FHardwareCursorReference {
    /* 0x0000 */ FName CursorPath;
    /* 0x0008 */ FVector2D HotSpot;
};

// Size: 0x18
struct FHardwareDeviceIdentifier {
    /* 0x0000 */ FName InputClassName;
    /* 0x0008 */ FName HardwareDeviceIdentifier;
    /* 0x0010 */ EHardwareDevicePrimaryType PrimaryDeviceType;
    /* 0x0014 */ int32_t SupportedFeaturesMask;
};

// Size: 0x28
class UHealthSnapshotBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void LogPerformanceSnapshot(const FString SnapshotTitle, bool bResetStats);
    static void StartPerformanceSnapshots();
    static void StopPerformanceSnapshots();
};

// Size: 0x2b0
class AHeterogeneousVolume : public AInfo {
    /* 0x02a8 */ UHeterogeneousVolumeComponent* HeterogeneousVolumeComponent;
};

// Size: 0x620
class UHeterogeneousVolumeComponent : public UMeshComponent {
    /* 0x0568 */ FIntVector VolumeResolution;
    /* 0x0580 */ FTransform FrameTransform;
    /* 0x05e0 */ float Frame;
    /* 0x05e4 */ float FrameRate;
    /* 0x05e8 */ float StartFrame;
    /* 0x05ec */ float EndFrame;
    /* 0x05f0 */ bool bPlaying;
    /* 0x05f0 */ bool bLooping;
    /* 0x05f4 */ float StreamingMipBias;
    /* 0x05f8 */ bool bIssueBlockingRequests;
    /* 0x05f8 */ bool bPivotAtCentroid;
    /* 0x05fc */ float StepFactor;
    /* 0x0600 */ float ShadowStepFactor;
    /* 0x0604 */ float ShadowBiasFactor;
    /* 0x0608 */ float LightingDownsampleFactor;
    /* 0x0610 */ UMaterialInstanceDynamic* MaterialInstanceDynamic;

    void Play();
    void SetEndFrame(float NewValue);
    void SetFrame(float NewValue);
    void SetFrameRate(float NewValue);
    void SetLooping(bool NewValue);
    void SetPlaying(bool NewValue);
    void SetStartFrame(float NewValue);
    void SetStreamingMipBias(int32_t NewValue);
    void SetVolumeResolution(FIntVector NewValue);
};

// Size: 0xb50
class UHierarchicalInstancedStaticMeshComponent : public UInstancedStaticMeshComponent {
    /* 0x09c0 */ bool bUseTranslatedInstanceSpace;
    /* 0x09c8 */ FVector TranslatedInstanceSpaceOrigin;
    /* 0x09e0 */ TArray<int32_t> SortedInstances;
    /* 0x09f0 */ int32_t NumBuiltInstances;
    /* 0x09f8 */ FBox BuiltInstanceBounds;
    /* 0x0a30 */ FBox UnbuiltInstanceBounds;
    /* 0x0a68 */ TArray<FBox> UnbuiltInstanceBoundsList;
    /* 0x0a78 */ bool bEnableDensityScaling;
    /* 0x0a80 */ int32_t OcclusionLayerNumNodes;
    /* 0x0a88 */ FBoxSphereBounds CacheMeshExtendedBounds;
    /* 0x0ac0 */ int32_t InstanceCountToRender;
};

// Size: 0x60
class UHierarchicalLODSetup : public UObject {
    /* 0x0028 */ TArray<FHierarchicalSimplification> HierarchicalLODSetup;
    /* 0x0038 */ TSoftObjectPtr<UMaterialInterface> OverrideBaseMaterial;
};

// Size: 0x3b0
struct FHierarchicalSimplification {
    /* 0x0000 */ float TransitionScreenSize;
    /* 0x0004 */ float OverrideDrawDistance;
    /* 0x0008 */ bool bUseOverrideDrawDistance;
    /* 0x0008 */ bool bAllowSpecificExclusion;
    /* 0x0008 */ bool bOnlyGenerateClustersForVolumes;
    /* 0x0008 */ bool bReusePreviousLevelClusters;
    /* 0x0009 */ EHierarchicalSimplificationMethod SimplificationMethod;
    /* 0x0010 */ FMeshProxySettings ProxySetting;
    /* 0x0140 */ FMeshMergingSettings MergeSetting;
    /* 0x0278 */ FMeshApproximationSettings ApproximateSettings;
    /* 0x03a0 */ float DesiredBoundRadius;
    /* 0x03a4 */ float DesiredFillingPercentage;
    /* 0x03a8 */ int32_t MinNumberOfActorsToBuild;
};

// Size: 0x100
struct FHitResult {
    /* 0x0000 */ int32_t FaceIndex;
    /* 0x0004 */ float Time;
    /* 0x0008 */ float Distance;
    /* 0x0010 */ FVector_NetQuantize Location;
    /* 0x0028 */ FVector_NetQuantize ImpactPoint;
    /* 0x0040 */ FVector_NetQuantizeNormal Normal;
    /* 0x0058 */ FVector_NetQuantizeNormal ImpactNormal;
    /* 0x0070 */ FVector_NetQuantize TraceStart;
    /* 0x0088 */ FVector_NetQuantize TraceEnd;
    /* 0x00a0 */ float PenetrationDepth;
    /* 0x00a4 */ int32_t MyItem;
    /* 0x00a8 */ int32_t Item;
    /* 0x00ac */ uint8_t ElementIndex;
    /* 0x00ad */ bool bBlockingHit;
    /* 0x00ad */ bool bStartPenetrating;
    /* 0x00b0 */ TWeakObjectPtr<UPhysicalMaterial> PhysMaterial;
    /* 0x00b8 */ FActorInstanceHandle HitObjectHandle;
    /* 0x00d8 */ TWeakObjectPtr<UPrimitiveComponent> Component;
    /* 0x00f0 */ FName BoneName;
    /* 0x00f8 */ FName MyBoneName;
};

// Size: 0x10
struct FHitResultNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FISMClientData {
    /* 0x0000 */ TArray<FISMClientInstance> Instances;
};

// Size: 0x14
struct FISMClientHandle {
    /* 0x0000 */ int32_t Index;
    /* 0x0004 */ FGuid Guid;
};

// Size: 0x10
struct FISMClientInstance {
    /* 0x0000 */ TArray<int32_t> ComponentIndices;
};

// Size: 0x10
struct FISMClientInstanceManagerData {
};

// Size: 0x1
struct FISMComponentData {
};

// Size: 0x280
struct FISMComponentDescriptor : public FISMComponentDescriptorBase {
    /* 0x01d8 */ UStaticMesh* StaticMesh;
    /* 0x01e0 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x01f0 */ UMaterialInterface* OverlayMaterial;
    /* 0x01f8 */ TArray<URuntimeVirtualTexture*> RuntimeVirtualTextures;
    /* 0x0210 */ FTransform LocalTransform;
    /* 0x0270 */ TWeakObjectPtr<UStaticMeshComponent> StaticMeshComponent;
};

// Size: 0x1d8
struct FISMComponentDescriptorBase {
    /* 0x0008 */ uint32_t Hash;
    /* 0x0010 */ UClass* ComponentClass;
    /* 0x0018 */ uint8_t Mobility;
    /* 0x0019 */ ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType;
    /* 0x001a */ ELightmapType LightmapType;
    /* 0x001b */ FLightingChannels LightingChannels;
    /* 0x001c */ int32_t RayTracingGroupId;
    /* 0x0020 */ ERayTracingGroupCullingPriority RayTracingGroupCullingPriority;
    /* 0x0021 */ uint8_t bHasCustomNavigableGeometry;
    /* 0x0022 */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x0028 */ FBodyInstance BodyInstance;
    /* 0x01a8 */ int32_t InstanceMinDrawDistance;
    /* 0x01ac */ int32_t InstanceStartCullDistance;
    /* 0x01b0 */ int32_t InstanceEndCullDistance;
    /* 0x01b4 */ float InstanceLODDistanceScale;
    /* 0x01b8 */ int32_t VirtualTextureCullMips;
    /* 0x01bc */ int32_t TranslucencySortPriority;
    /* 0x01c0 */ int32_t OverriddenLightMapRes;
    /* 0x01c4 */ int32_t CustomDepthStencilValue;
    /* 0x01c8 */ bool bCastShadow;
    /* 0x01c8 */ bool bEmissiveLightSource;
    /* 0x01c8 */ bool bCastDynamicShadow;
    /* 0x01c8 */ bool bCastStaticShadow;
    /* 0x01c8 */ bool bCastContactShadow;
    /* 0x01c8 */ bool bCastShadowAsTwoSided;
    /* 0x01c8 */ bool bCastHiddenShadow;
    /* 0x01c8 */ bool bAffectDynamicIndirectLighting;
    /* 0x01c9 */ bool bAffectDynamicIndirectLightingWhileHidden;
    /* 0x01c9 */ bool bAffectDistanceFieldLighting;
    /* 0x01c9 */ bool bReceivesDecals;
    /* 0x01c9 */ bool bOverrideLightMapRes;
    /* 0x01c9 */ bool bUseAsOccluder;
    /* 0x01c9 */ bool bEnableDensityScaling;
    /* 0x01c9 */ bool bEnableDiscardOnLoad;
    /* 0x01c9 */ bool bRenderCustomDepth;
    /* 0x01ca */ bool bVisibleInRayTracing;
    /* 0x01ca */ bool bRenderInMainPass;
    /* 0x01ca */ bool bRenderInDepthPass;
    /* 0x01ca */ bool bHiddenInGame;
    /* 0x01ca */ bool bIsEditorOnly;
    /* 0x01ca */ bool bVisible;
    /* 0x01ca */ bool bSelectable;
    /* 0x01ca */ bool bHasPerInstanceHitProxies;
    /* 0x01cb */ bool bEvaluateWorldPositionOffset;
    /* 0x01cb */ bool bReverseCulling;
    /* 0x01cb */ bool bUseGpuLodSelection;
    /* 0x01cb */ bool bUseDefaultCollision;
    /* 0x01cb */ bool bGenerateOverlapEvents;
    /* 0x01cb */ bool bOverrideNavigationExport;
    /* 0x01cb */ bool bForceNavigationObstacle;
    /* 0x01cb */ bool bCanEverAffectNavigation;
    /* 0x01cc */ bool bFillCollisionUnderneathForNavmesh;
    /* 0x01cc */ bool bRasterizeAsFilledConvexVolume;
    /* 0x01d0 */ int32_t WorldPositionOffsetDisableDistance;
    /* 0x01d4 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
    /* 0x01d5 */ uint8_t DetailMode;
};

// Size: 0xc
struct FISMComponentInstance {
    /* 0x0000 */ int32_t ClientIndex;
    /* 0x0004 */ int32_t InstanceIndex;
    /* 0x0008 */ int32_t InstanceSubIndex;
};

// Size: 0x2b8
class AISMPartitionActor : public APartitionActor {
};

// Size: 0x28
class IISMPartitionInstanceManager : public UInterface {
};

// Size: 0x28
class IISMPartitionInstanceManagerProvider : public UInterface {
};

// Size: 0x20
struct FImportFactorySettingValues {
    /* 0x0000 */ FString SettingName;
    /* 0x0010 */ FString Value;
};

// Size: 0x28
class UImportanceSamplingLibrary : public UBlueprintFunctionLibrary {

    static void BreakImportanceTexture(const FImportanceTexture& ImportanceTexture, UTexture2D*& Texture, uint8_t& WeightingFunc);
    static void ImportanceSample(const FImportanceTexture& Texture, const FVector2D& Rand, int32_t Samples, float Intensity, FVector2D& SamplePosition, FLinearColor& SampleColor, float& SampleIntensity, float& SampleSize);
    static FImportanceTexture MakeImportanceTexture(UTexture2D* Texture, uint8_t WeightingFunc);
    static FVector2D NextSobolCell2D(int32_t Index, int32_t NumCells, FVector2D PreviousValue);
    static FVector NextSobolCell3D(int32_t Index, int32_t NumCells, FVector PreviousValue);
    static float NextSobolFloat(int32_t Index, int32_t Dimension, float PreviousValue);
    static FVector2D RandomSobolCell2D(int32_t Index, int32_t NumCells, FVector2D cell, FVector2D Seed);
    static FVector RandomSobolCell3D(int32_t Index, int32_t NumCells, FVector cell, FVector Seed);
    static float RandomSobolFloat(int32_t Index, int32_t Dimension, float Seed);
};

// Size: 0x60
struct FImportanceTexture {
    /* 0x0000 */ FIntPoint Size;
    /* 0x0008 */ int32_t NumMips;
    /* 0x0010 */ TArray<float> MarginalCDF;
    /* 0x0020 */ TArray<float> ConditionalCDF;
    /* 0x0030 */ TArray<FColor> TextureData;
    /* 0x0040 */ TArray<FLinearColor> LinearTextureData;
    /* 0x0050 */ TWeakObjectPtr<UTexture2D> Texture;
    /* 0x0058 */ uint8_t Weighting;
};

// Size: 0x28
class IImportantToggleSettingInterface : public UInterface {
};

// Size: 0x60
class UInGameAdManager : public UPlatformInterfaceBase {
    /* 0x0038 */ bool bShouldPauseWhileAdOpen;
    /* 0x0040 */ TArray<FDelegate> ClickedBannerDelegates;
    /* 0x0050 */ TArray<FDelegate> ClosedAdDelegates;
};

// Size: 0x68
struct FIndexedCurve {
    /* 0x0008 */ FKeyHandleMap KeyHandlesToIndices;
};

// Size: 0x60
struct FInertializationBoneDiff {
};

// Size: 0xc0
struct FInertializationPose {
};

// Size: 0x38
struct FInertializationPoseDiff {
};

// Size: 0x58
struct FInertializationRequest {
    /* 0x0000 */ float Duration;
    /* 0x0008 */ UBlendProfile* BlendProfile;
    /* 0x0010 */ bool bUseBlendMode;
    /* 0x0011 */ EAlphaBlendOption BlendMode;
    /* 0x0018 */ UCurveFloat* CustomBlendCurve;
    /* 0x0020 */ FName Tag;
    /* 0x0028 */ FText Description;
    /* 0x0038 */ FString DescriptionString;
    /* 0x0048 */ int32_t NodeID;
    /* 0x0050 */ UObject* AnimInstance;
};

// Size: 0x2a8
class AInfo : public AActor {
};

// Size: 0x48
class UInheritableComponentHandler : public UObject {
    /* 0x0028 */ TArray<FComponentOverrideRecord> Records;
    /* 0x0038 */ TArray<UActorComponent*> UnnecessaryComponents;
};

// Size: 0x38
class UInitialActiveSoundParams : public UObject {
    /* 0x0028 */ TArray<FAudioParameter> AudioParams;
};

// Size: 0x38
class UInputActionDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputActionDelegateBinding> InputActionDelegateBindings;
};

// Size: 0x28
struct FInputActionKeyMapping {
    /* 0x0000 */ FName ActionName;
    /* 0x0008 */ bool bShift;
    /* 0x0008 */ bool bCtrl;
    /* 0x0008 */ bool bAlt;
    /* 0x0008 */ bool bCmd;
    /* 0x0010 */ FKey Key;
};

// Size: 0x10
struct FInputActionSpeechMapping {
    /* 0x0000 */ FName ActionName;
    /* 0x0008 */ FName SpeechKeyword;
};

// Size: 0x48
struct FInputAlphaBoolBlend {
    /* 0x0000 */ float BlendInTime;
    /* 0x0004 */ float BlendOutTime;
    /* 0x0008 */ EAlphaBlendOption BlendOption;
    /* 0x0009 */ bool bInitialized;
    /* 0x0010 */ UCurveFloat* CustomCurve;
    /* 0x0018 */ FAlphaBlend AlphaBlend;
};

// Size: 0x18
struct FInputAxisConfigEntry {
    /* 0x0000 */ FName AxisKeyName;
    /* 0x0008 */ FInputAxisProperties AxisProperties;
};

// Size: 0x38
class UInputAxisDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputAxisDelegateBinding> InputAxisDelegateBindings;
};

// Size: 0x38
class UInputAxisKeyDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputAxisKeyDelegateBinding> InputAxisKeyDelegateBindings;
};

// Size: 0x28
struct FInputAxisKeyMapping {
    /* 0x0000 */ FName AxisName;
    /* 0x0008 */ float Scale;
    /* 0x0010 */ FKey Key;
};

// Size: 0x10
struct FInputAxisProperties {
    /* 0x0000 */ float DeadZone;
    /* 0x0004 */ float Sensitivity;
    /* 0x0008 */ float Exponent;
    /* 0x000c */ bool bInvert;
};

// Size: 0x10
struct FInputBlendPose {
    /* 0x0000 */ TArray<FBranchFilter> BranchFilters;
};

// Size: 0x14
struct FInputClampConstants {
    /* 0x0000 */ bool bClampResult;
    /* 0x0001 */ bool bInterpResult;
    /* 0x0004 */ float ClampMin;
    /* 0x0008 */ float ClampMax;
    /* 0x000c */ float InterpSpeedIncreasing;
    /* 0x0010 */ float InterpSpeedDecreasing;
};

// Size: 0x8
struct FInputClampState {
};

// Size: 0x140
class UInputComponent : public UActorComponent {
    /* 0x0128 */ TArray<FCachedKeyToActionInfo> CachedKeyToActionInfo;

    float GetControllerAnalogKeyState(FKey Key) const;
    void GetControllerAnalogStickState(uint8_t WhichStick, float& StickX, float& StickY) const;
    float GetControllerKeyTimeDown(FKey Key) const;
    void GetControllerMouseDelta(float& DeltaX, float& DeltaY) const;
    FVector GetControllerVectorKeyState(FKey Key) const;
    void GetTouchState(int32_t FingerIndex, float& LocationX, float& LocationY, bool& bIsCurrentlyPressed) const;
    bool IsControllerKeyDown(FKey Key) const;
    void OnInputOwnerEndPlayed(AActor* InOwner, uint8_t EndPlayReason);
    bool WasControllerKeyJustPressed(FKey Key) const;
    bool WasControllerKeyJustReleased(FKey Key) const;
};

// Size: 0x28
class UInputDelegateBinding : public UDynamicBlueprintBinding {
};

// Size: 0x88
class UInputDeviceAudioBasedVibrationProperty : public UInputDeviceProperty {
    /* 0x0030 */ FAudioBasedVibrationData Data;
    /* 0x0038 */ TMap<FName, FAudioBasedVibrationData> DeviceOverrideData;
};

// Size: 0x28
class UInputDeviceLibrary : public UBlueprintFunctionLibrary {

    static bool EqualEqual_InputDeviceId(FInputDeviceId A, FInputDeviceId B);
    static bool EqualEqual_PlatformUserId(FPlatformUserId A, FPlatformUserId B);
    static int32_t GetAllActiveUsers(TArray<FPlatformUserId>& OutUsers);
    static int32_t GetAllConnectedInputDevices(TArray<FInputDeviceId>& OutInputDevices);
    static int32_t GetAllInputDevices(TArray<FInputDeviceId>& OutInputDevices);
    static int32_t GetAllInputDevicesForUser(const FPlatformUserId UserId, TArray<FInputDeviceId>& OutInputDevices);
    static FInputDeviceId GetDefaultInputDevice();
    static EInputDeviceConnectionState GetInputDeviceConnectionState(const FInputDeviceId DeviceID);
    static APlayerController* GetPlayerControllerFromInputDevice(const FInputDeviceId DeviceID);
    static APlayerController* GetPlayerControllerFromPlatformUser(const FPlatformUserId UserId);
    static FInputDeviceId GetPrimaryInputDeviceForUser(FPlatformUserId UserId);
    static FPlatformUserId GetPrimaryPlatformUser();
    static FPlatformUserId GetUserForInputDevice(FInputDeviceId DeviceID);
    static FPlatformUserId GetUserForUnpairedInputDevices();
    static FInputDeviceId InputDeviceId_None();
    static bool IsDevicePropertyHandleValid(const FInputDevicePropertyHandle& InHandle);
    static bool IsInputDeviceMappedToUnpairedUser(const FInputDeviceId InputDevice);
    static bool IsUnpairedUserId(const FPlatformUserId PlatformId);
    static bool IsValidInputDevice(FInputDeviceId DeviceID);
    static bool IsValidPlatformId(FPlatformUserId UserId);
    static bool NotEqual_InputDeviceId(FInputDeviceId A, FInputDeviceId B);
    static bool NotEqual_PlatformUserId(FPlatformUserId A, FPlatformUserId B);
    static FPlatformUserId PlatformUserId_None();
};

// Size: 0x30
class UInputDeviceProperty : public UObject {
    /* 0x0028 */ float PropertyDuration;

    void ApplyDeviceProperty(const FPlatformUserId UserId, const FInputDeviceId DeviceID);
    void EvaluateDeviceProperty(const FPlatformUserId PlatformUser, const FInputDeviceId DeviceID, const float deltaTime, const float Duration);
    void ResetDeviceProperty(const FPlatformUserId PlatformUser, const FInputDeviceId DeviceID, bool bForceReset);
};

// Size: 0x4
struct FInputDevicePropertyHandle {
    /* 0x0000 */ uint32_t InternalId;
};

// Size: 0x198
class UInputDeviceSubsystem : public UEngineSubsystem {
    /* 0x0038 */ FMulticastInlineDelegate OnInputHardwareDeviceChanged;
    /* 0x0048 */ TSet<FActiveDeviceProperty> ActiveProperties;
    /* 0x0098 */ TSet<FInputDevicePropertyHandle> PropertiesPendingRemoval;

    FInputDevicePropertyHandle ActivateDevicePropertyOfClass(UClass* PropertyClass, const FActivateDevicePropertyParams& Params);
    UInputDeviceProperty* GetActiveDeviceProperty(const FInputDevicePropertyHandle Handle) const;
    FHardwareDeviceIdentifier GetInputDeviceHardwareIdentifier(const FInputDeviceId InputDevice) const;
    FHardwareDeviceIdentifier GetMostRecentlyUsedHardwareDevice(const FPlatformUserId InUserId) const;
    FInputDeviceId GetMostRecentlyUsedInputDeviceId(const FPlatformUserId InUserId, const EHardwareDevicePrimaryType OfType) const;
    bool IsPropertyActive(const FInputDevicePropertyHandle Handle) const;
    void RemoveAllDeviceProperties();
    void RemoveDevicePropertyByHandle(const FInputDevicePropertyHandle HandleToRemove);
    void RemoveDevicePropertyHandles(const TSet<FInputDevicePropertyHandle>& HandlesToRemove);
};

// Size: 0x40
class UInputDeviceTriggerEffect : public UInputDeviceProperty {
    /* 0x0030 */ FDeviceTriggerBaseData BaseTriggerData;
};

// Size: 0xb8
class UInputDeviceTriggerFeedbackProperty : public UInputDeviceTriggerEffect {
    /* 0x0040 */ FDeviceTriggerFeedbackData TriggerData;
    /* 0x0050 */ TMap<FName, FDeviceTriggerFeedbackData> DeviceOverrideData;
};

// Size: 0xc0
class UInputDeviceTriggerResistanceProperty : public UInputDeviceTriggerEffect {
    /* 0x0040 */ FDeviceTriggerTriggerResistanceData TriggerData;
    /* 0x0050 */ TMap<FName, FDeviceTriggerTriggerResistanceData> DeviceOverrideData;
};

// Size: 0xc0
class UInputDeviceTriggerVibrationProperty : public UInputDeviceTriggerEffect {
    /* 0x0040 */ FDeviceTriggerTriggerVibrationData TriggerData;
    /* 0x0058 */ TMap<FName, FDeviceTriggerTriggerVibrationData> DeviceOverrideData;
};

// Size: 0x38
class UInputKeyDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputKeyDelegateBinding> InputKeyDelegateBindings;
};

// Size: 0x70
class UInputPlatformSettings : public UPlatformSettings {
    /* 0x0040 */ int32_t MaxPlatformUserCount;
    /* 0x0044 */ EInputDeviceMappingPolicy DeviceMappingPolicy;
    /* 0x0048 */ int32_t MaxTriggerFeedbackPosition;
    /* 0x004c */ int32_t MaxTriggerFeedbackStrength;
    /* 0x0050 */ int32_t MaxTriggerVibrationTriggerPosition;
    /* 0x0054 */ int32_t MaxTriggerVibrationFrequency;
    /* 0x0058 */ int32_t MaxTriggerVibrationAmplitude;
    /* 0x0060 */ TArray<FHardwareDeviceIdentifier> HardwareDevices;
};

// Size: 0x8
struct FInputRange {
    /* 0x0000 */ float min;
    /* 0x0004 */ float max;
};

// Size: 0x8
struct FInputScaleBias {
    /* 0x0000 */ float Scale;
    /* 0x0004 */ float Bias;
};

// Size: 0x30
struct FInputScaleBiasClamp {
    /* 0x0000 */ bool bMapRange;
    /* 0x0001 */ bool bClampResult;
    /* 0x0002 */ bool bInterpResult;
    /* 0x0004 */ FInputRange InRange;
    /* 0x000c */ FInputRange OutRange;
    /* 0x0014 */ float Scale;
    /* 0x0018 */ float Bias;
    /* 0x001c */ float ClampMin;
    /* 0x0020 */ float ClampMax;
    /* 0x0024 */ float InterpSpeedIncreasing;
    /* 0x0028 */ float InterpSpeedDecreasing;
};

// Size: 0x2c
struct FInputScaleBiasClampConstants {
    /* 0x0000 */ bool bMapRange;
    /* 0x0001 */ bool bClampResult;
    /* 0x0002 */ bool bInterpResult;
    /* 0x0004 */ FInputRange InRange;
    /* 0x000c */ FInputRange OutRange;
    /* 0x0014 */ float Scale;
    /* 0x0018 */ float Bias;
    /* 0x001c */ float ClampMin;
    /* 0x0020 */ float ClampMax;
    /* 0x0024 */ float InterpSpeedIncreasing;
    /* 0x0028 */ float InterpSpeedDecreasing;
};

// Size: 0x8
struct FInputScaleBiasClampState {
};

// Size: 0x140
class UInputSettings : public UObject {
    /* 0x0028 */ TArray<FInputAxisConfigEntry> AxisConfig;
    /* 0x0038 */ FPerPlatformSettings PlatformSettings;
    /* 0x0048 */ bool bAltEnterTogglesFullscreen;
    /* 0x0048 */ bool bF11TogglesFullscreen;
    /* 0x0048 */ bool bUseMouseForTouch;
    /* 0x0048 */ bool bEnableMouseSmoothing;
    /* 0x0048 */ bool bEnableFOVScaling;
    /* 0x0048 */ bool bCaptureMouseOnLaunch;
    /* 0x0048 */ bool bEnableLegacyInputScales;
    /* 0x0048 */ bool bEnableMotionControls;
    /* 0x0049 */ bool bFilterInputByPlatformUser;
    /* 0x0049 */ bool bEnableInputDeviceSubsystem;
    /* 0x0049 */ bool bShouldFlushPressedKeysOnViewportFocusLost;
    /* 0x0049 */ bool bEnableDynamicComponentInputBinding;
    /* 0x0049 */ bool bAlwaysShowTouchInterface;
    /* 0x0049 */ bool bShowConsoleOnFourFingerTap;
    /* 0x0049 */ bool bEnableGestureRecognizer;
    /* 0x0049 */ bool bUseAutocorrect;
    /* 0x0050 */ TArray<FString> ExcludedAutocorrectOS;
    /* 0x0060 */ TArray<FString> ExcludedAutocorrectCultures;
    /* 0x0070 */ TArray<FString> ExcludedAutocorrectDeviceModels;
    /* 0x0080 */ EMouseCaptureMode DefaultViewportMouseCaptureMode;
    /* 0x0081 */ EMouseLockMode DefaultViewportMouseLockMode;
    /* 0x0084 */ float FOVScale;
    /* 0x0088 */ float DoubleClickTime;
    /* 0x0090 */ TArray<FInputActionKeyMapping> ActionMappings;
    /* 0x00a0 */ TArray<FInputAxisKeyMapping> AxisMappings;
    /* 0x00b0 */ TArray<FInputActionSpeechMapping> SpeechMappings;
    /* 0x00c0 */ TSoftClassPtr<UPlayerInput> DefaultPlayerInputClass;
    /* 0x00e8 */ TSoftClassPtr<UInputComponent> DefaultInputComponentClass;
    /* 0x0110 */ FSoftObjectPath DefaultTouchInterface;
    /* 0x0130 */ TArray<FKey> ConsoleKeys;

    void AddActionMapping(const FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
    void AddAxisMapping(const FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
    void ForceRebuildKeymaps();
    void GetActionMappingByName(const FName InActionName, TArray<FInputActionKeyMapping>& OutMappings) const;
    void GetActionNames(TArray<FName>& ActionNames) const;
    void GetAxisMappingByName(const FName InAxisName, TArray<FInputAxisKeyMapping>& OutMappings) const;
    void GetAxisNames(TArray<FName>& AxisNames) const;
    static UInputSettings* GetInputSettings();
    void RemoveActionMapping(const FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
    void RemoveAxisMapping(const FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps);
    void SaveKeyMappings();
};

// Size: 0x38
class UInputTouchDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputTouchDelegateBinding> InputTouchDelegateBindings;
};

// Size: 0x38
class UInputVectorAxisDelegateBinding : public UInputAxisKeyDelegateBinding {
};

// Size: 0x58
struct FInstanceCacheDataBase {
    /* 0x0008 */ TArray<uint8_t> SavedProperties;
    /* 0x0018 */ FDataCacheDuplicatedObjectData UniqueTransientPackage;
    /* 0x0028 */ TArray<FDataCacheDuplicatedObjectData> DuplicatedObjects;
    /* 0x0038 */ TArray<UObject*> ReferencedObjects;
    /* 0x0048 */ TArray<FName> ReferencedNames;
};

// Size: 0x28
class UInstancedPlacemenClientSettings : public UObject {
};

// Size: 0x2b8
class AInstancedPlacementPartitionActor : public AISMPartitionActor {
};

// Size: 0xa80
class UInstancedSkinnedMeshComponent : public USkinnedMeshComponent {
    /* 0x08e8 */ TArray<FSkinnedMeshInstanceData> InstanceData;
    /* 0x08f8 */ int32_t NumCustomDataFloats;
    /* 0x0900 */ TArray<float> InstanceCustomData;
    /* 0x0910 */ float AnimationMinScreenSize;
    /* 0x0914 */ int32_t InstanceMinDrawDistance;
    /* 0x0918 */ int32_t InstanceStartCullDistance;
    /* 0x091c */ int32_t InstanceEndCullDistance;
    /* 0x0920 */ bool bInheritPerInstanceData;
    /* 0x0928 */ TArray<FAnimBankItem> AnimBankItems;
    /* 0x0938 */ FBox PrimitiveBoundsOverride;
    /* 0x0970 */ bool bIsInstanceDataGPUOnly;
    /* 0x0974 */ int32_t NumInstancesGPUOnly;

    int32_t AddAnimBankItem(const FAnimBankItem& BankItem);
    FPrimitiveInstanceId AddInstance(const FTransform& InstanceTransform, int32_t BankIndex, bool bWorldSpace);
    TArray<FPrimitiveInstanceId> AddInstances(const TArray<FTransform>& Transforms, const TArray<int32_t>& BankIndices, bool bShouldReturnIds, bool bWorldSpace);
    void ClearInstances();
    bool GetInstanceTransform(FPrimitiveInstanceId InstanceId, FTransform& OutInstanceTransform, bool bWorldSpace) const;
    void OptimizeInstanceData(bool bShouldRetainIdMap);
    bool RemoveInstance(FPrimitiveInstanceId InstanceId);
    void RemoveInstances(const TArray<FPrimitiveInstanceId>& InstancesToRemove);
    bool SetCustomDataValue(FPrimitiveInstanceId InstanceId, int32_t CustomDataIndex, float CustomDataValue);
    void SetNumCustomDataFloats(int32_t InNumCustomDataFloats);
};

// Size: 0x138
struct FInstancedSkinnedMeshComponentInstanceData : public FSceneComponentInstanceData {
    /* 0x00b8 */ USkinnedAsset* SkinnedAsset;
    /* 0x00c0 */ TArray<FSkinnedMeshInstanceData> InstanceData;
    /* 0x00f0 */ bool bHasPerInstanceHitProxies;
    /* 0x00f8 */ FBox PrimitiveBoundsOverride;
    /* 0x0130 */ bool bIsInstanceDataGPUOnly;
    /* 0x0134 */ int32_t NumInstancesGPUOnly;
};

// Size: 0x9b0
class UInstancedStaticMeshComponent : public UStaticMeshComponent {
    /* 0x0618 */ TArray<FInstancedStaticMeshInstanceData> PerInstanceSMData;
    /* 0x0628 */ TArray<FMatrix> PerInstancePrevTransform;
    /* 0x0640 */ FTransform PreviousComponentTransform;
    /* 0x06a0 */ int32_t NumCustomDataFloats;
    /* 0x06a4 */ int32_t InstancingRandomSeed;
    /* 0x06a8 */ TArray<float> PerInstanceSMCustomData;
    /* 0x06b8 */ TArray<FInstancedStaticMeshRandomSeed> AdditionalRandomSeeds;
    /* 0x06c8 */ float InstanceLODDistanceScale;
    /* 0x06cc */ int32_t InstanceMinDrawDistance;
    /* 0x06d0 */ int32_t InstanceStartCullDistance;
    /* 0x06d4 */ int32_t InstanceEndCullDistance;
    /* 0x06d8 */ bool bUseGpuLodSelection;
    /* 0x06d8 */ bool bInheritPerInstanceData;
    /* 0x06d8 */ bool bDisableCollision;
    /* 0x06e0 */ TArray<int32_t> InstanceReorderTable;
    /* 0x0750 */ int32_t NumPendingLightmaps;
    /* 0x08e0 */ TArray<FInstancedStaticMeshMappingInfo> CachedMappings;
    /* 0x08f0 */ FBoundsCacheElement CachedBounds[3];

    int32_t AddInstance(const FTransform& InstanceTransform, bool bWorldSpace);
    int32_t AddInstanceWorldSpace(const FTransform& WorldTransform);
    TArray<int32_t> AddInstances(const TArray<FTransform>& InstanceTransforms, bool bShouldReturnIndices, bool bWorldSpace, bool bUpdateNavigation);
    bool BatchUpdateInstancesTransform(int32_t StartInstanceIndex, int32_t NumInstances, const FTransform& NewInstancesTransform, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
    bool BatchUpdateInstancesTransforms(int32_t StartInstanceIndex, const TArray<FTransform>& NewInstancesTransforms, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
    void ClearInstances();
    void GetCullDistances(int32_t& OutStartCullDistance, int32_t& OutEndCullDistance) const;
    int32_t GetInstanceCount() const;
    bool GetInstanceTransform(int32_t InstanceIndex, FTransform& OutInstanceTransform, bool bWorldSpace) const;
    TArray<int32_t> GetInstancesOverlappingBox(const FBox& Box, bool bBoxInWorldSpace) const;
    TArray<int32_t> GetInstancesOverlappingSphere(const FVector& Center, float Radius, bool bSphereInWorldSpace) const;
    float GetLODDistanceScale() const;
    bool IsValidInstance(int32_t InstanceIndex) const;
    bool RemoveInstance(int32_t InstanceIndex);
    bool RemoveInstances(const TArray<int32_t>& InstancesToRemove);
    void SetCullDistances(int32_t StartCullDistance, int32_t EndCullDistance);
    bool SetCustomDataValue(int32_t InstanceIndex, int32_t CustomDataIndex, float CustomDataValue, bool bMarkRenderStateDirty);
    void SetLODDistanceScale(float InLODDistanceScale);
    void SetNumCustomDataFloats(int32_t InNumCustomDataFloats);
    bool UpdateInstanceTransform(int32_t InstanceIndex, const FTransform& NewInstanceTransform, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
};

// Size: 0x180
struct FInstancedStaticMeshComponentInstanceData : public FSceneComponentInstanceData {
    /* 0x00b8 */ UStaticMesh* StaticMesh;
    /* 0x00c0 */ FInstancedStaticMeshLightMapInstanceData CachedStaticLighting;
    /* 0x0130 */ TArray<FInstancedStaticMeshInstanceData> PerInstanceSMData;
    /* 0x0160 */ int32_t InstancingRandomSeed;
    /* 0x0168 */ TArray<FInstancedStaticMeshRandomSeed> AdditionalRandomSeeds;
    /* 0x0178 */ bool bHasPerInstanceHitProxies;
};

// Size: 0x80
struct FInstancedStaticMeshInstanceData {
    /* 0x0000 */ FMatrix Transform;
};

// Size: 0x70
struct FInstancedStaticMeshLightMapInstanceData {
    /* 0x0000 */ FTransform Transform;
    /* 0x0060 */ TArray<FGuid> MapBuildDataIds;
};

// Size: 0x8
struct FInstancedStaticMeshMappingInfo {
};

// Size: 0x8
struct FInstancedStaticMeshRandomSeed {
    /* 0x0000 */ int32_t StartInstanceIndex;
    /* 0x0004 */ int32_t RandomSeed;
};

// Size: 0x50
class UIntSerialization : public UObject {
    /* 0x0028 */ uint16_t UnsignedInt16Variable;
    /* 0x002c */ uint32_t UnsignedInt32Variable;
    /* 0x0030 */ uint64_t UnsignedInt64Variable;
    /* 0x0038 */ int8_t SignedInt8Variable;
    /* 0x003a */ int16_t SignedInt16Variable;
    /* 0x0040 */ int64_t SignedInt64Variable;
    /* 0x0048 */ uint8_t UnsignedInt8Variable;
    /* 0x004c */ int32_t SignedInt32Variable;
};

// Size: 0x4
struct FIntegerAnimationAttribute {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x80
struct FIntegralCurve : public FIndexedCurve {
    /* 0x0068 */ TArray<FIntegralKey> Keys;
    /* 0x0078 */ int32_t DefaultValue;
    /* 0x007c */ bool bUseDefaultValueBeforeFirstKey;
};

// Size: 0x8
struct FIntegralKey {
    /* 0x0000 */ float Time;
    /* 0x0004 */ int32_t Value;
};

// Size: 0x28
class IInterface_ActorSubobject : public UInterface {
};

// Size: 0x28
class IInterface_AnimCurveMetaData : public UInterface {
};

// Size: 0x28
class IInterface_AssetUserData : public UInterface {

    bool AddAssetUserDataOfClass(UClass* InUserDataClass);
    UAssetUserData* GetAssetUserDataOfClass(UClass* InUserDataClass);
    bool HasAssetUserDataOfClass(UClass* InUserDataClass);
};

// Size: 0x28
class IInterface_AsyncCompilation : public UInterface {
};

// Size: 0x28
class IInterface_CollisionDataProvider : public UInterface {
};

// Size: 0x28
class IInterface_PostProcessVolume : public UInterface {
};

// Size: 0x28
class IInterface_PreviewMeshProvider : public UInterface {
};

// Size: 0x24
struct FInteriorSettings {
    /* 0x0000 */ bool bIsWorldSettings;
    /* 0x0004 */ float ExteriorVolume;
    /* 0x0008 */ float ExteriorTime;
    /* 0x000c */ float ExteriorLPF;
    /* 0x0010 */ float ExteriorLPFTime;
    /* 0x0014 */ float InteriorVolume;
    /* 0x0018 */ float InteriorTime;
    /* 0x001c */ float InteriorLPF;
    /* 0x0020 */ float InteriorLPFTime;
};

// Size: 0x28
struct FInterpControlPoint {
    /* 0x0000 */ FVector PositionControlPoint;
    /* 0x0018 */ bool bPositionIsRelative;
};

// Size: 0x40
class UInterpCurveEdSetup : public UObject {
    /* 0x0028 */ TArray<FCurveEdTab> Tabs;
    /* 0x0038 */ int32_t ActiveTab;
};

// Size: 0x1d8
class UInterpToMovementComponent : public UMovementComponent {
    /* 0x0120 */ float Duration;
    /* 0x0124 */ bool bPauseOnImpact;
    /* 0x0128 */ bool bSweep;
    /* 0x0129 */ ETeleportType TeleportType;
    /* 0x012a */ EInterpToBehaviourType BehaviourType;
    /* 0x012b */ bool bCheckIfStillInWorld;
    /* 0x012c */ bool bForceSubStepping;
    /* 0x0130 */ FMulticastInlineDelegate OnInterpToReverse;
    /* 0x0140 */ FMulticastInlineDelegate OnInterpToStop;
    /* 0x0150 */ FMulticastInlineDelegate OnWaitBeginDelegate;
    /* 0x0160 */ FMulticastInlineDelegate OnWaitEndDelegate;
    /* 0x0170 */ FMulticastInlineDelegate OnResetDelegate;
    /* 0x0180 */ float MaxSimulationTimeStep;
    /* 0x0184 */ float SpeedMultiplier;
    /* 0x0188 */ int32_t MaxSimulationIterations;
    /* 0x0190 */ TArray<FInterpControlPoint> ControlPoints;

    void AddControlPointPosition(FVector Pos, bool bPositionIsRelative);
    void FinaliseControlPoints();
    void OnInterpToResetDelegate__DelegateSignature(const FHitResult& ImpactResult, float Time);
    void OnInterpToReverseDelegate__DelegateSignature(const FHitResult& ImpactResult, float Time);
    void OnInterpToStopDelegate__DelegateSignature(const FHitResult& ImpactResult, float Time);
    void OnInterpToWaitBeginDelegate__DelegateSignature(const FHitResult& ImpactResult, float Time);
    void OnInterpToWaitEndDelegate__DelegateSignature(const FHitResult& ImpactResult, float Time);
    void ResetControlPoints();
    void RestartMovement(float InitialDirection);
    void StopSimulating(const FHitResult& HitResult);
};

// Size: 0x10
struct FInterpolationParameter {
    /* 0x0000 */ float InterpolationTime;
    /* 0x0004 */ float DampingRatio;
    /* 0x0008 */ float MaxSpeed;
    /* 0x000c */ uint8_t InterpolationType;
};

// Size: 0x28
struct FIrisNetDriverConfig {
    /* 0x0000 */ FName NetDriverDefinition;
    /* 0x0008 */ FName NetDriverName;
    /* 0x0010 */ FString NetDriverWildcardName;
    /* 0x0020 */ bool bCanUseIris;
};

// Size: 0xa0
struct FKAggregateGeom {
    /* 0x0000 */ TArray<FKSphereElem> SphereElems;
    /* 0x0010 */ TArray<FKBoxElem> BoxElems;
    /* 0x0020 */ TArray<FKSphylElem> SphylElems;
    /* 0x0030 */ TArray<FKConvexElem> ConvexElems;
    /* 0x0040 */ TArray<FKTaperedCapsuleElem> TaperedCapsuleElems;
    /* 0x0050 */ TArray<FKLevelSetElem> LevelSetElems;
    /* 0x0060 */ TArray<FKSkinnedLevelSetElem> SkinnedLevelSetElems;
    /* 0x0070 */ TArray<FKMLLevelSetElem> MLLevelSetElems;
    /* 0x0080 */ TArray<FKSkinnedTriangleMeshElem> SkinnedTriangleMeshElems;
};

// Size: 0x70
struct FKBoxElem : public FKShapeElem {
    /* 0x0030 */ FVector Center;
    /* 0x0048 */ FRotator Rotation;
    /* 0x0060 */ float X;
    /* 0x0064 */ float Y;
    /* 0x0068 */ float Z;
};

// Size: 0x100
struct FKConvexElem : public FKShapeElem {
    /* 0x0030 */ TArray<FVector> VertexData;
    /* 0x0040 */ TArray<int32_t> IndexData;
    /* 0x0050 */ FBox ElemBox;
    /* 0x0090 */ FTransform Transform;
};

// Size: 0xa0
struct FKLevelSetElem : public FKShapeElem {
    /* 0x0030 */ FTransform Transform;
};

// Size: 0x50
struct FKMLLevelSetElem : public FKShapeElem {
    /* 0x0040 */ UNNEModelData* NNESignedDistanceModelData;
    /* 0x0048 */ UNNEModelData* NNEIncorrectZoneModelData;
};

// Size: 0x30
struct FKShapeElem {
    /* 0x0008 */ float RestOffset;
    /* 0x000c */ FName Name;
    /* 0x0018 */ bool bContributeToMass;
    /* 0x0019 */ uint8_t CollisionEnabled;
};

// Size: 0x38
struct FKSkinnedLevelSetElem : public FKShapeElem {
};

// Size: 0x38
struct FKSkinnedTriangleMeshElem : public FKShapeElem {
};

// Size: 0x50
struct FKSphereElem : public FKShapeElem {
    /* 0x0030 */ FVector Center;
    /* 0x0048 */ float Radius;
};

// Size: 0x68
struct FKSphylElem : public FKShapeElem {
    /* 0x0030 */ FVector Center;
    /* 0x0048 */ FRotator Rotation;
    /* 0x0060 */ float Radius;
    /* 0x0064 */ float Length;
};

// Size: 0x70
struct FKTaperedCapsuleElem : public FKShapeElem {
    /* 0x0030 */ FVector Center;
    /* 0x0048 */ FRotator Rotation;
    /* 0x0060 */ float Radius0;
    /* 0x0064 */ float Radius1;
    /* 0x0068 */ float Length;
    /* 0x006c */ bool bOneSidedCollision;
};

// Size: 0x30
struct FKeyBind {
    /* 0x0000 */ FKey Key;
    /* 0x0018 */ FString Command;
    /* 0x0028 */ bool Control;
    /* 0x0028 */ bool Shift;
    /* 0x0028 */ bool Alt;
    /* 0x0028 */ bool Cmd;
    /* 0x0028 */ bool bIgnoreCtrl;
    /* 0x0028 */ bool bIgnoreShift;
    /* 0x0028 */ bool bIgnoreAlt;
    /* 0x0028 */ bool bIgnoreCmd;
    /* 0x0029 */ bool bDisabled;
};

// Size: 0x88
struct FKeyHandleLookupTable {
};

// Size: 0x60
struct FKeyHandleMap {
};

// Size: 0x2f0
class AKillZVolume : public APhysicsVolume {
};

// Size: 0x28
class UKismetArrayLibrary : public UBlueprintFunctionLibrary {

    static int32_t Array_Add(const TArray<int32_t>& TargetArray, const int32_t& NewItem);
    static int32_t Array_AddUnique(const TArray<int32_t>& TargetArray, const int32_t& NewItem);
    static void Array_Append(const TArray<int32_t>& TargetArray, const TArray<int32_t>& SourceArray);
    static void Array_Clear(const TArray<int32_t>& TargetArray);
    static bool Array_Contains(const TArray<int32_t>& TargetArray, const int32_t& ItemToFind);
    static int32_t Array_Find(const TArray<int32_t>& TargetArray, const int32_t& ItemToFind);
    static void Array_Get(const TArray<int32_t>& TargetArray, int32_t Index, int32_t& Item);
    static bool Array_Identical(const TArray<int32_t>& ArrayA, const TArray<int32_t>& ArrayB);
    static void Array_Insert(const TArray<int32_t>& TargetArray, const int32_t& NewItem, int32_t Index);
    static bool Array_IsEmpty(const TArray<int32_t>& TargetArray);
    static bool Array_IsNotEmpty(const TArray<int32_t>& TargetArray);
    static bool Array_IsValidIndex(const TArray<int32_t>& TargetArray, int32_t IndexToTest);
    static int32_t Array_LastIndex(const TArray<int32_t>& TargetArray);
    static int32_t Array_Length(const TArray<int32_t>& TargetArray);
    static void Array_Random(const TArray<int32_t>& TargetArray, int32_t& OutItem, int32_t& OutIndex);
    static void Array_RandomFromStream(const TArray<int32_t>& TargetArray, FRandomStream& RandomStream, int32_t& OutItem, int32_t& OutIndex);
    static void Array_Remove(const TArray<int32_t>& TargetArray, int32_t IndexToRemove);
    static bool Array_RemoveItem(const TArray<int32_t>& TargetArray, const int32_t& Item);
    static void Array_Resize(const TArray<int32_t>& TargetArray, int32_t Size);
    static void Array_Reverse(const TArray<int32_t>& TargetArray);
    static void Array_Set(const TArray<int32_t>& TargetArray, int32_t Index, const int32_t& Item, bool bSizeToFit);
    static void Array_Shuffle(const TArray<int32_t>& TargetArray);
    static void Array_ShuffleFromStream(const TArray<int32_t>& TargetArray, FRandomStream& RandomStream);
    static void Array_Swap(const TArray<int32_t>& TargetArray, int32_t FirstIndex, int32_t SecondIndex);
    static void FilterArray(const TArray<AActor*>& TargetArray, UClass* FilterClass, TArray<AActor*>& FilteredArray);
    static void SetArrayPropertyByName(UObject* Object, FName PropertyName, const TArray<int32_t>& Value);
    static void SortByteArray(TArray<uint8_t>& TargetArray, bool bStableSort, EArraySortOrder SortOrder);
    static void SortFloatArray(TArray<double>& TargetArray, bool bStableSort, EArraySortOrder SortOrder);
    static void SortInt64Array(TArray<int64_t>& TargetArray, bool bStableSort, EArraySortOrder SortOrder);
    static void SortIntArray(TArray<int32_t>& TargetArray, bool bStableSort, EArraySortOrder SortOrder);
    static void SortNameArray(TArray<FName>& TargetArray, bool bStableSort, bool bLexicalSort, EArraySortOrder SortOrder);
    static void SortStringArray(TArray<FString>& TargetArray, bool bStableSort, EArraySortOrder SortOrder);
};

// Size: 0x28
class UKismetGuidLibrary : public UBlueprintFunctionLibrary {

    static FString Conv_GuidToString(const FGuid& InGuid);
    static bool EqualEqual_GuidGuid(const FGuid& A, const FGuid& B);
    static void Invalidate_Guid(FGuid& InGuid);
    static bool IsValid_Guid(const FGuid& InGuid);
    static FGuid NewGuid();
    static bool NotEqual_GuidGuid(const FGuid& A, const FGuid& B);
    static void Parse_StringToGuid(FString GuidString, FGuid& OutGuid, bool& success);
};

// Size: 0x28
class UKismetInputLibrary : public UBlueprintFunctionLibrary {

    static void CalibrateTilt();
    static bool EqualEqual_InputChordInputChord(FInputChord A, FInputChord B);
    static bool EqualEqual_KeyKey(FKey A, FKey B);
    static float GetAnalogValue(const FAnalogInputEvent& Input);
    static FKey GetKey(const FKeyEvent& Input);
    static FSlateModifierKeysState GetModifierKeysState();
    static int32_t GetUserIndex(const FKeyEvent& Input);
    static FText InputChord_GetDisplayName(const FInputChord& Key);
    static bool InputEvent_IsAltDown(const FInputEvent& Input);
    static bool InputEvent_IsCommandDown(const FInputEvent& Input);
    static bool InputEvent_IsControlDown(const FInputEvent& Input);
    static bool InputEvent_IsLeftAltDown(const FInputEvent& Input);
    static bool InputEvent_IsLeftCommandDown(const FInputEvent& Input);
    static bool InputEvent_IsLeftControlDown(const FInputEvent& Input);
    static bool InputEvent_IsLeftShiftDown(const FInputEvent& Input);
    static bool InputEvent_IsRepeat(const FInputEvent& Input);
    static bool InputEvent_IsRightAltDown(const FInputEvent& Input);
    static bool InputEvent_IsRightCommandDown(const FInputEvent& Input);
    static bool InputEvent_IsRightControlDown(const FInputEvent& Input);
    static bool InputEvent_IsRightShiftDown(const FInputEvent& Input);
    static bool InputEvent_IsShiftDown(const FInputEvent& Input);
    static FText Key_GetDisplayName(const FKey& Key, bool bLongDisplayName);
    static EUINavigationAction Key_GetNavigationAction(const FKey& InKey);
    static EUINavigationAction Key_GetNavigationActionFromKey(const FKeyEvent& InKeyEvent);
    static EUINavigation Key_GetNavigationDirectionFromAnalog(const FAnalogInputEvent& InAnalogEvent);
    static EUINavigation Key_GetNavigationDirectionFromKey(const FKeyEvent& InKeyEvent);
    static bool Key_IsAnalog(const FKey& Key);
    static bool Key_IsAxis1D(const FKey& Key);
    static bool Key_IsAxis2D(const FKey& Key);
    static bool Key_IsAxis3D(const FKey& Key);
    static bool Key_IsButtonAxis(const FKey& Key);
    static bool Key_IsDigital(const FKey& Key);
    static bool Key_IsGamepadKey(const FKey& Key);
    static bool Key_IsKeyboardKey(const FKey& Key);
    static bool Key_IsModifierKey(const FKey& Key);
    static bool Key_IsMouseButton(const FKey& Key);
    static bool Key_IsValid(const FKey& Key);
    static bool ModifierKeysState_IsAltDown(const FSlateModifierKeysState& KeysState);
    static bool ModifierKeysState_IsCommandDown(const FSlateModifierKeysState& KeysState);
    static bool ModifierKeysState_IsControlDown(const FSlateModifierKeysState& KeysState);
    static bool ModifierKeysState_IsShiftDown(const FSlateModifierKeysState& KeysState);
    static FVector2D PointerEvent_GetCursorDelta(const FPointerEvent& Input);
    static FKey PointerEvent_GetEffectingButton(const FPointerEvent& Input);
    static FVector2D PointerEvent_GetGestureDelta(const FPointerEvent& Input);
    static ESlateGesture PointerEvent_GetGestureType(const FPointerEvent& Input);
    static FVector2D PointerEvent_GetLastScreenSpacePosition(const FPointerEvent& Input);
    static int32_t PointerEvent_GetPointerIndex(const FPointerEvent& Input);
    static FVector2D PointerEvent_GetScreenSpacePosition(const FPointerEvent& Input);
    static int32_t PointerEvent_GetTouchpadIndex(const FPointerEvent& Input);
    static int32_t PointerEvent_GetUserIndex(const FPointerEvent& Input);
    static float PointerEvent_GetWheelDelta(const FPointerEvent& Input);
    static bool PointerEvent_IsMouseButtonDown(const FPointerEvent& Input, FKey MouseButton);
    static bool PointerEvent_IsTouchEvent(const FPointerEvent& Input);
};

// Size: 0x28
class UKismetInternationalizationLibrary : public UBlueprintFunctionLibrary {

    static void ClearCurrentAssetGroupCulture(const FName AssetGroup, const bool SaveToConfig);
    static FString GetCultureDisplayName(FString Culture, const bool Localized);
    static FString GetCurrentAssetGroupCulture(const FName AssetGroup);
    static FString GetCurrentCulture();
    static FString GetCurrentLanguage();
    static FString GetCurrentLocale();
    static TArray<FString> GetLocalizedCultures(const bool IncludeGame, const bool IncludeEngine, const bool IncludeEditor, const bool IncludeAdditional);
    static FString GetNativeCulture(const ELocalizedTextSourceCategory TextCategory);
    static FString GetSuitableCulture(const TArray<FString>& AvailableCultures, FString CultureToMatch, FString FallbackCulture);
    static bool IsCultureRightToLeft(FString Culture);
    static bool SetCurrentAssetGroupCulture(const FName AssetGroup, FString Culture, const bool SaveToConfig);
    static bool SetCurrentCulture(FString Culture, const bool SaveToConfig);
    static bool SetCurrentLanguage(FString Culture, const bool SaveToConfig);
    static bool SetCurrentLanguageAndLocale(FString Culture, const bool SaveToConfig);
    static bool SetCurrentLocale(FString Culture, const bool SaveToConfig);
};

// Size: 0x28
class UKismetMaterialLibrary : public UBlueprintFunctionLibrary {

    static UMaterialInstanceDynamic* CreateDynamicMaterialInstance(UObject* WorldContextObject, UMaterialInterface* Parent, FName OptionalName, EMIDCreationFlags CreationFlags);
    static float GetScalarParameterValue(UObject* WorldContextObject, UMaterialParameterCollection* Collection, FName ParameterName);
    static FLinearColor GetVectorParameterValue(UObject* WorldContextObject, UMaterialParameterCollection* Collection, FName ParameterName);
    static void SetScalarParameterValue(UObject* WorldContextObject, UMaterialParameterCollection* Collection, FName ParameterName, float ParameterValue);
    static void SetVectorParameterValue(UObject* WorldContextObject, UMaterialParameterCollection* Collection, FName ParameterName, const FLinearColor& ParameterValue);
};

// Size: 0x28
class UKismetMathLibrary : public UBlueprintFunctionLibrary {

    static int32_t Abs_Int(int32_t A);
    static int64_t Abs_Int64(int64_t A);
    static uint8_t Add_ByteByte(uint8_t A, uint8_t B);
    static FDateTime Add_DateTimeDateTime(FDateTime A, FDateTime B);
    static FDateTime Add_DateTimeTimespan(FDateTime A, FTimespan B);
    static double Add_DoubleDouble(double A, double B);
    static int64_t Add_Int64Int64(int64_t A, int64_t B);
    static int32_t Add_IntInt(int32_t A, int32_t B);
    static FIntPoint Add_IntPointInt(FIntPoint A, int32_t B);
    static FIntPoint Add_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static FLinearColor Add_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static FMatrix Add_MatrixMatrix(const FMatrix& A, const FMatrix& B);
    static FQuat Add_QuatQuat(const FQuat& A, const FQuat& B);
    static FTimespan Add_TimespanTimespan(FTimespan A, FTimespan B);
    static FVector2D Add_Vector2DFloat(FVector2D A, double B);
    static FVector2D Add_Vector2DVector2D(FVector2D A, FVector2D B);
    static FVector4 Add_Vector4Vector4(const FVector4& A, const FVector4& B);
    static FVector Add_VectorFloat(FVector A, double B);
    static FVector Add_VectorInt(FVector A, int32_t B);
    static FVector Add_VectorVector(FVector A, FVector B);
    static int64_t And_Int64Int64(int64_t A, int64_t B);
    static int32_t And_IntInt(int32_t A, int32_t B);
    static double Atan2(double Y, double X);
    static void AverageOfIntArray(const TArray<int32_t>& IntArray, float& AverageValue);
    static uint8_t BMax(uint8_t A, uint8_t B);
    static uint8_t BMin(uint8_t A, uint8_t B);
    static bool BooleanAND(bool A, bool B);
    static bool BooleanNAND(bool A, bool B);
    static bool BooleanNOR(bool A, bool B);
    static bool BooleanOR(bool A, bool B);
    static bool BooleanXOR(bool A, bool B);
    static FBox Box_ExpandBy(const FBox& Box, const FVector& negative, const FVector& Positive);
    static FVector Box_GetClosestPointTo(const FBox& Box, const FVector& Point);
    static bool Box_Intersects(const FBox& A, const FBox& B);
    static bool Box_IsInside(const FBox& InnerTest, const FBox& OuterTest);
    static bool Box_IsInsideOrOn(const FBox& InnerTest, const FBox& OuterTest);
    static bool Box_IsPointInside(const FBox& Box, const FVector& Point);
    static FBox Box_Overlap(const FBox& A, const FBox& B);
    static void BreakBoxSphereBounds(const FBoxSphereBounds& InBoxSphereBounds, FVector& Origin, FVector& BoxExtent, float& SphereRadius);
    static void BreakColor(FLinearColor InColor, float& R, float& G, float& B, float& A);
    static void BreakDateTime(FDateTime InDateTime, int32_t& year, int32_t& Month, int32_t& day, int32_t& Hour, int32_t& Minute, int32_t& Second, int32_t& Millisecond);
    static void BreakFrameRate(const FFrameRate& InFrameRate, int32_t& Numerator, int32_t& Denominator);
    static void BreakQualifiedFrameTime(const FQualifiedFrameTime& InFrameTime, FFrameNumber& Frame, FFrameRate& FrameRate, float& SubFrame);
    static void BreakQuat(const FQuat& InQuat, float& X, float& Y, float& Z, float& W);
    static void BreakRandomStream(const FRandomStream& InRandomStream, int32_t& InitialSeed);
    static void BreakRotIntoAxes(const FRotator& InRot, FVector& X, FVector& Y, FVector& Z);
    static void BreakRotator(FRotator InRot, float& Roll, float& Pitch, float& Yaw);
    static void BreakTimespan(FTimespan InTimespan, int32_t& Days, int32_t& Hours, int32_t& Minutes, int32_t& Seconds, int32_t& Milliseconds);
    static void BreakTimespan2(FTimespan InTimespan, int32_t& Days, int32_t& Hours, int32_t& Minutes, int32_t& Seconds, int32_t& FractionNano);
    static void BreakTransform(const FTransform& InTransform, FVector& Location, FRotator& Rotation, FVector& Scale);
    static void BreakVector(FVector InVec, double& X, double& Y, double& Z);
    static void BreakVector2D(FVector2D InVec, double& X, double& Y);
    static void BreakVector4(const FVector4& InVec, double& X, double& Y, double& Z, double& W);
    static void BreakVector_NetQuantize(FVector_NetQuantize InVec, double& X, double& Y, double& Z);
    static void BreakVector_NetQuantize10(FVector_NetQuantize10 InVec, double& X, double& Y, double& Z);
    static void BreakVector_NetQuantize100(FVector_NetQuantize100 InVec, double& X, double& Y, double& Z);
    static void BreakVector_NetQuantizeNormal(FVector_NetQuantizeNormal InVec, double& X, double& Y, double& Z);
    static FLinearColor CInterpTo(FLinearColor Current, FLinearColor Target, float deltaTime, float InterpSpeed);
    static double ClampAngle(double AngleDegrees, double MinAngleDegrees, double MaxAngleDegrees);
    static FVector2D ClampAxes2D(FVector2D A, double MinAxisVal, double MaxAxisVal);
    static float ClampAxis(float Angle);
    static int64_t ClampInt64(int64_t Value, int64_t min, int64_t max);
    static FVector ClampVectorSize(FVector A, double min, double max);
    static bool ClassIsChildOf(UClass* TestClass, UClass* ParentClass);
    static FRotator ComposeRotators(FRotator A, FRotator B);
    static FTransform ComposeTransforms(const FTransform& A, const FTransform& B);
    static uint8_t Conv_BoolToByte(bool InBool);
    static double Conv_BoolToDouble(bool InBool);
    static int32_t Conv_BoolToInt(bool InBool);
    static double Conv_ByteToDouble(uint8_t InByte);
    static int32_t Conv_ByteToInt(uint8_t InByte);
    static int64_t Conv_ByteToInt64(uint8_t InByte);
    static FLinearColor Conv_ColorToLinearColor(FColor InColor);
    static float Conv_DoubleToFloat(double InDouble);
    static int64_t Conv_DoubleToInt64(double InDouble);
    static FLinearColor Conv_DoubleToLinearColor(double InDouble);
    static FVector Conv_DoubleToVector(double InDouble);
    static FVector2D Conv_DoubleToVector2D(double InDouble);
    static double Conv_FloatToDouble(float InFloat);
    static uint8_t Conv_Int64ToByte(int64_t inInt);
    static double Conv_Int64ToDouble(int64_t inInt);
    static int32_t Conv_Int64ToInt(int64_t inInt);
    static FVector2D Conv_IntPointToVector2D(FIntPoint InIntPoint);
    static bool Conv_IntToBool(int32_t inInt);
    static uint8_t Conv_IntToByte(int32_t inInt);
    static double Conv_IntToDouble(int32_t inInt);
    static int64_t Conv_IntToInt64(int32_t inInt);
    static FIntVector Conv_IntToIntVector(int32_t inInt);
    static FIntVector2 Conv_IntToIntVector2(int32_t inInt);
    static FVector Conv_IntToVector(int32_t inInt);
    static FVector2D Conv_IntVector2ToVector2D(const FIntVector2& InIntVector2);
    static FVector Conv_IntVectorToVector(const FIntVector& InIntVector);
    static FColor Conv_LinearColorToColor(FLinearColor InLinearColor, bool InUseSRGB);
    static FVector Conv_LinearColorToVector(FLinearColor InLinearColor);
    static FRotator Conv_MatrixToRotator(const FMatrix& InMatrix);
    static FTransform Conv_MatrixToTransform(const FMatrix& InMatrix);
    static FQuat Conv_RotatorToQuaternion(FRotator InRot);
    static FTransform Conv_RotatorToTransform(const FRotator& InRotator);
    static FVector Conv_RotatorToVector(FRotator InRot);
    static FMatrix Conv_TransformToMatrix(const FTransform& Transform);
    static FIntPoint Conv_Vector2DToIntPoint(FVector2D InVector2D);
    static FVector Conv_Vector2DToVector(FVector2D InVector2D, float Z);
    static FQuat Conv_Vector4ToQuaternion(const FVector4& InVec);
    static FRotator Conv_Vector4ToRotator(const FVector4& InVec);
    static FVector Conv_Vector4ToVector(const FVector4& InVector4);
    static FLinearColor Conv_VectorToLinearColor(FVector InVec);
    static FQuat Conv_VectorToQuaternion(FVector InVec);
    static FRotator Conv_VectorToRotator(FVector InVec);
    static FTransform Conv_VectorToTransform(FVector InLocation);
    static FVector2D Conv_VectorToVector2D(FVector InVector);
    static FIntPoint Convert1DTo2D(int32_t Index1D, int32_t XSize);
    static FIntVector Convert1DTo3D(int32_t Index1D, int32_t XSize, int32_t YSize);
    static int32_t Convert2DTo1D(const FIntPoint& Index2D, int32_t XSize);
    static int32_t Convert3DTo1D(const FIntVector& Index3D, int32_t XSize, int32_t YSize);
    static FVector CreateVectorFromYawPitch(float Yaw, float Pitch, float Length);
    static double CrossProduct2D(FVector2D A, FVector2D B);
    static FVector Cross_VectorVector(FVector A, FVector B);
    static bool DateTimeFromIsoString(FString IsoString, FDateTime& Result);
    static bool DateTimeFromString(FString DateTimeString, FDateTime& Result);
    static FDateTime DateTimeMaxValue();
    static FDateTime DateTimeMinValue();
    static int32_t DaysInMonth(int32_t year, int32_t Month);
    static int32_t DaysInYear(int32_t year);
    static double DegAcos(double A);
    static double DegAsin(double A);
    static double DegAtan(double A);
    static double DegAtan2(double Y, double X);
    static double DegCos(double A);
    static double DegSin(double A);
    static double DegTan(double A);
    static double DegreesToRadians(double A);
    static double Distance2D(FVector2D v1, FVector2D v2);
    static double DistanceSquared2D(FVector2D v1, FVector2D v2);
    static uint8_t Divide_ByteByte(uint8_t A, uint8_t B);
    static double Divide_DoubleDouble(double A, double B);
    static int64_t Divide_Int64Int64(int64_t A, int64_t B);
    static int32_t Divide_IntInt(int32_t A, int32_t B);
    static FIntPoint Divide_IntPointInt(FIntPoint A, int32_t B);
    static FIntPoint Divide_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static FLinearColor Divide_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static FTimespan Divide_TimespanFloat(FTimespan A, float Scalar);
    static FVector2D Divide_Vector2DFloat(FVector2D A, double B);
    static FVector2D Divide_Vector2DVector2D(FVector2D A, FVector2D B);
    static FVector4 Divide_Vector4Vector4(const FVector4& A, const FVector4& B);
    static FVector Divide_VectorFloat(FVector A, double B);
    static FVector Divide_VectorInt(FVector A, int32_t B);
    static FVector Divide_VectorVector(FVector A, FVector B);
    static double DotProduct2D(FVector2D A, FVector2D B);
    static double Dot_VectorVector(FVector A, FVector B);
    static FRotator DynamicWeightedMovingAverage_FRotator(FRotator CurrentSample, FRotator PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
    static FVector DynamicWeightedMovingAverage_FVector(FVector CurrentSample, FVector PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
    static float DynamicWeightedMovingAverage_Float(float CurrentSample, float PreviousSample, float MaxDistance, float MinWeight, float MaxWeight);
    static double Ease(double A, double B, double Alpha, uint8_t EasingFunc, double BlendExp, int32_t Steps);
    static bool EqualEqual_BoolBool(bool A, bool B);
    static bool EqualEqual_ByteByte(uint8_t A, uint8_t B);
    static bool EqualEqual_ClassClass(UClass* A, UClass* B);
    static bool EqualEqual_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool EqualEqual_DoubleDouble(double A, double B);
    static bool EqualEqual_Int64Int64(int64_t A, int64_t B);
    static bool EqualEqual_IntInt(int32_t A, int32_t B);
    static bool EqualEqual_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static bool EqualEqual_MatrixMatrix(const FMatrix& A, const FMatrix& B, float Tolerance);
    static bool EqualEqual_NameName(FName A, FName B);
    static bool EqualEqual_ObjectObject(UObject* A, UObject* B);
    static bool EqualEqual_QuatQuat(const FQuat& A, const FQuat& B, float Tolerance);
    static bool EqualEqual_RotatorRotator(FRotator A, FRotator B, float ErrorTolerance);
    static bool EqualEqual_TimespanTimespan(FTimespan A, FTimespan B);
    static bool EqualEqual_TransformTransform(const FTransform& A, const FTransform& B);
    static bool EqualEqual_Vector2DVector2D(FVector2D A, FVector2D B, float ErrorTolerance);
    static bool EqualEqual_Vector4Vector4(const FVector4& A, const FVector4& B, float ErrorTolerance);
    static bool EqualEqual_VectorVector(FVector A, FVector B, float ErrorTolerance);
    static bool EqualExactly_Vector2DVector2D(FVector2D A, FVector2D B);
    static bool EqualExactly_Vector4Vector4(const FVector4& A, const FVector4& B);
    static bool EqualExactly_VectorVector(FVector A, FVector B);
    static bool Equal_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static int32_t FCeil(double A);
    static int64_t FCeil64(double A);
    static double FClamp(double Value, double min, double max);
    static int32_t FFloor(double A);
    static int64_t FFloor64(double A);
    static double FInterpEaseInOut(double A, double B, double Alpha, double Exponent);
    static double FInterpTo(double Current, double Target, double deltaTime, double InterpSpeed);
    static double FInterpTo_Constant(double Current, double Target, double deltaTime, double InterpSpeed);
    static double FMax(double A, double B);
    static double FMin(double A, double B);
    static int32_t FMod(double Dividend, double Divisor, double& Remainder);
    static int64_t FMod64(double Dividend, double Divisor, double& Remainder);
    static int32_t FTrunc(double A);
    static int64_t FTrunc64(double A);
    static FIntVector FTruncVector(const FVector& InVector);
    static FIntVector2 FTruncVector2D(const FVector2D& InVector2D);
    static double FWrap(double Value, double min, double max);
    static FVector FindClosestPointOnLine(FVector Point, FVector LineOrigin, FVector LineDirection);
    static FVector FindClosestPointOnSegment(FVector Point, FVector SegmentStart, FVector SegmentEnd);
    static FRotator FindLookAtRotation(const FVector& Start, const FVector& Target);
    static void FindNearestPointsOnLineSegments(FVector Segment1Start, FVector Segment1End, FVector Segment2Start, FVector Segment2End, FVector& Segment1Point, FVector& Segment2Point);
    static FRotator FindRelativeLookAtRotation(const FTransform& StartTransform, const FVector& TargetLocation);
    static float FixedTurn(float InCurrent, float InDesired, float InDeltaRate);
    static float FloatSpringInterp(float Current, float Target, FFloatSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float deltaTime, float Mass, float TargetVelocityAmount, bool bClamp, float MinValue, float MaxValue, bool bInitializeFromTarget);
    static double Fraction(double A);
    static FTimespan FromDays(double Days);
    static FTimespan FromHours(double Hours);
    static FTimespan FromMilliseconds(double Milliseconds);
    static FTimespan FromMinutes(double Minutes);
    static FTimespan FromSeconds(double Seconds);
    static FDateTime FromUnixTimestamp(const int64_t UnixTime);
    static FVector2D GetAbs2D(FVector2D A);
    static double GetAbsMax2D(FVector2D A);
    static void GetAxes(FRotator A, FVector& X, FVector& Y, FVector& Z);
    static void GetAzimuthAndElevation(FVector InDirection, const FTransform& ReferenceFrame, float& Azimuth, float& Elevation);
    static FVector GetBoxCenter(const FBox& InBox);
    static FVector GetBoxSize(const FBox& InBox);
    static double GetBoxVolume(const FBox& InBox);
    static FDateTime GetDate(FDateTime A);
    static int32_t GetDay(FDateTime A);
    static int32_t GetDayOfYear(FDateTime A);
    static int32_t GetDays(FTimespan A);
    static FVector GetDirectionUnitVector(FVector From, FVector To);
    static FTimespan GetDuration(FTimespan A);
    static FVector GetForwardVector(FRotator InRot);
    static int32_t GetHour(FDateTime A);
    static int32_t GetHour12(FDateTime A);
    static int32_t GetHours(FTimespan A);
    static double GetMax2D(FVector2D A);
    static double GetMaxElement(FVector A);
    static int32_t GetMillisecond(FDateTime A);
    static int32_t GetMilliseconds(FTimespan A);
    static double GetMin2D(FVector2D A);
    static double GetMinElement(FVector A);
    static int32_t GetMinute(FDateTime A);
    static int32_t GetMinutes(FTimespan A);
    static int32_t GetMonth(FDateTime A);
    static double GetPI();
    static float GetPointDistanceToLine(FVector Point, FVector LineOrigin, FVector LineDirection);
    static float GetPointDistanceToSegment(FVector Point, FVector SegmentStart, FVector SegmentEnd);
    static FVector GetReflectionVector(FVector Direction, FVector SurfaceNormal);
    static FVector GetRightVector(FRotator InRot);
    static FVector2D GetRotated2D(FVector2D A, float AngleDeg);
    static float GetRuntimeFloatCurveValue(const FRuntimeFloatCurve& Curve, const float InTime, const float InDefaultValue);
    static int32_t GetSecond(FDateTime A);
    static int32_t GetSeconds(FTimespan A);
    static void GetSlopeDegreeAngles(const FVector& MyRightYAxis, const FVector& FloorNormal, const FVector& UpVector, float& OutSlopePitchDegreeAngle, float& OutSlopeRollDegreeAngle);
    static double GetTAU();
    static FTimespan GetTimeOfDay(FDateTime A);
    static double GetTotalDays(FTimespan A);
    static double GetTotalHours(FTimespan A);
    static double GetTotalMilliseconds(FTimespan A);
    static double GetTotalMinutes(FTimespan A);
    static double GetTotalSeconds(FTimespan A);
    static FVector GetUpVector(FRotator InRot);
    static FVector GetVectorArrayAverage(const TArray<FVector>& Vectors);
    static void GetYawPitchFromVector(FVector InVec, float& Yaw, float& Pitch);
    static int32_t GetYear(FDateTime A);
    static bool GreaterEqual_ByteByte(uint8_t A, uint8_t B);
    static bool GreaterEqual_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool GreaterEqual_DoubleDouble(double A, double B);
    static bool GreaterEqual_Int64Int64(int64_t A, int64_t B);
    static bool GreaterEqual_IntInt(int32_t A, int32_t B);
    static bool GreaterEqual_TimespanTimespan(FTimespan A, FTimespan B);
    static FVector GreaterGreater_VectorRotator(FVector A, FRotator B);
    static bool Greater_ByteByte(uint8_t A, uint8_t B);
    static bool Greater_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool Greater_DoubleDouble(double A, double B);
    static bool Greater_Int64Int64(int64_t A, int64_t B);
    static bool Greater_IntInt(int32_t A, int32_t B);
    static bool Greater_TimespanTimespan(FTimespan A, FTimespan B);
    static double GridSnap_Float(double Location, double GridSize);
    static FLinearColor HSVToRGB(float H, float S, float V, float A);
    static FLinearColor HSVToRGBLinear(FLinearColor HSV);
    static void HSVToRGB_Vector(FLinearColor HSV, FLinearColor& RGB);
    static double Hypotenuse(double Width, double Height);
    static bool InRange_FloatFloat(double Value, double min, double max, bool InclusiveMin, bool InclusiveMax);
    static bool InRange_Int64Int64(int64_t Value, int64_t min, int64_t max, bool InclusiveMin, bool InclusiveMax);
    static bool InRange_IntInt(int32_t Value, int32_t min, int32_t max, bool InclusiveMin, bool InclusiveMax);
    static FIntPoint IntPoint_Down();
    static FIntPoint IntPoint_Left();
    static FIntPoint IntPoint_One();
    static FIntPoint IntPoint_Right();
    static FIntPoint IntPoint_Up();
    static FIntPoint IntPoint_Zero();
    static FVector InverseTransformDirection(const FTransform& T, FVector Direction);
    static FVector InverseTransformLocation(const FTransform& T, FVector Location);
    static FRotator InverseTransformRotation(const FTransform& T, FRotator Rotation);
    static FTransform InvertTransform(const FTransform& T);
    static bool IsAfternoon(FDateTime A);
    static bool IsLeapYear(int32_t year);
    static bool IsMorning(FDateTime A);
    static bool IsNearlyZero2D(const FVector2D& A, float Tolerance);
    static bool IsPointInBox(FVector Point, FVector BoxOrigin, FVector BoxExtent);
    static bool IsPointInBoxWithTransform(FVector Point, const FTransform& BoxWorldTransform, FVector BoxExtent);
    static bool IsPointInBoxWithTransform_Box(FVector Point, const FTransform& BoxWorldTransform, FBox BoxExtent);
    static bool IsPointInBox_Box(FVector Point, FBox Box);
    static bool IsZero2D(const FVector2D& A);
    static double Lerp(double A, double B, double Alpha);
    static bool LessEqual_ByteByte(uint8_t A, uint8_t B);
    static bool LessEqual_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool LessEqual_DoubleDouble(double A, double B);
    static bool LessEqual_Int64Int64(int64_t A, int64_t B);
    static bool LessEqual_IntInt(int32_t A, int32_t B);
    static bool LessEqual_TimespanTimespan(FTimespan A, FTimespan B);
    static FVector LessLess_VectorRotator(FVector A, FRotator B);
    static bool Less_ByteByte(uint8_t A, uint8_t B);
    static bool Less_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool Less_DoubleDouble(double A, double B);
    static bool Less_Int64Int64(int64_t A, int64_t B);
    static bool Less_IntInt(int32_t A, int32_t B);
    static bool Less_TimespanTimespan(FTimespan A, FTimespan B);
    static bool LinePlaneIntersection(const FVector& LineStart, const FVector& LineEnd, const FPlane& APlane, float& T, FVector& Intersection);
    static bool LinePlaneIntersection_OriginNormal(const FVector& LineStart, const FVector& LineEnd, FVector PlaneOrigin, FVector PlaneNormal, float& T, FVector& Intersection);
    static FLinearColor LinearColorLerp(FLinearColor A, FLinearColor B, float Alpha);
    static FLinearColor LinearColorLerpUsingHSV(FLinearColor A, FLinearColor B, float Alpha);
    static FLinearColor LinearColor_Black();
    static FLinearColor LinearColor_Blue();
    static FLinearColor LinearColor_Desaturated(FLinearColor InColor, float InDesaturation);
    static float LinearColor_Distance(FLinearColor C1, FLinearColor C2);
    static float LinearColor_GetLuminance(FLinearColor InColor);
    static float LinearColor_GetMax(FLinearColor InColor);
    static float LinearColor_GetMin(FLinearColor InColor);
    static FLinearColor LinearColor_Gray();
    static FLinearColor LinearColor_Green();
    static bool LinearColor_IsNearEqual(FLinearColor A, FLinearColor B, float Tolerance);
    static FColor LinearColor_Quantize(FLinearColor InColor);
    static FColor LinearColor_QuantizeRound(FLinearColor InColor);
    static FLinearColor LinearColor_Red();
    static void LinearColor_Set(FLinearColor& InOutColor, FLinearColor InColor);
    static void LinearColor_SetFromHSV(FLinearColor& InOutColor, float H, float S, float V, float A);
    static void LinearColor_SetFromPow22(FLinearColor& InOutColor, const FColor& InColor);
    static void LinearColor_SetFromSRGB(FLinearColor& InOutColor, const FColor& InSRGB);
    static void LinearColor_SetRGBA(FLinearColor& InOutColor, float R, float G, float B, float A);
    static void LinearColor_SetRandomHue(FLinearColor& InOutColor);
    static void LinearColor_SetTemperature(FLinearColor& InOutColor, float InTemperature);
    static FLinearColor LinearColor_ToNewOpacity(FLinearColor InColor, float InOpacity);
    static FColor LinearColor_ToRGBE(FLinearColor InLinearColor);
    static FLinearColor LinearColor_Transparent();
    static FLinearColor LinearColor_White();
    static FLinearColor LinearColor_Yellow();
    static double Loge(double A);
    static FBox MakeBox(FVector min, FVector max);
    static FBox2D MakeBox2D(FVector2D min, FVector2D max);
    static FBoxSphereBounds MakeBoxSphereBounds(FVector Origin, FVector BoxExtent, float SphereRadius);
    static FBox MakeBoxWithOrigin(const FVector& Origin, const FVector& Extent);
    static FLinearColor MakeColor(float R, float G, float B, float A);
    static FDateTime MakeDateTime(int32_t year, int32_t Month, int32_t day, int32_t Hour, int32_t Minute, int32_t Second, int32_t Millisecond);
    static FFrameRate MakeFrameRate(int32_t Numerator, int32_t Denominator);
    static FPlane MakePlaneFromPointAndNormal(FVector Point, FVector Normal);
    static float MakePulsatingValue(float InCurrentTime, float InPulsesPerSecond, float InPhase);
    static FQualifiedFrameTime MakeQualifiedFrameTime(FFrameNumber Frame, FFrameRate FrameRate, float SubFrame);
    static FQuat MakeQuat(float X, float Y, float Z, float W);
    static FRandomStream MakeRandomStream(int32_t InitialSeed);
    static FRandomStream MakeRandomStreamFromLocation(const FVector& Location, float DistanceInterval, bool bIncludeZ);
    static FTransform MakeRelativeTransform(const FTransform& A, const FTransform& RelativeTo);
    static FRotator MakeRotFromX(const FVector& X);
    static FRotator MakeRotFromXY(const FVector& X, const FVector& Y);
    static FRotator MakeRotFromXZ(const FVector& X, const FVector& Z);
    static FRotator MakeRotFromY(const FVector& Y);
    static FRotator MakeRotFromYX(const FVector& Y, const FVector& X);
    static FRotator MakeRotFromYZ(const FVector& Y, const FVector& Z);
    static FRotator MakeRotFromZ(const FVector& Z);
    static FRotator MakeRotFromZX(const FVector& Z, const FVector& X);
    static FRotator MakeRotFromZY(const FVector& Z, const FVector& Y);
    static FRotator MakeRotationFromAxes(FVector Forward, FVector Right, FVector Up);
    static FRotator MakeRotator(float Roll, float Pitch, float Yaw);
    static FTimespan MakeTimespan(int32_t Days, int32_t Hours, int32_t Minutes, int32_t Seconds, int32_t Milliseconds);
    static FTimespan MakeTimespan2(int32_t Days, int32_t Hours, int32_t Minutes, int32_t Seconds, int32_t FractionNano);
    static FTransform MakeTransform(FVector Location, FRotator Rotation, FVector Scale);
    static FVector MakeVector(double X, double Y, double Z);
    static FVector2D MakeVector2D(double X, double Y);
    static FVector4 MakeVector4(double X, double Y, double Z, double W);
    static FVector_NetQuantize MakeVector_NetQuantize(double X, double Y, double Z);
    static FVector_NetQuantize10 MakeVector_NetQuantize10(double X, double Y, double Z);
    static FVector_NetQuantize100 MakeVector_NetQuantize100(double X, double Y, double Z);
    static FVector_NetQuantizeNormal MakeVector_NetQuantizeNormal(double X, double Y, double Z);
    static double MapRangeClamped(double Value, double InRangeA, double InRangeB, double OutRangeA, double OutRangeB);
    static double MapRangeUnclamped(double Value, double InRangeA, double InRangeB, double OutRangeA, double OutRangeB);
    static FMatrix Matrix_ApplyScale(const FMatrix& M, float Scale);
    static FMatrix Matrix_ConcatenateTranslation(const FMatrix& M, FVector Translation);
    static bool Matrix_ContainsNaN(const FMatrix& M);
    static FVector Matrix_GetColumn(const FMatrix& M, uint8_t Column);
    static float Matrix_GetDeterminant(const FMatrix& M);
    static bool Matrix_GetFrustumBottomPlane(const FMatrix& M, FPlane& OutPlane);
    static bool Matrix_GetFrustumFarPlane(const FMatrix& M, FPlane& OutPlane);
    static bool Matrix_GetFrustumLeftPlane(const FMatrix& M, FPlane& OutPlane);
    static bool Matrix_GetFrustumNearPlane(const FMatrix& M, FPlane& OutPlane);
    static bool Matrix_GetFrustumRightPlane(const FMatrix& M, FPlane& OutPlane);
    static bool Matrix_GetFrustumTopPlane(const FMatrix& M, FPlane& OutPlane);
    static FMatrix Matrix_GetInverse(const FMatrix& M);
    static FMatrix Matrix_GetMatrixWithoutScale(const FMatrix& M, float Tolerance);
    static float Matrix_GetMaximumAxisScale(const FMatrix& M);
    static FVector Matrix_GetOrigin(const FMatrix& InMatrix);
    static float Matrix_GetRotDeterminant(const FMatrix& M);
    static FRotator Matrix_GetRotator(const FMatrix& M);
    static FVector Matrix_GetScaleVector(const FMatrix& M, float Tolerance);
    static void Matrix_GetScaledAxes(const FMatrix& M, FVector& X, FVector& Y, FVector& Z);
    static FVector Matrix_GetScaledAxis(const FMatrix& M, uint8_t Axis);
    static FMatrix Matrix_GetTransposeAdjoint(const FMatrix& M);
    static FMatrix Matrix_GetTransposed(const FMatrix& M);
    static void Matrix_GetUnitAxes(const FMatrix& M, FVector& X, FVector& Y, FVector& Z);
    static FVector Matrix_GetUnitAxis(const FMatrix& M, uint8_t Axis);
    static FMatrix Matrix_Identity();
    static FVector Matrix_InverseTransformPosition(const FMatrix& M, FVector V);
    static FVector Matrix_InverseTransformVector(const FMatrix& M, FVector V);
    static FMatrix Matrix_Mirror(const FMatrix& M, uint8_t MirrorAxis, uint8_t FlipAxis);
    static void Matrix_RemoveScaling(FMatrix& M, float Tolerance);
    static FMatrix Matrix_RemoveTranslation(const FMatrix& M);
    static FMatrix Matrix_ScaleTranslation(const FMatrix& M, FVector Scale3D);
    static void Matrix_SetAxis(FMatrix& M, uint8_t Axis, FVector AxisVector);
    static void Matrix_SetColumn(FMatrix& M, uint8_t Column, FVector Value);
    static void Matrix_SetOrigin(FMatrix& M, FVector NewOrigin);
    static FQuat Matrix_ToQuat(const FMatrix& M);
    static FVector4 Matrix_TransformPosition(const FMatrix& M, FVector V);
    static FVector4 Matrix_TransformVector(const FMatrix& M, FVector V);
    static FVector4 Matrix_TransformVector4(const FMatrix& M, FVector4 V);
    static int64_t MaxInt64(int64_t A, int64_t B);
    static void MaxOfByteArray(const TArray<uint8_t>& ByteArray, int32_t& IndexOfMaxValue, uint8_t& MaxValue);
    static void MaxOfFloatArray(const TArray<float>& FloatArray, int32_t& IndexOfMaxValue, float& MaxValue);
    static void MaxOfIntArray(const TArray<int32_t>& IntArray, int32_t& IndexOfMaxValue, int32_t& MaxValue);
    static void MedianOfIntArray(TArray<int32_t> IntArray, float& MedianValue);
    static void MinAreaRectangle(UObject* WorldContextObject, const TArray<FVector>& InPoints, const FVector& SampleSurfaceNormal, FVector& OutRectCenter, FRotator& OutRectRotation, float& OutRectLengthX, float& OutRectLengthY, bool bDebugDraw);
    static int64_t MinInt64(int64_t A, int64_t B);
    static void MinOfByteArray(const TArray<uint8_t>& ByteArray, int32_t& IndexOfMinValue, uint8_t& MinValue);
    static void MinOfFloatArray(const TArray<float>& FloatArray, int32_t& IndexOfMinValue, float& MinValue);
    static void MinOfIntArray(const TArray<int32_t>& IntArray, int32_t& IndexOfMinValue, int32_t& MinValue);
    static FVector MirrorVectorByNormal(FVector InVect, FVector InNormal);
    static double MultiplyByPi(double Value);
    static double MultiplyMultiply_FloatFloat(double base, double exp);
    static uint8_t Multiply_ByteByte(uint8_t A, uint8_t B);
    static double Multiply_DoubleDouble(double A, double B);
    static int64_t Multiply_Int64Int64(int64_t A, int64_t B);
    static double Multiply_IntFloat(int32_t A, double B);
    static int32_t Multiply_IntInt(int32_t A, int32_t B);
    static FIntPoint Multiply_IntPointInt(FIntPoint A, int32_t B);
    static FIntPoint Multiply_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static FLinearColor Multiply_LinearColorFloat(FLinearColor A, float B);
    static FLinearColor Multiply_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static FMatrix Multiply_MatrixFloat(const FMatrix& A, double B);
    static FMatrix Multiply_MatrixMatrix(const FMatrix& A, const FMatrix& B);
    static FQuat Multiply_QuatQuat(const FQuat& A, const FQuat& B);
    static FRotator Multiply_RotatorFloat(FRotator A, float B);
    static FRotator Multiply_RotatorInt(FRotator A, int32_t B);
    static FTimespan Multiply_TimespanFloat(FTimespan A, float Scalar);
    static FVector2D Multiply_Vector2DFloat(FVector2D A, double B);
    static FVector2D Multiply_Vector2DVector2D(FVector2D A, FVector2D B);
    static FVector4 Multiply_Vector4Vector4(const FVector4& A, const FVector4& B);
    static FVector Multiply_VectorFloat(FVector A, double B);
    static FVector Multiply_VectorInt(FVector A, int32_t B);
    static FVector Multiply_VectorVector(FVector A, FVector B);
    static bool NearlyEqual_FloatFloat(double A, double B, double ErrorTolerance);
    static bool NearlyEqual_TransformTransform(const FTransform& A, const FTransform& B, float LocationTolerance, float RotationTolerance, float Scale3DTolerance);
    static FRotator NegateRotator(FRotator A);
    static FVector NegateVector(FVector A);
    static FVector2D Negated2D(const FVector2D& A);
    static FVector Normal(FVector A, float Tolerance);
    static FVector2D Normal2D(FVector2D A);
    static FVector2D NormalSafe2D(FVector2D A, float Tolerance);
    static void Normalize2D(FVector2D& A, float Tolerance);
    static float NormalizeAxis(float Angle);
    static double NormalizeToRange(double Value, double RangeMin, double RangeMax);
    static FRotator NormalizedDeltaRotator(FRotator A, FRotator B);
    static bool NotEqualExactly_Vector2DVector2D(FVector2D A, FVector2D B);
    static bool NotEqualExactly_Vector4Vector4(const FVector4& A, const FVector4& B);
    static bool NotEqualExactly_VectorVector(FVector A, FVector B);
    static bool NotEqual_BoolBool(bool A, bool B);
    static bool NotEqual_ByteByte(uint8_t A, uint8_t B);
    static bool NotEqual_ClassClass(UClass* A, UClass* B);
    static bool NotEqual_DateTimeDateTime(FDateTime A, FDateTime B);
    static bool NotEqual_DoubleDouble(double A, double B);
    static bool NotEqual_Int64Int64(int64_t A, int64_t B);
    static bool NotEqual_IntInt(int32_t A, int32_t B);
    static bool NotEqual_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static bool NotEqual_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static bool NotEqual_MatrixMatrix(const FMatrix& A, const FMatrix& B, float Tolerance);
    static bool NotEqual_NameName(FName A, FName B);
    static bool NotEqual_ObjectObject(UObject* A, UObject* B);
    static bool NotEqual_QuatQuat(const FQuat& A, const FQuat& B, float ErrorTolerance);
    static bool NotEqual_RotatorRotator(FRotator A, FRotator B, float ErrorTolerance);
    static bool NotEqual_TimespanTimespan(FTimespan A, FTimespan B);
    static bool NotEqual_Vector2DVector2D(FVector2D A, FVector2D B, float ErrorTolerance);
    static bool NotEqual_Vector4Vector4(const FVector4& A, const FVector4& B, float ErrorTolerance);
    static bool NotEqual_VectorVector(FVector A, FVector B, float ErrorTolerance);
    static int32_t Not_Int(int32_t A);
    static int64_t Not_Int64(int64_t A);
    static bool Not_PreBool(bool A);
    static FDateTime Now();
    static int64_t Or_Int64Int64(int64_t A, int64_t B);
    static int32_t Or_IntInt(int32_t A, int32_t B);
    static uint8_t Percent_ByteByte(uint8_t A, uint8_t B);
    static double Percent_FloatFloat(double A, double B);
    static int64_t Percent_Int64Int64(int64_t A, int64_t B);
    static int32_t Percent_IntInt(int32_t A, int32_t B);
    static float PerlinNoise1D(const float Value);
    static bool PointsAreCoplanar(const TArray<FVector>& points, float Tolerance);
    static FVector ProjectPointOnToPlane(FVector Point, FVector PlaneBase, FVector PlaneNormal);
    static FVector ProjectVectorOnToVector(FVector V, FVector Target);
    static FVector ProjectVectorOntoPlane(FVector V, FVector PlaneNormal);
    static float Quat_AngularDistance(const FQuat& A, const FQuat& B);
    static void Quat_EnforceShortestArcWith(FQuat& A, const FQuat& B);
    static FVector Quat_Euler(const FQuat& Q);
    static FQuat Quat_Exp(const FQuat& Q);
    static FQuat Quat_FindBetweenNormals(FVector StartNormal, FVector EndNormal);
    static FQuat Quat_FindBetweenVectors(FVector Start, FVector End);
    static float Quat_GetAngle(const FQuat& Q);
    static FVector Quat_GetAxisX(const FQuat& Q);
    static FVector Quat_GetAxisY(const FQuat& Q);
    static FVector Quat_GetAxisZ(const FQuat& Q);
    static FVector Quat_GetRotationAxis(const FQuat& Q);
    static FQuat Quat_Identity();
    static FQuat Quat_Inversed(const FQuat& Q);
    static bool Quat_IsFinite(const FQuat& Q);
    static bool Quat_IsIdentity(const FQuat& Q, float Tolerance);
    static bool Quat_IsNonFinite(const FQuat& Q);
    static bool Quat_IsNormalized(const FQuat& Q);
    static FQuat Quat_Log(const FQuat& Q);
    static FQuat Quat_MakeFromEuler(const FVector& Euler);
    static void Quat_Normalize(FQuat& Q, float Tolerance);
    static FQuat Quat_Normalized(const FQuat& Q, float Tolerance);
    static FVector Quat_RotateVector(const FQuat& Q, const FVector& V);
    static FRotator Quat_Rotator(const FQuat& Q);
    static void Quat_SetComponents(FQuat& Q, float X, float Y, float Z, float W);
    static void Quat_SetFromEuler(FQuat& Q, const FVector& Euler);
    static float Quat_Size(const FQuat& Q);
    static float Quat_SizeSquared(const FQuat& Q);
    static FQuat Quat_Slerp(const FQuat& A, const FQuat& B, double Alpha);
    static FVector Quat_UnrotateVector(const FQuat& Q, const FVector& V);
    static FVector Quat_VectorForward(const FQuat& Q);
    static FVector Quat_VectorRight(const FQuat& Q);
    static FVector Quat_VectorUp(const FQuat& Q);
    static FQuat QuaternionSpringInterp(FQuat Current, FQuat Target, FQuaternionSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float deltaTime, float Mass, float TargetVelocityAmount, bool bInitializeFromTarget);
    static FRotator REase(FRotator A, FRotator B, float Alpha, bool bShortestPath, uint8_t EasingFunc, float BlendExp, int32_t Steps);
    static FLinearColor RGBLinearToHSV(FLinearColor RGB);
    static void RGBToHSV_Vector(FLinearColor RGB, FLinearColor& HSV);
    static void RGBtoHSV(FLinearColor InColor, float& H, float& S, float& V, float& A);
    static FRotator RInterpTo(FRotator Current, FRotator Target, float deltaTime, float InterpSpeed);
    static FRotator RInterpTo_Constant(FRotator Current, FRotator Target, float deltaTime, float InterpSpeed);
    static FRotator RLerp(FRotator A, FRotator B, float Alpha, bool bShortestPath);
    static double RadiansToDegrees(double A);
    static bool RandomBool();
    static bool RandomBoolFromStream(const FRandomStream& Stream);
    static bool RandomBoolWithWeight(float Weight);
    static bool RandomBoolWithWeightFromStream(const FRandomStream& RandomStream, float Weight);
    static double RandomFloat();
    static float RandomFloatFromStream(const FRandomStream& Stream);
    static double RandomFloatInRange(double min, double max);
    static float RandomFloatInRangeFromStream(const FRandomStream& Stream, float min, float max);
    static int32_t RandomInteger(int32_t max);
    static int64_t RandomInteger64(int64_t max);
    static int64_t RandomInteger64InRange(int64_t min, int64_t max);
    static int32_t RandomIntegerFromStream(const FRandomStream& Stream, int32_t max);
    static int32_t RandomIntegerInRange(int32_t min, int32_t max);
    static int32_t RandomIntegerInRangeFromStream(const FRandomStream& Stream, int32_t min, int32_t max);
    static FVector RandomPointInBoundingBox(const FVector Center, const FVector HalfSize);
    static FVector RandomPointInBoundingBoxFromStream(const FRandomStream& Stream, const FVector Center, const FVector HalfSize);
    static FVector RandomPointInBoundingBoxFromStream_Box(const FRandomStream& Stream, const FBox Box);
    static FVector RandomPointInBoundingBox_Box(const FBox Box);
    static FRotator RandomRotator(bool bRoll);
    static FRotator RandomRotatorFromStream(const FRandomStream& Stream, bool bRoll);
    static FVector RandomUnitVector();
    static FVector RandomUnitVectorFromStream(const FRandomStream& Stream);
    static FVector RandomUnitVectorInConeInDegrees(FVector ConeDir, float ConeHalfAngleInDegrees);
    static FVector RandomUnitVectorInConeInDegreesFromStream(const FRandomStream& Stream, const FVector& ConeDir, float ConeHalfAngleInDegrees);
    static FVector RandomUnitVectorInConeInRadians(FVector ConeDir, float ConeHalfAngleInRadians);
    static FVector RandomUnitVectorInConeInRadiansFromStream(const FRandomStream& Stream, const FVector& ConeDir, float ConeHalfAngleInRadians);
    static FVector RandomUnitVectorInEllipticalConeInDegrees(FVector ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees);
    static FVector RandomUnitVectorInEllipticalConeInDegreesFromStream(const FRandomStream& Stream, const FVector& ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees);
    static FVector RandomUnitVectorInEllipticalConeInRadians(FVector ConeDir, float MaxYawInRadians, float MaxPitchInRadians);
    static FVector RandomUnitVectorInEllipticalConeInRadiansFromStream(const FRandomStream& Stream, const FVector& ConeDir, float MaxYawInRadians, float MaxPitchInRadians);
    static void ResetFloatSpringState(FFloatSpringState& SpringState);
    static void ResetQuaternionSpringState(FQuaternionSpringState& SpringState);
    static void ResetRandomStream(const FRandomStream& Stream);
    static void ResetVectorSpringState(FVectorSpringState& SpringState);
    static FVector RotateAngleAxis(FVector InVect, float AngleDeg, FVector Axis);
    static FRotator RotatorFromAxisAndAngle(FVector Axis, float Angle);
    static int64_t Round64(double A);
    static double SafeDivide(double A, double B);
    static void SeedRandomStream(FRandomStream& Stream);
    static UClass* SelectClass(UClass* A, UClass* B, bool bSelectA);
    static FLinearColor SelectColor(FLinearColor A, FLinearColor B, bool bPickA);
    static double SelectFloat(double A, double B, bool bPickA);
    static int32_t SelectInt(int32_t A, int32_t B, bool bPickA);
    static FName SelectName(const FName A, const FName B, bool bPickA);
    static UObject* SelectObject(UObject* A, UObject* B, bool bSelectA);
    static FRotator SelectRotator(FRotator A, FRotator B, bool bPickA);
    static FString SelectString(FString A, FString B, bool bPickA);
    static FText SelectText(const FText A, const FText B, bool bPickA);
    static FTransform SelectTransform(const FTransform& A, const FTransform& B, bool bPickA);
    static FVector SelectVector(FVector A, FVector B, bool bPickA);
    static void Set2D(FVector2D& A, double X, double Y);
    static void SetFloatSpringStateVelocity(FFloatSpringState& SpringState, float Velocity);
    static void SetQuaternionSpringStateAngularVelocity(FQuaternionSpringState& SpringState, FVector AngularVelocity);
    static void SetRandomStreamSeed(FRandomStream& Stream, int32_t NewSeed);
    static void SetVectorSpringStateVelocity(FVectorSpringState& SpringState, FVector Velocity);
    static double SignOfFloat(double A);
    static int32_t SignOfInteger(int32_t A);
    static int64_t SignOfInteger64(int64_t A);
    static FVector Spherical2DToUnitCartesian(FVector2D A);
    static double Square(double A);
    static uint8_t Subtract_ByteByte(uint8_t A, uint8_t B);
    static FTimespan Subtract_DateTimeDateTime(FDateTime A, FDateTime B);
    static FDateTime Subtract_DateTimeTimespan(FDateTime A, FTimespan B);
    static double Subtract_DoubleDouble(double A, double B);
    static int64_t Subtract_Int64Int64(int64_t A, int64_t B);
    static int32_t Subtract_IntInt(int32_t A, int32_t B);
    static FIntPoint Subtract_IntPointInt(FIntPoint A, int32_t B);
    static FIntPoint Subtract_IntPointIntPoint(FIntPoint A, FIntPoint B);
    static FLinearColor Subtract_LinearColorLinearColor(FLinearColor A, FLinearColor B);
    static FQuat Subtract_QuatQuat(const FQuat& A, const FQuat& B);
    static FTimespan Subtract_TimespanTimespan(FTimespan A, FTimespan B);
    static FVector2D Subtract_Vector2DFloat(FVector2D A, double B);
    static FVector2D Subtract_Vector2DVector2D(FVector2D A, FVector2D B);
    static FVector4 Subtract_Vector4Vector4(const FVector4& A, const FVector4& B);
    static FVector Subtract_VectorFloat(FVector A, double B);
    static FVector Subtract_VectorInt(FVector A, int32_t B);
    static FVector Subtract_VectorVector(FVector A, FVector B);
    static FTransform TEase(const FTransform& A, const FTransform& B, float Alpha, uint8_t EasingFunc, float BlendExp, int32_t Steps);
    static FTransform TInterpTo(const FTransform& Current, const FTransform& Target, float deltaTime, float InterpSpeed);
    static FTransform TLerp(const FTransform& A, const FTransform& B, float Alpha, uint8_t InterpMode);
    static bool TimespanFromString(FString TimespanString, FTimespan& Result);
    static FTimespan TimespanMaxValue();
    static FTimespan TimespanMinValue();
    static float TimespanRatio(FTimespan A, FTimespan B);
    static FTimespan TimespanZeroValue();
    static void ToDirectionAndLength2D(FVector2D A, FVector2D& outDir, double& OutLength);
    static FString ToHex_LinearColor(FLinearColor InColor);
    static FVector2D ToRounded2D(FVector2D A);
    static FVector2D ToSign2D(FVector2D A);
    static int64_t ToUnixTimestamp(const FDateTime& Time);
    static double ToUnixTimestampDouble(const FDateTime& Time);
    static FDateTime Today();
    static FVector TransformDirection(const FTransform& T, FVector Direction);
    static FVector TransformLocation(const FTransform& T, FVector Location);
    static FRotator TransformRotation(const FTransform& T, FRotator Rotation);
    static FVector4 TransformVector4(const FMatrix& Matrix, const FVector4& Vec4);
    static float Transform_Determinant(const FTransform& Transform);
    static FDateTime UtcNow();
    static FVector VEase(FVector A, FVector B, float Alpha, uint8_t EasingFunc, float BlendExp, int32_t Steps);
    static FVector VInterpTo(FVector Current, FVector Target, float deltaTime, float InterpSpeed);
    static FVector VInterpTo_Constant(FVector Current, FVector Target, float deltaTime, float InterpSpeed);
    static FVector VLerp(FVector A, FVector B, float Alpha);
    static double VSize(FVector A);
    static double VSize2D(FVector2D A);
    static double VSize2DSquared(FVector2D A);
    static double VSizeSquared(FVector A);
    static double VSizeXY(FVector A);
    static double VSizeXYSquared(FVector A);
    static FVector2D Vector2DInterpTo(FVector2D Current, FVector2D Target, float deltaTime, float InterpSpeed);
    static FVector2D Vector2DInterpTo_Constant(FVector2D Current, FVector2D Target, float deltaTime, float InterpSpeed);
    static FVector2D Vector2D_One();
    static FVector2D Vector2D_Unit45Deg();
    static FVector2D Vector2D_Zero();
    static void Vector4_Assign(FVector4& A, const FVector4& InVector);
    static FVector4 Vector4_CrossProduct3(const FVector4& A, const FVector4& B);
    static double Vector4_DotProduct(const FVector4& A, const FVector4& B);
    static double Vector4_DotProduct3(const FVector4& A, const FVector4& B);
    static bool Vector4_IsNAN(const FVector4& A);
    static bool Vector4_IsNearlyZero3(const FVector4& A, float Tolerance);
    static bool Vector4_IsNormal3(const FVector4& A);
    static bool Vector4_IsUnit3(const FVector4& A, float SquaredLenthTolerance);
    static bool Vector4_IsZero(const FVector4& A);
    static FVector4 Vector4_MirrorByVector3(const FVector4& Direction, const FVector4& SurfaceNormal);
    static FVector4 Vector4_Negated(const FVector4& A);
    static FVector4 Vector4_Normal3(const FVector4& A, float Tolerance);
    static FVector4 Vector4_NormalUnsafe3(const FVector4& A);
    static void Vector4_Normalize3(FVector4& A, float Tolerance);
    static void Vector4_Set(FVector4& A, double X, double Y, double Z, double W);
    static double Vector4_Size(const FVector4& A);
    static double Vector4_Size3(const FVector4& A);
    static double Vector4_SizeSquared(const FVector4& A);
    static double Vector4_SizeSquared3(const FVector4& A);
    static FVector4 Vector4_Zero();
    static FVector VectorSpringInterp(FVector Current, FVector Target, FVectorSpringState& SpringState, float Stiffness, float CriticalDampingFactor, float deltaTime, float Mass, float TargetVelocityAmount, bool bClamp, FVector MinValue, FVector MaxValue, bool bInitializeFromTarget);
    static void Vector_AddBounded(FVector& A, FVector InAddVect, float InRadius);
    static void Vector_Assign(FVector& A, const FVector& InVector);
    static FVector Vector_Backward();
    static FVector Vector_BoundedToBox(FVector InVect, FVector InBoxMin, FVector InBoxMax);
    static FVector Vector_BoundedToCube(FVector InVect, float InRadius);
    static FVector Vector_ClampSize2D(FVector A, double min, double max);
    static FVector Vector_ClampSizeMax(FVector A, double max);
    static FVector Vector_ClampSizeMax2D(FVector A, double max);
    static FVector Vector_ComponentMax(FVector A, FVector B);
    static FVector Vector_ComponentMin(FVector A, FVector B);
    static double Vector_CosineAngle2D(FVector A, FVector B);
    static double Vector_Distance(FVector v1, FVector v2);
    static double Vector_Distance2D(FVector v1, FVector v2);
    static double Vector_Distance2DSquared(FVector v1, FVector v2);
    static double Vector_DistanceSquared(FVector v1, FVector v2);
    static FVector Vector_Down();
    static FVector Vector_Forward();
    static FVector Vector_GetAbs(FVector A);
    static double Vector_GetAbsMax(FVector A);
    static double Vector_GetAbsMin(FVector A);
    static FVector Vector_GetProjection(FVector A);
    static FVector Vector_GetSignVector(FVector A);
    static double Vector_HeadingAngle(FVector A);
    static bool Vector_IsNAN(const FVector& A);
    static bool Vector_IsNearlyZero(const FVector& A, float Tolerance);
    static bool Vector_IsNormal(const FVector& A);
    static bool Vector_IsUniform(const FVector& A, float Tolerance);
    static bool Vector_IsUnit(const FVector& A, float SquaredLenthTolerance);
    static bool Vector_IsZero(const FVector& A);
    static FVector Vector_Left();
    static FVector Vector_MirrorByPlane(FVector A, const FPlane& InPlane);
    static FVector Vector_Normal2D(FVector A, float Tolerance);
    static FVector Vector_NormalUnsafe(const FVector& A);
    static void Vector_Normalize(FVector& A, float Tolerance);
    static FVector Vector_One();
    static FVector Vector_ProjectOnToNormal(FVector V, FVector InNormal);
    static FVector Vector_Reciprocal(const FVector& A);
    static FVector Vector_Right();
    static void Vector_Set(FVector& A, double X, double Y, double Z);
    static FVector Vector_SlerpNormals(FVector NormalA, FVector NormalB, double Alpha);
    static FVector Vector_SlerpVectorToDirection(FVector Vector, FVector Direction, double Alpha);
    static FVector Vector_SnappedToGrid(FVector InVect, float InGridSize);
    static FVector Vector_ToDegrees(FVector A);
    static FVector Vector_ToRadians(FVector A);
    static FVector2D Vector_UnitCartesianToSpherical(FVector A);
    static void Vector_UnwindEuler(FVector& A);
    static FVector Vector_Up();
    static FVector Vector_Zero();
    static FRotator WeightedMovingAverage_FRotator(FRotator CurrentSample, FRotator PreviousSample, float Weight);
    static FVector WeightedMovingAverage_FVector(FVector CurrentSample, FVector PreviousSample, float Weight);
    static float WeightedMovingAverage_Float(float CurrentSample, float PreviousSample, float Weight);
    static int32_t Wrap(int32_t Value, int32_t min, int32_t max);
    static int64_t Xor_Int64Int64(int64_t A, int64_t B);
    static int32_t Xor_IntInt(int32_t A, int32_t B);
    static double abs(double A);
    static double acos(double A);
    static double asin(double A);
    static double atan(double A);
    static int32_t clamp(int32_t Value, int32_t min, int32_t max);
    static double cos(double A);
    static double exp(double A);
    static double log(double A, double base);
    static int32_t max(int32_t A, int32_t B);
    static int32_t min(int32_t A, int32_t B);
    static int32_t round(double A);
    static double sin(double A);
    static double sqrt(double A);
    static double tan(double A);
};

// Size: 0x28
class UKismetNodeHelperLibrary : public UBlueprintFunctionLibrary {

    static bool BitIsMarked(int32_t Data, int32_t Index);
    static void ClearAllBits(int32_t& Data);
    static void ClearBit(int32_t& Data, int32_t Index);
    static FName GetEnumeratorName(const UEnum* Enum, uint8_t EnumeratorValue);
    static FString GetEnumeratorUserFriendlyName(const UEnum* Enum, uint8_t EnumeratorValue);
    static uint8_t GetEnumeratorValueFromIndex(const UEnum* Enum, uint8_t EnumeratorIndex);
    static int32_t GetFirstUnmarkedBit(int32_t Data, int32_t StartIdx, int32_t NumBits);
    static int32_t GetRandomUnmarkedBit(int32_t Data, int32_t StartIdx, int32_t NumBits);
    static int32_t GetUnmarkedBit(int32_t Data, int32_t StartIdx, int32_t NumBits, bool bRandom);
    static uint8_t GetValidValue(const UEnum* Enum, uint8_t EnumeratorValue);
    static bool HasMarkedBit(int32_t Data, int32_t NumBits);
    static bool HasUnmarkedBit(int32_t Data, int32_t NumBits);
    static void MarkBit(int32_t& Data, int32_t Index);
};

// Size: 0x28
class UKismetRenderingLibrary : public UBlueprintFunctionLibrary {

    static void BeginDrawCanvasToRenderTarget(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, UCanvas*& Canvas, FVector2D& Size, FDrawToRenderTargetContext& Context);
    static void BreakSkinWeightInfo(FSkelMeshSkinWeightInfo InWeight, int32_t& Bone0, uint8_t& Weight0, int32_t& Bone1, uint8_t& Weight1, int32_t& Bone2, uint8_t& Weight2, int32_t& Bone3, uint8_t& Weight3);
    static FMatrix CalculateProjectionMatrix(const FMinimalViewInfo& MinimalViewInfo);
    static void ClearRenderTarget2D(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, FLinearColor ClearColor);
    static void ConvertRenderTargetToTexture2DArrayEditorOnly(UObject* WorldContextObject, UTextureRenderTarget2DArray* RenderTarget, UTexture2DArray* Texture);
    static void ConvertRenderTargetToTexture2DEditorOnly(UObject* WorldContextObject, UTextureRenderTarget2D* RenderTarget, UTexture2D* Texture);
    static void ConvertRenderTargetToTextureCubeEditorOnly(UObject* WorldContextObject, UTextureRenderTargetCube* RenderTarget, UTextureCube* Texture);
    static void ConvertRenderTargetToTextureVolumeEditorOnly(UObject* WorldContextObject, UTextureRenderTargetVolume* RenderTarget, UVolumeTexture* Texture);
    static UTextureRenderTarget2D* CreateRenderTarget2D(UObject* WorldContextObject, int32_t Width, int32_t Height, uint8_t Format, FLinearColor ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
    static UTextureRenderTarget2DArray* CreateRenderTarget2DArray(UObject* WorldContextObject, int32_t Width, int32_t Height, int32_t Slices, uint8_t Format, FLinearColor ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
    static UTextureRenderTargetVolume* CreateRenderTargetVolume(UObject* WorldContextObject, int32_t Width, int32_t Height, int32_t Depth, uint8_t Format, FLinearColor ClearColor, bool bAutoGenerateMipMaps, bool bSupportUAVs);
    static void DrawMaterialToRenderTarget(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, UMaterialInterface* Material);
    static void EnablePathTracing(bool bEnablePathTracer);
    static void EndDrawCanvasToRenderTarget(UObject* WorldContextObject, const FDrawToRenderTargetContext& Context);
    static void ExportRenderTarget(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, FString FilePath, FString Filename);
    static void ExportTexture2D(UObject* WorldContextObject, UTexture2D* Texture, FString FilePath, FString Filename);
    static UTexture2D* ImportBufferAsTexture2D(UObject* WorldContextObject, const TArray<uint8_t>& Buffer);
    static UTexture2D* ImportFileAsTexture2D(UObject* WorldContextObject, FString Filename);
    static FSkelMeshSkinWeightInfo MakeSkinWeightInfo(int32_t Bone0, uint8_t Weight0, int32_t Bone1, uint8_t Weight1, int32_t Bone2, uint8_t Weight2, int32_t Bone3, uint8_t Weight3);
    static int32_t NumPrecompilingPSOsRemaining();
    static bool ReadRenderTarget(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, TArray<FColor>& OutSamples, bool bNormalize);
    static FColor ReadRenderTargetPixel(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, int32_t X, int32_t Y);
    static bool ReadRenderTargetRaw(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, TArray<FLinearColor>& OutLinearSamples, bool bNormalize);
    static FLinearColor ReadRenderTargetRawPixel(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, int32_t X, int32_t Y, bool bNormalize);
    static TArray<FLinearColor> ReadRenderTargetRawPixelArea(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, int32_t MinX, int32_t MinY, int32_t MaxX, int32_t MaxY, bool bNormalize);
    static FLinearColor ReadRenderTargetRawUV(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, float U, float V, bool bNormalize);
    static TArray<FLinearColor> ReadRenderTargetRawUVArea(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, FBox2D Area, bool bNormalize);
    static FColor ReadRenderTargetUV(UObject* WorldContextObject, UTextureRenderTarget2D* TextureRenderTarget, float U, float V);
    static void RefreshPathTracingOutput();
    static void ReleaseRenderTarget2D(UTextureRenderTarget2D* TextureRenderTarget);
    static UTexture2DArray* RenderTargetCreateStaticTexture2DArrayEditorOnly(UTextureRenderTarget2DArray* RenderTarget, FString Name, uint8_t CompressionSettings, uint8_t MipSettings);
    static UTexture2D* RenderTargetCreateStaticTexture2DEditorOnly(UTextureRenderTarget2D* RenderTarget, FString Name, uint8_t CompressionSettings, uint8_t MipSettings);
    static UTextureCube* RenderTargetCreateStaticTextureCubeEditorOnly(UTextureRenderTargetCube* RenderTarget, FString Name, uint8_t CompressionSettings, uint8_t MipSettings);
    static UVolumeTexture* RenderTargetCreateStaticVolumeTextureEditorOnly(UTextureRenderTargetVolume* RenderTarget, FString Name, uint8_t CompressionSettings, uint8_t MipSettings);
    static void ResizeRenderTarget2D(UTextureRenderTarget2D* TextureRenderTarget, int32_t Width, int32_t Height);
    static void SetCastInsetShadowForAllAttachments(UPrimitiveComponent* PrimitiveComponent, bool bCastInsetShadow, bool bLightAttachmentsAsGroup);
};

// Size: 0x28
class UKismetStringLibrary : public UBlueprintFunctionLibrary {

    static FString BuildString_Bool(FString AppendTo, FString Prefix, bool InBool, FString Suffix);
    static FString BuildString_Color(FString AppendTo, FString Prefix, FLinearColor InColor, FString Suffix);
    static FString BuildString_Double(FString AppendTo, FString Prefix, double InDouble, FString Suffix);
    static FString BuildString_Int(FString AppendTo, FString Prefix, int32_t inInt, FString Suffix);
    static FString BuildString_IntVector(FString AppendTo, FString Prefix, FIntVector InIntVector2, FString Suffix);
    static FString BuildString_IntVector2(FString AppendTo, FString Prefix, FIntVector2 InIntVector, FString Suffix);
    static FString BuildString_Name(FString AppendTo, FString Prefix, FName InName, FString Suffix);
    static FString BuildString_Object(FString AppendTo, FString Prefix, UObject* InObj, FString Suffix);
    static FString BuildString_Rotator(FString AppendTo, FString Prefix, FRotator InRot, FString Suffix);
    static FString BuildString_Vector(FString AppendTo, FString Prefix, FVector InVector, FString Suffix);
    static FString BuildString_Vector2d(FString AppendTo, FString Prefix, FVector2D InVector2D, FString Suffix);
    static FString Concat_StrStr(FString A, FString B);
    static bool Contains(FString SearchIn, FString Substring, bool bUseCase, bool bSearchFromEnd);
    static FString Conv_BoolToString(bool InBool);
    static FString Conv_BoxCenterAndExtentsToString(const FBox& Box);
    static FString Conv_BoxToString(const FBox& Box);
    static FString Conv_ByteToString(uint8_t InByte);
    static FString Conv_ColorToString(FLinearColor InColor);
    static FString Conv_DoubleToString(double InDouble);
    static FString Conv_InputDeviceIdToString(FInputDeviceId InDeviceId);
    static FString Conv_Int64ToString(int64_t inInt);
    static FString Conv_IntPointToString(FIntPoint InIntPoint);
    static FString Conv_IntToString(int32_t inInt);
    static FString Conv_IntVector2ToString(FIntVector2 InIntVec2);
    static FString Conv_IntVectorToString(FIntVector InIntVec);
    static FString Conv_MatrixToString(const FMatrix& InMatrix);
    static FString Conv_NameToString(FName InName);
    static FString Conv_ObjectToString(UObject* InObj);
    static FString Conv_PlatformUserIdToString(FPlatformUserId InPlatformUserId);
    static FString Conv_RotatorToString(FRotator InRot);
    static void Conv_StringToColor(FString InString, FLinearColor& OutConvertedColor, bool& OutIsValid);
    static double Conv_StringToDouble(FString InString);
    static int32_t Conv_StringToInt(FString InString);
    static int64_t Conv_StringToInt64(FString InString);
    static FName Conv_StringToName(FString InString);
    static void Conv_StringToRotator(FString InString, FRotator& OutConvertedRotator, bool& OutIsValid);
    static void Conv_StringToVector(FString InString, FVector& OutConvertedVector, bool& OutIsValid);
    static void Conv_StringToVector2D(FString InString, FVector2D& OutConvertedVector2D, bool& OutIsValid);
    static void Conv_StringToVector3f(FString InString, FVector3f& OutConvertedVector, bool& OutIsValid);
    static FString Conv_TransformToString(const FTransform& InTrans);
    static FString Conv_Vector2dToString(FVector2D InVec);
    static FString Conv_Vector3fToString(FVector3f InVec);
    static FString Conv_VectorToString(FVector InVec);
    static int32_t CullArray(FString SourceString, TArray<FString>& inArray);
    static bool EndsWith(FString SourceString, FString InSuffix, uint8_t SearchCase);
    static bool EqualEqual_StrStr(FString A, FString B);
    static bool EqualEqual_StriStri(FString A, FString B);
    static int32_t FindSubstring(FString SearchIn, FString Substring, bool bUseCase, bool bSearchFromEnd, int32_t StartPosition);
    static TArray<FString> GetCharacterArrayFromString(FString SourceString);
    static int32_t GetCharacterAsNumber(FString SourceString, int32_t Index);
    static FString GetSubstring(FString SourceString, int32_t StartIndex, int32_t Length);
    static bool IsEmpty(FString InString);
    static bool IsNumeric(FString SourceString);
    static FString JoinStringArray(const TArray<FString>& SourceArray, FString Separator);
    static FString Left(FString SourceString, int32_t Count);
    static FString LeftChop(FString SourceString, int32_t Count);
    static FString LeftPad(FString SourceString, int32_t ChCount);
    static int32_t Len(FString S);
    static bool MatchesWildcard(FString SourceString, FString Wildcard, uint8_t SearchCase);
    static FString Mid(FString SourceString, int32_t Start, int32_t Count);
    static bool NotEqual_StrStr(FString A, FString B);
    static bool NotEqual_StriStri(FString A, FString B);
    static TArray<FString> ParseIntoArray(FString SourceString, FString Delimiter, const bool CullEmptyStrings);
    static FString Replace(FString SourceString, FString From, FString To, uint8_t SearchCase);
    static int32_t ReplaceInline(FString& SourceString, FString SearchText, FString ReplacementText, uint8_t SearchCase);
    static FString Reverse(FString SourceString);
    static FString Right(FString SourceString, int32_t Count);
    static FString RightChop(FString SourceString, int32_t Count);
    static FString RightPad(FString SourceString, int32_t ChCount);
    static bool Split(FString SourceString, FString InStr, FString& LeftS, FString& RightS, uint8_t SearchCase, uint8_t SearchDir);
    static bool StartsWith(FString SourceString, FString InPrefix, uint8_t SearchCase);
    static FString TimeSecondsToString(float InSeconds);
    static FString ToLower(FString SourceString);
    static FString ToUpper(FString SourceString);
    static FString Trim(FString SourceString);
    static FString TrimTrailing(FString SourceString);
};

// Size: 0x28
class UKismetStringTableLibrary : public UBlueprintFunctionLibrary {

    static TArray<FString> GetKeysFromStringTable(const FName TableId);
    static TArray<FName> GetMetaDataIdsFromStringTableEntry(const FName TableId, FString Key);
    static TArray<FName> GetRegisteredStringTables();
    static FString GetTableEntryMetaData(const FName TableId, FString Key, const FName MetaDataId);
    static FString GetTableEntrySourceString(const FName TableId, FString Key);
    static FString GetTableNamespace(const FName TableId);
    static bool IsRegisteredTableEntry(const FName TableId, FString Key);
    static bool IsRegisteredTableId(const FName TableId);
};

// Size: 0x28
class UKismetSystemLibrary : public UBlueprintFunctionLibrary {

    static FDebugFloatHistory AddFloatHistorySample(float Value, const FDebugFloatHistory& FloatHistory);
    static int32_t BeginTransaction(FString Context, FText Description, UObject* PrimaryObject);
    static bool BoxOverlapActors(const UObject* WorldContextObject, const FVector BoxPos, FVector BoxExtent, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool BoxOverlapActorsWithOrientation(const UObject* WorldContextObject, const FVector BoxPos, FVector BoxExtent, FRotator Orientation, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool BoxOverlapComponents(const UObject* WorldContextObject, const FVector BoxPos, FVector Extent, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static bool BoxOverlapComponentsWithOrientation(const UObject* WorldContextObject, const FVector BoxPos, FVector Extent, FRotator Orientation, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static bool BoxTraceMulti(const UObject* WorldContextObject, const FVector Start, const FVector End, FVector HalfSize, const FRotator Orientation, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool BoxTraceMultiByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, FVector HalfSize, const FRotator Orientation, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool BoxTraceMultiForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, const FVector HalfSize, const FRotator Orientation, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool BoxTraceSingle(const UObject* WorldContextObject, const FVector Start, const FVector End, const FVector HalfSize, const FRotator Orientation, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool BoxTraceSingleByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, const FVector HalfSize, const FRotator Orientation, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool BoxTraceSingleForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, const FVector HalfSize, const FRotator Orientation, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static void BreakARFilter(FARFilter InARFilter, TArray<FName>& PackageNames, TArray<FName>& PackagePaths, TArray<FSoftObjectPath>& SoftObjectPaths, TArray<FTopLevelAssetPath>& ClassPaths, TSet<FTopLevelAssetPath>& RecursiveClassPathsExclusionSet, TArray<FName>& ClassNames, TSet<FName>& RecursiveClassesExclusionSet, bool& bRecursivePaths, bool& bRecursiveClasses, bool& bIncludeOnlyOnDiskAssets);
    static void BreakSoftClassPath(FSoftClassPath InSoftClassPath, FString& PathString);
    static void BreakSoftObjectPath(FSoftObjectPath InSoftObjectPath, FString& PathString);
    static void BreakTopLevelAssetPath(const FTopLevelAssetPath& TopLevelAssetPath, FString& PathString);
    static bool CanLaunchURL(FString URL);
    static void CancelTransaction(const int32_t Index);
    static bool CapsuleOverlapActors(const UObject* WorldContextObject, const FVector CapsulePos, float Radius, float HalfHeight, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool CapsuleOverlapActorsWithOrientation(const UObject* WorldContextObject, const FVector CapsulePos, float Radius, float HalfHeight, FRotator Orientation, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool CapsuleOverlapComponents(const UObject* WorldContextObject, const FVector CapsulePos, float Radius, float HalfHeight, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static bool CapsuleOverlapComponentsWithOrientation(const UObject* WorldContextObject, const FVector CapsulePos, float Radius, float HalfHeight, FRotator Orientation, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static bool CapsuleTraceMulti(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool CapsuleTraceMultiByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool CapsuleTraceMultiForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool CapsuleTraceSingle(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool CapsuleTraceSingleByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool CapsuleTraceSingleForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, float HalfHeight, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static void CollectGarbage();
    static bool ComponentOverlapActors(UPrimitiveComponent* Component, const FTransform& ComponentTransform, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool ComponentOverlapComponents(UPrimitiveComponent* Component, const FTransform& ComponentTransform, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static void ControlScreensaver(bool bAllowScreenSaver);
    static TSoftClassPtr<UObject> Conv_ClassToSoftClassReference(const UClass*& Class);
    static FSoftComponentReference Conv_ComponentReferenceToSoftComponentReference(const FComponentReference& ComponentReference);
    static UObject* Conv_InterfaceToObject(const TScriptInterface<UInterface>& Interface);
    static UClass* Conv_ObjectToClass(UObject* Object, UClass* Class);
    static TSoftObjectPtr<UObject> Conv_ObjectToSoftObjectReference(UObject* Object);
    static FString Conv_PrimaryAssetIdToString(FPrimaryAssetId PrimaryAssetId);
    static FString Conv_PrimaryAssetTypeToString(FPrimaryAssetType PrimaryAssetType);
    static TSoftClassPtr<UObject> Conv_SoftClassPathToSoftClassRef(const FSoftClassPath& SoftClassPath);
    static UClass* Conv_SoftClassReferenceToClass(const TSoftClassPtr<UObject>& SoftClass);
    static FString Conv_SoftClassReferenceToString(const TSoftClassPtr<UObject>& SoftClassReference);
    static TSoftObjectPtr<UObject> Conv_SoftObjPathToSoftObjRef(const FSoftObjectPath& SoftObjectPath);
    static FSoftClassPath Conv_SoftObjRefToSoftClassPath(TSoftClassPtr<UObject> SoftClassReference);
    static FSoftObjectPath Conv_SoftObjRefToSoftObjPath(TSoftObjectPtr<UObject> SoftObjectReference);
    static UObject* Conv_SoftObjectReferenceToObject(const TSoftObjectPtr<UObject>& SoftObject);
    static FString Conv_SoftObjectReferenceToString(const TSoftObjectPtr<UObject>& SoftObjectReference);
    static FString ConvertToAbsolutePath(FString Filename);
    static FString ConvertToRelativePath(FString Filename);
    static void CreateCopyForUndoBuffer(UObject* ObjectToModify);
    static void Delay(const UObject* WorldContextObject, float Duration, FLatentActionInfo LatentInfo);
    static void DelayUntilNextTick(const UObject* WorldContextObject, FLatentActionInfo LatentInfo);
    static bool DoesClassImplementInterface(const UClass* TestClass, UClass* Interface);
    static bool DoesImplementInterface(const UObject* TestObject, UClass* Interface);
    static void DrawDebugArrow(const UObject* WorldContextObject, const FVector LineStart, const FVector LineEnd, float ArrowSize, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugBox(const UObject* WorldContextObject, const FVector Center, FVector Extent, FLinearColor LineColor, const FRotator Rotation, float Duration, float Thickness);
    static void DrawDebugCamera(const ACameraActor* CameraActor, FLinearColor CameraColor, float Duration);
    static void DrawDebugCapsule(const UObject* WorldContextObject, const FVector Center, float HalfHeight, float Radius, const FRotator Rotation, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugCircle(const UObject* WorldContextObject, FVector Center, float Radius, int32_t NumSegments, FLinearColor LineColor, float Duration, float Thickness, FVector YAxis, FVector ZAxis, bool bDrawAxis);
    static void DrawDebugCone(const UObject* WorldContextObject, const FVector Origin, const FVector Direction, float Length, float AngleWidth, float AngleHeight, int32_t NumSides, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugConeInDegrees(const UObject* WorldContextObject, const FVector Origin, const FVector Direction, float Length, float AngleWidth, float AngleHeight, int32_t NumSides, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugCoordinateSystem(const UObject* WorldContextObject, const FVector AxisLoc, const FRotator AxisRot, float Scale, float Duration, float Thickness);
    static void DrawDebugCylinder(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, int32_t Segments, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugFloatHistoryLocation(const UObject* WorldContextObject, const FDebugFloatHistory& FloatHistory, FVector DrawLocation, FVector2D DrawSize, FLinearColor DrawColor, float Duration);
    static void DrawDebugFloatHistoryTransform(const UObject* WorldContextObject, const FDebugFloatHistory& FloatHistory, const FTransform& DrawTransform, FVector2D DrawSize, FLinearColor DrawColor, float Duration);
    static void DrawDebugFrustum(const UObject* WorldContextObject, const FTransform& FrustumTransform, FLinearColor FrustumColor, float Duration, float Thickness);
    static void DrawDebugLine(const UObject* WorldContextObject, const FVector LineStart, const FVector LineEnd, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugPlane(const UObject* WorldContextObject, const FPlane& PlaneCoordinates, const FVector Location, float Size, FLinearColor PlaneColor, float Duration);
    static void DrawDebugPoint(const UObject* WorldContextObject, const FVector position, float Size, FLinearColor PointColor, float Duration);
    static void DrawDebugSphere(const UObject* WorldContextObject, const FVector Center, float Radius, int32_t Segments, FLinearColor LineColor, float Duration, float Thickness);
    static void DrawDebugString(const UObject* WorldContextObject, const FVector TextLocation, FString Text, AActor* TestBaseActor, FLinearColor TextColor, float Duration);
    static int32_t EndTransaction();
    static bool EqualEqual_PrimaryAssetId(FPrimaryAssetId A, FPrimaryAssetId B);
    static bool EqualEqual_PrimaryAssetType(FPrimaryAssetType A, FPrimaryAssetType B);
    static bool EqualEqual_SoftClassReference(const TSoftClassPtr<UObject>& A, const TSoftClassPtr<UObject>& B);
    static bool EqualEqual_SoftObjectReference(const TSoftObjectPtr<UObject>& A, const TSoftObjectPtr<UObject>& B);
    static void ExecuteConsoleCommand(const UObject* WorldContextObject, FString Command, APlayerController* SpecificPlayer);
    static void FlushDebugStrings(const UObject* WorldContextObject);
    static void FlushPersistentDebugLines(const UObject* WorldContextObject);
    static void ForceCloseAdBanner();
    static void GetActorBounds(const AActor* Actor, FVector& Origin, FVector& BoxExtent);
    static void GetActorListFromComponentList(const TArray<UPrimitiveComponent*>& ComponentList, UClass* ActorClassFilter, TArray<AActor*>& OutActorList);
    static int32_t GetAdIDCount();
    static FString GetBuildConfiguration();
    static FString GetBuildVersion();
    static FString GetClassDisplayName(const UClass* Class);
    static UClass* GetClassFromPrimaryAssetId(FPrimaryAssetId PrimaryAssetId);
    static FTopLevelAssetPath GetClassTopLevelAssetPath(const UClass* Class);
    static FString GetCommandLine();
    static void GetComponentBounds(const USceneComponent* Component, FVector& Origin, FVector& BoxExtent, float& SphereRadius);
    static bool GetConsoleVariableBoolValue(FString VariableName);
    static float GetConsoleVariableFloatValue(FString VariableName);
    static int32_t GetConsoleVariableIntValue(FString VariableName);
    static FString GetConsoleVariableStringValue(FString VariableName);
    static bool GetConvenientWindowedResolutions(TArray<FIntPoint>& Resolutions);
    static bool GetCurrentBundleState(FPrimaryAssetId PrimaryAssetId, bool bForceCurrentState, TArray<FName>& OutBundles);
    static FString GetDefaultLanguage();
    static FString GetDefaultLocale();
    static FString GetDeviceId();
    static FString GetDisplayName(const UObject* Object);
    static FString GetEngineVersion();
    static FTopLevelAssetPath GetEnumTopLevelAssetPath(const UEnum* Enum);
    static int64_t GetFrameCount();
    static FString GetGameBundleId();
    static FString GetGameName();
    static double GetGameTimeInSeconds(const UObject* WorldContextObject);
    static UTexture2D* GetGamepadButtonGlyph(FString ButtonKey, int32_t ControllerIndex);
    static FString GetGamepadControllerName(int32_t ControllerId);
    static FString GetLocalCurrencyCode();
    static FString GetLocalCurrencySymbol();
    static int32_t GetMinYResolutionFor3DView();
    static int32_t GetMinYResolutionForUI();
    static UObject* GetObjectFromPrimaryAssetId(FPrimaryAssetId PrimaryAssetId);
    static FString GetObjectName(const UObject* Object);
    static UObject* GetOuterObject(const UObject* Object);
    static FString GetPathName(const UObject* Object);
    static FString GetPlatformUserDir();
    static FString GetPlatformUserName();
    static TArray<FString> GetPreferredLanguages();
    static FPrimaryAssetId GetPrimaryAssetIdFromClass(UClass* Class);
    static FPrimaryAssetId GetPrimaryAssetIdFromObject(UObject* Object);
    static FPrimaryAssetId GetPrimaryAssetIdFromSoftClassReference(TSoftClassPtr<UObject> SoftClassReference);
    static FPrimaryAssetId GetPrimaryAssetIdFromSoftObjectReference(TSoftObjectPtr<UObject> SoftObjectReference);
    static void GetPrimaryAssetIdList(FPrimaryAssetType PrimaryAssetType, TArray<FPrimaryAssetId>& OutPrimaryAssetIdList);
    static void GetPrimaryAssetsWithBundleState(const TArray<FName>& RequiredBundles, const TArray<FName>& ExcludedBundles, const TArray<FPrimaryAssetType>& ValidTypes, bool bForceCurrentState, TArray<FPrimaryAssetId>& OutPrimaryAssetIdList);
    static FString GetProjectContentDirectory();
    static FString GetProjectDirectory();
    static FString GetProjectSavedDirectory();
    static int32_t GetRenderingDetailMode();
    static int32_t GetRenderingMaterialQualityLevel();
    static FSoftClassPath GetSoftClassPath(const UClass* Class);
    static TSoftClassPtr<UObject> GetSoftClassReferenceFromPrimaryAssetId(FPrimaryAssetId PrimaryAssetId);
    static FTopLevelAssetPath GetSoftClassTopLevelAssetPath(TSoftClassPtr<UObject> SoftClassReference);
    static FSoftObjectPath GetSoftObjectPath(const UObject* Object);
    static TSoftObjectPtr<UObject> GetSoftObjectReferenceFromPrimaryAssetId(FPrimaryAssetId PrimaryAssetId);
    static FTopLevelAssetPath GetStructTopLevelAssetPath(const UScriptStruct* Struct);
    static bool GetSupportedFullscreenResolutions(TArray<FIntPoint>& Resolutions);
    static FString GetSystemPath(const UObject* Object);
    static FString GetUniqueDeviceId();
    static bool GetVolumeButtonsHandledBySystem();
    static bool HasMultipleLocalPlayers(const UObject* WorldContextObject);
    static void HideAdBanner();
    static bool IsControllerAssignedToGamepad(int32_t ControllerId);
    static bool IsDedicatedServer(const UObject* WorldContextObject);
    static bool IsInterstitialAdAvailable();
    static bool IsInterstitialAdRequested();
    static bool IsLoggedIn(const APlayerController* SpecificPlayer);
    static bool IsObjectOfSoftClass(const UObject* Object, TSoftClassPtr<UObject> SoftClass);
    static bool IsPackagedForDistribution();
    static bool IsScreensaverEnabled();
    static bool IsServer(const UObject* WorldContextObject);
    static bool IsSplitScreen(const UObject* WorldContextObject);
    static bool IsStandalone(const UObject* WorldContextObject);
    static bool IsUnattended();
    static bool IsValid(const UObject* Object);
    static bool IsValidClass(UClass* Class);
    static bool IsValidInterface(const TScriptInterface<UInterface>& Interface);
    static bool IsValidPrimaryAssetId(FPrimaryAssetId PrimaryAssetId);
    static bool IsValidPrimaryAssetType(FPrimaryAssetType PrimaryAssetType);
    static bool IsValidSoftClassReference(const TSoftClassPtr<UObject>& SoftClassReference);
    static bool IsValidSoftObjectReference(const TSoftObjectPtr<UObject>& SoftObjectReference);
    static void K2_ClearAndInvalidateTimerHandle(const UObject* WorldContextObject, FTimerHandle& Handle);
    static void K2_ClearTimer(UObject* Object, FString FunctionName);
    static void K2_ClearTimerDelegate(FDelegate Delegate);
    static void K2_ClearTimerHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static float K2_GetTimerElapsedTime(UObject* Object, FString FunctionName);
    static float K2_GetTimerElapsedTimeDelegate(FDelegate Delegate);
    static float K2_GetTimerElapsedTimeHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static float K2_GetTimerRemainingTime(UObject* Object, FString FunctionName);
    static float K2_GetTimerRemainingTimeDelegate(FDelegate Delegate);
    static float K2_GetTimerRemainingTimeHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static FTimerHandle K2_InvalidateTimerHandle(FTimerHandle& Handle);
    static bool K2_IsTimerActive(UObject* Object, FString FunctionName);
    static bool K2_IsTimerActiveDelegate(FDelegate Delegate);
    static bool K2_IsTimerActiveHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static bool K2_IsTimerPaused(UObject* Object, FString FunctionName);
    static bool K2_IsTimerPausedDelegate(FDelegate Delegate);
    static bool K2_IsTimerPausedHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static bool K2_IsValidTimerHandle(FTimerHandle Handle);
    static void K2_PauseTimer(UObject* Object, FString FunctionName);
    static void K2_PauseTimerDelegate(FDelegate Delegate);
    static void K2_PauseTimerHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static FTimerHandle K2_SetTimer(UObject* Object, FString FunctionName, float Time, bool bLooping, bool bMaxOncePerFrame, float InitialStartDelay, float InitialStartDelayVariance);
    static FTimerHandle K2_SetTimerDelegate(FDelegate Delegate, float Time, bool bLooping, bool bMaxOncePerFrame, float InitialStartDelay, float InitialStartDelayVariance);
    static FTimerHandle K2_SetTimerForNextTick(UObject* Object, FString FunctionName);
    static FTimerHandle K2_SetTimerForNextTickDelegate(FDelegate Delegate);
    static bool K2_TimerExists(UObject* Object, FString FunctionName);
    static bool K2_TimerExistsDelegate(FDelegate Delegate);
    static bool K2_TimerExistsHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static void K2_UnPauseTimer(UObject* Object, FString FunctionName);
    static void K2_UnPauseTimerDelegate(FDelegate Delegate);
    static void K2_UnPauseTimerHandle(const UObject* WorldContextObject, FTimerHandle Handle);
    static void LaunchExternalUrl(const TArray<FString>& InDomainStrings, FString URL);
    static void LaunchURL(FString URL);
    static bool LineTraceMulti(const UObject* WorldContextObject, const FVector Start, const FVector End, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool LineTraceMultiByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool LineTraceMultiForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool LineTraceSingle(const UObject* WorldContextObject, const FVector Start, const FVector End, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool LineTraceSingleByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool LineTraceSingleForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static void LoadAsset(const UObject* WorldContextObject, TSoftObjectPtr<UObject> Asset, FDelegate OnLoaded, FLatentActionInfo LatentInfo);
    static void LoadAssetClass(const UObject* WorldContextObject, TSoftClassPtr<UObject> AssetClass, FDelegate OnLoaded, FLatentActionInfo LatentInfo);
    static UObject* LoadAsset_Blocking(TSoftObjectPtr<UObject> Asset);
    static UClass* LoadClassAsset_Blocking(TSoftClassPtr<UObject> AssetClass);
    static void LoadInterstitialAd(int32_t AdIdIndex);
    static void LogString(FString InString, bool bPrintToLog);
    static FARFilter MakeARFilter(const TArray<FName>& PackageNames, const TArray<FName>& PackagePaths, const TArray<FSoftObjectPath>& SoftObjectPaths, const TArray<FTopLevelAssetPath>& ClassPaths, const TSet<FTopLevelAssetPath>& RecursiveClassPathsExclusionSet, const TArray<FName>& ClassNames, const TSet<FName>& RecursiveClassesExclusionSet, const bool bRecursivePaths, const bool bRecursiveClasses, const bool bIncludeOnlyOnDiskAssets);
    static bool MakeLiteralBool(bool Value);
    static uint8_t MakeLiteralByte(uint8_t Value);
    static double MakeLiteralDouble(double Value);
    static int32_t MakeLiteralInt(int32_t Value);
    static int64_t MakeLiteralInt64(int64_t Value);
    static FName MakeLiteralName(FName Value);
    static FString MakeLiteralString(FString Value);
    static FText MakeLiteralText(FText Value);
    static FSoftClassPath MakeSoftClassPath(FString PathString);
    static FSoftObjectPath MakeSoftObjectPath(FString PathString);
    static FTopLevelAssetPath MakeTopLevelAssetPath(FString PackageName, FString AssetName);
    static void MoveComponentTo(USceneComponent* Component, FVector TargetRelativeLocation, FRotator TargetRelativeRotation, bool bEaseOut, bool bEaseIn, float OverTime, bool bForceShortestRotationPath, uint8_t MoveAction, FLatentActionInfo LatentInfo);
    static FString NormalizeFilename(FString InFilename);
    static bool NotEqual_PrimaryAssetId(FPrimaryAssetId A, FPrimaryAssetId B);
    static bool NotEqual_PrimaryAssetType(FPrimaryAssetType A, FPrimaryAssetType B);
    static bool NotEqual_SoftClassReference(const TSoftClassPtr<UObject>& A, const TSoftClassPtr<UObject>& B);
    static bool NotEqual_SoftObjectReference(const TSoftObjectPtr<UObject>& A, const TSoftObjectPtr<UObject>& B);
    void OnAssetClassLoaded__DelegateSignature(UClass* Loaded);
    void OnAssetLoaded__DelegateSignature(UObject* Loaded);
    static void ParseCommandLine(FString InCmdLine, TArray<FString>& OutTokens, TArray<FString>& OutSwitches, TMap<FString, FString>& OutParams);
    static bool ParseParam(FString InString, FString InParam);
    static bool ParseParamValue(FString InString, FString InParam, FString& OutValue);
    static void PrintString(const UObject* WorldContextObject, FString InString, bool bPrintToScreen, bool bPrintToLog, FLinearColor TextColor, float Duration, const FName Key);
    static void PrintText(const UObject* WorldContextObject, const FText InText, bool bPrintToScreen, bool bPrintToLog, FLinearColor TextColor, float Duration, const FName Key);
    static void PrintWarning(FString InString);
    static void QuitGame(const UObject* WorldContextObject, APlayerController* SpecificPlayer, uint8_t QuitPreference, bool bIgnorePlatformRestrictions);
    static void RaiseScriptError(FString ErrorMessage);
    static void RegisterForRemoteNotifications();
    static void ResetGamepadAssignmentToController(int32_t ControllerId);
    static void ResetGamepadAssignments();
    static void RetriggerableDelay(const UObject* WorldContextObject, float Duration, FLatentActionInfo LatentInfo);
    static void SetBoolPropertyByName(UObject* Object, FName PropertyName, bool Value);
    static void SetBytePropertyByName(UObject* Object, FName PropertyName, uint8_t Value);
    static void SetClassPropertyByName(UObject* Object, FName PropertyName, UClass* Value);
    static void SetCollisionProfileNameProperty(UObject* Object, FName PropertyName, const FCollisionProfileName& Value);
    static void SetColorPropertyByName(UObject* Object, FName PropertyName, const FColor& Value);
    static void SetDoublePropertyByName(UObject* Object, FName PropertyName, double Value);
    static void SetFieldPathPropertyByName(UObject* Object, FName PropertyName, const FFieldPath& Value);
    static void SetGamepadsBlockDeviceFeedback(bool bBlock);
    static void SetInt64PropertyByName(UObject* Object, FName PropertyName, int64_t Value);
    static void SetIntPropertyByName(UObject* Object, FName PropertyName, int32_t Value);
    static void SetInterfacePropertyByName(UObject* Object, FName PropertyName, const TScriptInterface<UInterface>& Value);
    static void SetLinearColorPropertyByName(UObject* Object, FName PropertyName, const FLinearColor& Value);
    static void SetNamePropertyByName(UObject* Object, FName PropertyName, const FName& Value);
    static void SetObjectPropertyByName(UObject* Object, FName PropertyName, UObject* Value);
    static void SetRotatorPropertyByName(UObject* Object, FName PropertyName, const FRotator& Value);
    static void SetSoftClassPropertyByName(UObject* Object, FName PropertyName, const TSoftClassPtr<UObject>& Value);
    static void SetSoftObjectPropertyByName(UObject* Object, FName PropertyName, const TSoftObjectPtr<UObject>& Value);
    static void SetStringPropertyByName(UObject* Object, FName PropertyName, FString Value);
    static void SetStructurePropertyByName(UObject* Object, FName PropertyName, const FGenericStruct& Value);
    static void SetSuppressViewportTransitionMessage(const UObject* WorldContextObject, bool bState);
    static void SetTextPropertyByName(UObject* Object, FName PropertyName, const FText& Value);
    static void SetTransformPropertyByName(UObject* Object, FName PropertyName, const FTransform& Value);
    static void SetUserActivity(const FUserActivity& UserActivity);
    static void SetVector3fPropertyByName(UObject* Object, FName PropertyName, const FVector3f& Value);
    static void SetVectorPropertyByName(UObject* Object, FName PropertyName, const FVector& Value);
    static void SetVolumeButtonsHandledBySystem(bool bEnabled);
    static void SetWindowTitle(const FText& Title);
    static void ShowAdBanner(int32_t AdIdIndex, bool bShowOnBottomOfScreen);
    static void ShowInterstitialAd();
    static void ShowPlatformSpecificAchievementsScreen(const APlayerController* SpecificPlayer);
    static void ShowPlatformSpecificLeaderboardScreen(FString CategoryName);
    static void SnapshotObject(UObject* Object);
    static bool SphereOverlapActors(const UObject* WorldContextObject, const FVector SpherePos, float SphereRadius, const TArray<uint8_t>& ObjectTypes, UClass* ActorClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<AActor*>& OutActors);
    static bool SphereOverlapComponents(const UObject* WorldContextObject, const FVector SpherePos, float SphereRadius, const TArray<uint8_t>& ObjectTypes, UClass* ComponentClassFilter, const TArray<AActor*>& ActorsToIgnore, TArray<UPrimitiveComponent*>& OutComponents);
    static bool SphereTraceMulti(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool SphereTraceMultiByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool SphereTraceMultiForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, TArray<FHitResult>& OutHits, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool SphereTraceSingle(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, uint8_t TraceChannel, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool SphereTraceSingleByProfile(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, FName ProfileName, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static bool SphereTraceSingleForObjects(const UObject* WorldContextObject, const FVector Start, const FVector End, float Radius, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, const TArray<AActor*>& ActorsToIgnore, uint8_t DrawDebugType, FHitResult& OutHit, bool bIgnoreSelf, FLinearColor TraceColor, FLinearColor TraceHitColor, float DrawTime);
    static void StackTrace();
    static void TransactObject(UObject* Object);
    static void UnloadPrimaryAsset(FPrimaryAssetId PrimaryAssetId);
    static void UnloadPrimaryAssetList(const TArray<FPrimaryAssetId>& PrimaryAssetIdList);
    static void UnregisterForRemoteNotifications();
};

// Size: 0x28
class UKismetTextLibrary : public UBlueprintFunctionLibrary {

    static FText AsCurrencyBase(int32_t BaseValue, FString CurrencyCode);
    static FText AsCurrency_Float(float Value, uint8_t RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits, int32_t MinimumFractionalDigits, int32_t MaximumFractionalDigits, FString CurrencyCode);
    static FText AsCurrency_Integer(int32_t Value, uint8_t RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits, int32_t MinimumFractionalDigits, int32_t MaximumFractionalDigits, FString CurrencyCode);
    static FText AsDateTime_DateTime(const FDateTime& In, uint8_t InDateStyle, uint8_t InTimeStyle);
    static FText AsDate_DateTime(const FDateTime& InDateTime, uint8_t InDateStyle);
    static FText AsMemory(int64_t NumBytes, uint8_t UnitStandard, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits, int32_t MinimumFractionalDigits, int32_t MaximumFractionalDigits);
    static FText AsPercent_Float(float Value, uint8_t RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits, int32_t MinimumFractionalDigits, int32_t MaximumFractionalDigits);
    static FText AsTimeZoneDateTime_DateTime(const FDateTime& InDateTime, FString InTimeZone, uint8_t InDateStyle, uint8_t InTimeStyle);
    static FText AsTimeZoneDate_DateTime(const FDateTime& InDateTime, FString InTimeZone, uint8_t InDateStyle);
    static FText AsTimeZoneTime_DateTime(const FDateTime& InDateTime, FString InTimeZone, uint8_t InTimeStyle);
    static FText AsTime_DateTime(const FDateTime& In, uint8_t InTimeStyle);
    static FText AsTimespan_Timespan(const FTimespan& InTimespan);
    static FText Conv_BoolToText(bool InBool);
    static FText Conv_ByteToText(uint8_t Value);
    static FText Conv_ColorToText(FLinearColor InColor);
    static FText Conv_DoubleToText(double Value, uint8_t RoundingMode, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits, int32_t MinimumFractionalDigits, int32_t MaximumFractionalDigits);
    static FText Conv_Int64ToText(int64_t Value, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits);
    static FText Conv_IntToText(int32_t Value, bool bAlwaysSign, bool bUseGrouping, int32_t MinimumIntegralDigits, int32_t MaximumIntegralDigits);
    static FText Conv_NameToText(FName InName);
    static FText Conv_NumericPropertyToText(const int32_t& Value);
    static FText Conv_ObjectToText(UObject* InObj);
    static FText Conv_RotatorToText(FRotator InRot);
    static FText Conv_StringToText(FString InString);
    static FString Conv_TextToString(const FText& InText);
    static FText Conv_TransformToText(const FTransform& InTrans);
    static FText Conv_Vector2dToText(FVector2D InVec);
    static FText Conv_VectorToText(FVector InVec);
    static bool EditTextPropertySourceString(UObject* TextOwner, const FName PropertyName, FString SourceString, const bool bEmitChangeNotify);
    static bool EditTextSourceString(UObject* TextOwner, FText& Text, FString SourceString, const bool bEmitChangeNotify);
    static bool EqualEqual_IgnoreCase_TextText(const FText& A, const FText& B);
    static bool EqualEqual_TextText(const FText& A, const FText& B);
    static bool FindTextInLocalizationTable(FString Namespace, FString Key, FText& OutText, FString SourceString);
    static FText Format(FText InPattern, TArray<FFormatArgumentData> InArgs);
    static FText GetEmptyText();
    static bool GetTextId(FText Text, FString& OutNamespace, FString& OutKey);
    static FString GetTextSourceString(FText Text);
    static void IsPolyglotDataValid(const FPolyglotTextData& PolyglotData, bool& IsValid, FText& ErrorMessage);
    static FText MakeInvariantText(FString InString);
    static bool NotEqual_IgnoreCase_TextText(const FText& A, const FText& B);
    static bool NotEqual_TextText(const FText& A, const FText& B);
    static FText PolyglotDataToText(const FPolyglotTextData& PolyglotData);
    static bool StringTableIdAndKeyFromText(FText Text, FName& OutTableId, FString& OutKey);
    static FText TextFromStringTable(const FName TableId, FString Key);
    static bool TextIsCultureInvariant(const FText& InText);
    static bool TextIsEmpty(const FText& InText);
    static bool TextIsFromStringTable(const FText& Text);
    static bool TextIsTransient(const FText& InText);
    static FText TextToLower(const FText& InText);
    static FText TextToUpper(const FText& InText);
    static FText TextTrimPreceding(const FText& InText);
    static FText TextTrimPrecedingAndTrailing(const FText& InText);
    static FText TextTrimTrailing(const FText& InText);
};

// Size: 0x330
class ALODActor : public AActor {
    /* 0x02a8 */ UStaticMeshComponent* StaticMeshComponent;
    /* 0x02b0 */ TMap<FHLODInstancingKey, UInstancedStaticMeshComponent*> InstancedStaticMeshComponents;
    /* 0x0300 */ UHLODProxy* Proxy;
    /* 0x0308 */ FName Key;
    /* 0x0310 */ float LODDrawDistance;
    /* 0x0314 */ int32_t LODLevel;
    /* 0x0318 */ TArray<AActor*> SubActors;
    /* 0x0328 */ uint8_t CachedNumHLODLevels;

    void OnSubActorEndPlay(AActor* Actor, uint8_t Reason);
};

// Size: 0x20
struct FLODMappingData {
    /* 0x0000 */ TArray<int32_t> Mapping;
    /* 0x0010 */ TArray<int32_t> InverseMapping;
};

// Size: 0x10
struct FLODSoloTrack {
    /* 0x0000 */ TArray<uint8_t> SoloEnableSetting;
};

// Size: 0x150
class ULODSyncComponent : public UActorComponent {
    /* 0x00b8 */ int32_t NumLODs;
    /* 0x00bc */ int32_t ForcedLOD;
    /* 0x00c0 */ int32_t MinLOD;
    /* 0x00c8 */ TArray<FComponentSync> ComponentsToSync;
    /* 0x00d8 */ TMap<FName, FLODMappingData> CustomLODMapping;
    /* 0x0128 */ int32_t CurrentLOD;
    /* 0x012c */ int32_t CurrentNumLODs;
    /* 0x0130 */ TArray<UPrimitiveComponent*> DriveComponents;
    /* 0x0140 */ TArray<UPrimitiveComponent*> SubComponents;

    FString GetLODSyncDebugText() const;
};

// Size: 0x28
class ILODSyncInterface : public UInterface {
};

// Size: 0x18
struct FLatentActionInfo {
    /* 0x0000 */ int32_t Linkage;
    /* 0x0004 */ int32_t UUID;
    /* 0x0008 */ FName ExecutionFunction;
    /* 0x0010 */ UObject* CallbackTarget;
};

// Size: 0x60
struct FLatentActionManager {
};

// Size: 0x20
struct FLaunchOnTestSettings {
    /* 0x0000 */ FFilePath LaunchOnTestmap;
    /* 0x0010 */ FString DeviceID;
};

// Size: 0x48
class ULayer : public UObject {
    /* 0x0028 */ FName LayerName;
    /* 0x0030 */ bool bIsVisible;
    /* 0x0038 */ TArray<FLayerActorStats> ActorStats;
};

// Size: 0x10
struct FLayerActorStats {
    /* 0x0000 */ UClass* Type;
    /* 0x0008 */ int32_t Total;
};

// Size: 0xc0
struct FLensBloomSettings {
    /* 0x0000 */ FGaussianSumBloomSettings GaussianSum;
    /* 0x0088 */ FConvolutionBloomSettings Convolution;
    /* 0x00b8 */ uint8_t Method;
};

// Size: 0x20
struct FLensImperfectionSettings {
    /* 0x0000 */ UTexture* DirtMask;
    /* 0x0008 */ float DirtMaskIntensity;
    /* 0x000c */ FLinearColor DirtMaskTint;
};

// Size: 0xe8
struct FLensSettings {
    /* 0x0000 */ FLensBloomSettings Bloom;
    /* 0x00c0 */ FLensImperfectionSettings Imperfections;
    /* 0x00e0 */ float ChromaticAberration;
};

// Size: 0x3d8
class ULevel : public UObject {
    /* 0x00c0 */ UWorld* OwningWorld;
    /* 0x00c8 */ UModel* Model;
    /* 0x00d0 */ TArray<UModelComponent*> ModelComponents;
    /* 0x00e0 */ ULevelActorContainer* ActorCluster;
    /* 0x00e8 */ int32_t NumTextureStreamingUnbuiltComponents;
    /* 0x00ec */ int32_t NumTextureStreamingDirtyResources;
    /* 0x00f0 */ ALevelScriptActor* LevelScriptActor;
    /* 0x00f8 */ ANavigationObjectBase* NavListStart;
    /* 0x0100 */ ANavigationObjectBase* NavListEnd;
    /* 0x0108 */ TArray<UNavigationDataChunk*> NavDataChunks;
    /* 0x0118 */ float LightmapTotalSize;
    /* 0x011c */ float ShadowmapTotalSize;
    /* 0x0120 */ TArray<FVector> StaticNavigableGeometry;
    /* 0x0130 */ TArray<FGuid> StreamingTextureGuids;
    /* 0x0140 */ TArray<FName> StreamingTextures;
    /* 0x0150 */ uint32_t PackedTextureStreamingQualityLevelFeatureLevel;
    /* 0x0210 */ FGuid LevelBuildDataId;
    /* 0x0220 */ UMapBuildDataRegistry* MapBuildData;
    /* 0x0228 */ FIntVector LightBuildLevelOffset;
    /* 0x0240 */ bool bIsLightingScenario;
    /* 0x0240 */ bool bTextureStreamingRotationChanged;
    /* 0x0240 */ bool bStaticComponentsRegisteredInStreamingManager;
    /* 0x0240 */ bool bIsVisible;
    /* 0x0243 */ bool bIsPartitioned;
    /* 0x02b0 */ AWorldSettings* WorldSettings;
    /* 0x02b8 */ AWorldDataLayers* WorldDataLayers;
    /* 0x02c0 */ TSoftObjectPtr<UWorldPartitionRuntimeCell> WorldPartitionRuntimeCell;
    /* 0x0398 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x03b8 */ TArray<FReplicatedStaticActorDestructionInfo> DestroyedReplicatedStaticActors;
};

// Size: 0x38
class ULevelActorContainer : public UObject {
    /* 0x0028 */ TArray<AActor*> Actors;
};

// Size: 0x2b8
class ALevelBounds : public AActor {
    /* 0x02a8 */ UBoxComponent* BoxComponent;
    /* 0x02b0 */ bool bAutoUpdateBounds;
};

// Size: 0x78
struct FLevelCollection {
    /* 0x0008 */ AGameStateBase* GameState;
    /* 0x0010 */ UNetDriver* NetDriver;
    /* 0x0018 */ UDemoNetDriver* DemoNetDriver;
    /* 0x0020 */ ULevel* PersistentLevel;
    /* 0x0028 */ TSet<ULevel*> Levels;
};

// Size: 0x348
class ALevelInstance : public AActor {
    /* 0x02b0 */ ULevelInstanceComponent* LevelInstanceComponent;
    /* 0x02b8 */ TSoftObjectPtr<UWorld> CookedWorldAsset;
    /* 0x02e0 */ FGuid LevelInstanceSpawnGuid;
};

// Size: 0x240
class ULevelInstanceComponent : public USceneComponent {
};

// Size: 0x28
class ULevelInstanceContainerInstance : public UActorDescContainerInstance {
};

// Size: 0x2a8
class ALevelInstanceEditorInstanceActor : public AActor {
};

// Size: 0x28
class ULevelInstanceEditorObject : public UObject {
};

// Size: 0x28
class ILevelInstanceEditorPivotInterface : public UInterface {
};

// Size: 0x28
class ILevelInstanceInterface : public UInterface {

    ULevel* GetLoadedLevel() const;
    TSoftObjectPtr<UWorld> GetWorldAsset() const;
    bool IsLoaded() const;
    void LoadLevelInstance();
    bool SetWorldAsset(TSoftObjectPtr<UWorld> WorldAsset);
    void UnloadLevelInstance();
};

// Size: 0x2b0
class ALevelInstancePivot : public AActor {
};

// Size: 0x28
class ULevelInstancePropertyOverrideAsset : public UWorldPartitionPropertyOverride {
};

// Size: 0x28
class ULevelInstancePropertyOverrideContainer : public UActorDescContainer {
};

// Size: 0x28
class ULevelInstancePropertyOverridePolicy : public UWorldPartitionPropertyOverridePolicy {
};

// Size: 0x28
class ULevelInstancePropertyOverrideSamplePolicy : public ULevelInstancePropertyOverridePolicy {
};

// Size: 0x38
class ULevelInstanceSettings : public UObject {
    /* 0x0028 */ FString PropertyOverridePolicyClass;
};

// Size: 0x1c8
class ULevelInstanceSubsystem : public UWorldSubsystem {
};

// Size: 0x18
struct FLevelNameAndTime {
    /* 0x0000 */ FString LevelName;
    /* 0x0010 */ uint32_t LevelChangeTimeInMS;
};

// Size: 0x2b0
class ALevelScriptActor : public AActor {
    /* 0x02a8 */ bool bInputEnabled;

    void LevelReset();
    bool RemoteEvent(FName EventName);
    void SetCinematicMode(bool bCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning);
    void WorldOriginLocationChanged(FIntVector OldOriginLocation, FIntVector NewOriginLocation);
};

// Size: 0xa8
class ULevelScriptBlueprint : public UBlueprint {
};

// Size: 0x158
struct FLevelSimplificationDetails {
    /* 0x0000 */ bool bCreatePackagePerAsset;
    /* 0x0004 */ float DetailsPercentage;
    /* 0x0008 */ FMaterialProxySettings StaticMeshMaterialSettings;
    /* 0x00a8 */ bool bOverrideLandscapeExportLOD;
    /* 0x00ac */ int32_t LandscapeExportLOD;
    /* 0x00b0 */ FMaterialProxySettings LandscapeMaterialSettings;
    /* 0x0150 */ bool bBakeFoliageToLandscape;
    /* 0x0151 */ bool bBakeGrassToLandscape;
};

// Size: 0x1d0
class ULevelStreaming : public UObject {
    /* 0x0028 */ TSoftObjectPtr<UWorld> WorldAsset;
    /* 0x0050 */ int32_t StreamingPriority;
    /* 0x005c */ FName PackageNameToLoad;
    /* 0x0068 */ TArray<FName> LODPackageNames;
    /* 0x0090 */ FTransform LevelTransform;
    /* 0x00f0 */ bool bClientOnlyVisible;
    /* 0x00f4 */ int32_t LevelLODIndex;
    /* 0x00f8 */ bool bShouldBeVisible;
    /* 0x00f8 */ bool bShouldBeLoaded;
    /* 0x011a */ bool bLocked;
    /* 0x011a */ bool bIsStatic;
    /* 0x011a */ bool bShouldBlockOnLoad;
    /* 0x011a */ bool bShouldBlockOnUnload;
    /* 0x011a */ bool bDisableDistanceStreaming;
    /* 0x011a */ bool bDrawOnLevelStatusMap;
    /* 0x011c */ FLinearColor LevelColor;
    /* 0x0130 */ TArray<ALevelStreamingVolume*> EditorStreamingVolumes;
    /* 0x0140 */ float MinTimeBetweenVolumeUnloadRequests;
    /* 0x0148 */ FMulticastInlineDelegate OnLevelLoaded;
    /* 0x0158 */ FMulticastInlineDelegate OnLevelUnloaded;
    /* 0x0168 */ FMulticastInlineDelegate OnLevelShown;
    /* 0x0178 */ FMulticastInlineDelegate OnLevelHidden;
    /* 0x0188 */ ULevel* LoadedLevel;
    /* 0x0190 */ ULevel* PendingUnloadLevel;

    ULevelStreaming* CreateInstance(FString UniqueInstanceName);
    bool GetIsRequestingUnloadAndRemoval() const;
    ALevelScriptActor* GetLevelScriptActor();
    ULevel* GetLoadedLevel() const;
    FName GetWorldAssetPackageFName() const;
    bool IsLevelLoaded() const;
    bool IsLevelVisible() const;
    bool IsStreamingStatePending() const;
    void SetIsRequestingUnloadAndRemoval(bool bInIsRequestingUnloadAndRemoval);
    void SetLevelLODIndex(int32_t LODIndex);
    void SetPriority(int32_t NewPriority);
    void SetShouldBeLoaded(bool bInShouldBeLoaded);
    void SetShouldBeVisible(bool bInShouldBeVisible);
    bool ShouldBeLoaded() const;
};

// Size: 0x1d0
class ULevelStreamingAlwaysLoaded : public ULevelStreaming {
};

// Size: 0x1d0
class ULevelStreamingDynamic : public ULevelStreaming {
    /* 0x01c8 */ bool bInitiallyLoaded;
    /* 0x01c8 */ bool bInitiallyVisible;

    static ULevelStreamingDynamic* LoadLevelInstance(UObject* WorldContextObject, FString LevelName, FVector Location, FRotator Rotation, bool& bOutSuccess, FString OptionalLevelNameOverride, UClass* OptionalLevelStreamingClass, bool bLoadAsTempPackage);
    static ULevelStreamingDynamic* LoadLevelInstanceBySoftObjectPtr(UObject* WorldContextObject, TSoftObjectPtr<UWorld> Level, FVector Location, FRotator Rotation, bool& bOutSuccess, FString OptionalLevelNameOverride, UClass* OptionalLevelStreamingClass, bool bLoadAsTempPackage);
};

// Size: 0x200
class ULevelStreamingLevelInstance : public ULevelStreamingDynamic {
};

// Size: 0x1d0
class ULevelStreamingLevelInstanceEditor : public ULevelStreamingAlwaysLoaded {
};

// Size: 0x1d0
class ULevelStreamingLevelInstanceEditorPropertyOverride : public ULevelStreamingDynamic {
};

// Size: 0x1d0
class ULevelStreamingPersistent : public ULevelStreaming {
};

// Size: 0xc0
class ULevelStreamingProfilingSubsystem : public UWorldSubsystem {
};

// Size: 0x10
struct FLevelStreamingStatus {
    /* 0x0000 */ FName PackageName;
    /* 0x0008 */ bool bShouldBeLoaded;
    /* 0x0008 */ bool bShouldBeVisible;
    /* 0x000c */ uint32_t LODIndex;
};

// Size: 0x2f8
class ALevelStreamingVolume : public AVolume {
    /* 0x02e0 */ TArray<FName> StreamingLevelNames;
    /* 0x02f0 */ bool bEditorPreVisOnly;
    /* 0x02f0 */ bool bDisabled;
    /* 0x02f4 */ uint8_t StreamingUsage;
};

// Size: 0x38
struct FLevelViewportInfo {
    /* 0x0000 */ FVector CamPosition;
    /* 0x0018 */ FRotator CamRotation;
    /* 0x0030 */ float CamOrthoZoom;
    /* 0x0034 */ bool CamUpdated;
};

// Size: 0x2b8
class ALight : public AActor {
    /* 0x02a8 */ ULightComponent* LightComponent;
    /* 0x02b0 */ bool bEnabled;

    float GetBrightness() const;
    FLinearColor GetLightColor() const;
    bool IsEnabled() const;
    void OnRep_bEnabled();
    void SetAffectTranslucentLighting(bool bNewValue);
    void SetBrightness(float NewBrightness);
    void SetCastShadows(bool bNewValue);
    void SetEnabled(bool bSetEnabled);
    void SetLightColor(FLinearColor NewLightColor);
    void SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance);
    void SetLightFunctionMaterial(UMaterialInterface* NewLightFunctionMaterial);
    void SetLightFunctionScale(FVector NewLightFunctionScale);
    void ToggleEnabled();
};

// Size: 0x3a0
class ULightComponent : public ULightComponentBase {
    /* 0x0288 */ float temperature;
    /* 0x028c */ float MaxDrawDistance;
    /* 0x0290 */ float MaxDistanceFadeRange;
    /* 0x0294 */ bool bUseTemperature;
    /* 0x0298 */ int32_t ShadowMapChannel;
    /* 0x029c */ int32_t PreviewShadowMapChannel;
    /* 0x02a0 */ float MinRoughness;
    /* 0x02a4 */ float SpecularScale;
    /* 0x02a8 */ float DiffuseScale;
    /* 0x02ac */ float ShadowResolutionScale;
    /* 0x02b0 */ float ShadowBias;
    /* 0x02b4 */ float ShadowSlopeBias;
    /* 0x02b8 */ float shadowSharpen;
    /* 0x02bc */ float ContactShadowLength;
    /* 0x02c0 */ bool ContactShadowLengthInWS;
    /* 0x02c4 */ float ContactShadowCastingIntensity;
    /* 0x02c8 */ float ContactShadowNonCastingIntensity;
    /* 0x02cc */ bool InverseSquaredFalloff;
    /* 0x02cc */ bool CastTranslucentShadows;
    /* 0x02cc */ bool bCastShadowsFromCinematicObjectsOnly;
    /* 0x02cc */ bool bForceCachedShadowsForMovablePrimitives;
    /* 0x02cc */ bool bAllowMegaLights;
    /* 0x02d0 */ uint8_t MegaLightsShadowMethod;
    /* 0x02d1 */ FLightingChannels LightingChannels;
    /* 0x02d2 */ FViewLightingChannels ViewLightingChannels;
    /* 0x02d8 */ UMaterialInterface* LightFunctionMaterial;
    /* 0x02e0 */ FVector LightFunctionScale;
    /* 0x02f8 */ UTextureLightProfile* IESTexture;
    /* 0x0300 */ bool bUseIESBrightness;
    /* 0x0304 */ float IESBrightnessScale;
    /* 0x0308 */ float LightFunctionFadeDistance;
    /* 0x030c */ float DisabledBrightness;
    /* 0x0310 */ bool bEnableLightShaftBloom;
    /* 0x0314 */ float BloomScale;
    /* 0x0318 */ float BloomThreshold;
    /* 0x031c */ float BloomMaxBrightness;
    /* 0x0320 */ FColor BloomTint;
    /* 0x0324 */ bool bUseRayTracedDistanceFieldShadows;
    /* 0x0328 */ float RayStartOffsetDepthScale;

    void SetAffectTranslucentLighting(bool bNewValue);
    void SetBloomMaxBrightness(float NewValue);
    void SetBloomScale(float NewValue);
    void SetBloomThreshold(float NewValue);
    void SetBloomTint(FColor NewValue);
    void SetDiffuseScale(float NewValue);
    void SetEnableLightShaftBloom(bool bNewValue);
    void SetForceCachedShadowsForMovablePrimitives(bool bNewValue);
    void SetIESBrightnessScale(float NewValue);
    void SetIESTexture(UTextureLightProfile* NewValue);
    void SetIndirectLightingIntensity(float NewIntensity);
    void SetIntensity(float NewIntensity);
    void SetLightColor(FLinearColor NewLightColor, bool bSRGB);
    void SetLightFColor(FColor NewLightColor);
    void SetLightFunctionDisabledBrightness(float NewValue);
    void SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance);
    void SetLightFunctionMaterial(UMaterialInterface* NewLightFunctionMaterial);
    void SetLightFunctionScale(FVector NewLightFunctionScale);
    void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
    void SetShadowBias(float NewValue);
    void SetShadowSlopeBias(float NewValue);
    void SetSpecularScale(float NewValue);
    void SetTemperature(float NewTemperature);
    void SetTransmission(bool bNewValue);
    void SetUseIESBrightness(bool bNewValue);
    void SetUseRayTracedDistanceFieldShadows(bool bNewValue);
    void SetUseTemperature(bool bNewValue);
    void SetVolumetricScatteringIntensity(float NewIntensity);
};

// Size: 0x290
class ULightComponentBase : public USceneComponent {
    /* 0x0240 */ FGuid OriginalLightGuid;
    /* 0x0250 */ FGuid LightGuid;
    /* 0x0260 */ float Brightness;
    /* 0x0264 */ float Intensity;
    /* 0x0268 */ FColor LightColor;
    /* 0x026c */ bool bAffectsWorld;
    /* 0x026c */ bool CastShadows;
    /* 0x026c */ bool CastStaticShadows;
    /* 0x026c */ bool CastDynamicShadows;
    /* 0x026c */ bool bAffectTranslucentLighting;
    /* 0x026c */ bool bTransmission;
    /* 0x026c */ bool bCastVolumetricShadow;
    /* 0x026c */ bool bCastDeepShadow;
    /* 0x026d */ bool bCastRaytracedShadow;
    /* 0x0270 */ uint8_t CastRaytracedShadow;
    /* 0x0274 */ bool bAffectReflection;
    /* 0x0274 */ bool bAffectGlobalIllumination;
    /* 0x0278 */ float DeepShadowLayerDistribution;
    /* 0x027c */ float IndirectLightingIntensity;
    /* 0x0280 */ float VolumetricScatteringIntensity;
    /* 0x0284 */ int32_t SamplesPerPixel;

    FLinearColor GetLightColor() const;
    void SetAffectGlobalIllumination(bool bNewValue);
    void SetAffectReflection(bool bNewValue);
    void SetCastDeepShadow(bool bNewValue);
    void SetCastRaytracedShadow(bool bNewValue);
    void SetCastRaytracedShadows(uint8_t bNewValue);
    void SetCastShadows(bool bNewValue);
    void SetCastVolumetricShadow(bool bNewValue);
    void SetSamplesPerPixel(int32_t NewValue);
};

// Size: 0x168
class ULightMapTexture2D : public UTexture2D {
};

// Size: 0x28
class ULightMapVirtualTexture : public UVirtualTexture {
};

// Size: 0x178
class ULightMapVirtualTexture2D : public UTexture2D {
    /* 0x0160 */ TArray<int8_t> TypeToLayer;
};

// Size: 0x28
class ULightWeightInstanceBlueprintFunctionLibrary : public UBlueprintFunctionLibrary {

    static FActorInstanceHandle ConvertActorToLightWeightInstance(AActor* Actor);
    static FActorInstanceHandle CreateNewLightWeightInstance(UClass* ActorClass, FTransform Transform, UDataLayerInstance* Layer, UWorld* World);
};

// Size: 0x360
class ALightWeightInstanceManager : public AActor {
    /* 0x02c0 */ UClass* RepresentedClass;
    /* 0x02c8 */ UClass* AcceptedClass;
    /* 0x02d0 */ TArray<FTransform> InstanceTransforms;
    /* 0x02e0 */ TMap<int32_t, AActor*> Actors;
    /* 0x0340 */ TArray<int32_t> FreeIndices;
    /* 0x0350 */ TArray<bool> ValidIndices;

    void OnRep_Transforms();
    void OnSpawnedActorDestroyed(AActor* DestroyedActor);
};

// Size: 0x3c8
class ALightWeightInstanceStaticMeshManager : public ALightWeightInstanceManager {
    /* 0x0368 */ TSoftObjectPtr<UStaticMesh> StaticMesh;
    /* 0x0390 */ UInstancedStaticMeshComponent* ISMComponent;
    /* 0x0398 */ TArray<int32_t> RenderingIndicesToDataIndices;
    /* 0x03a8 */ TArray<int32_t> DataIndicesToRenderingIndices;

    void OnRep_StaticMesh();
};

// Size: 0x1
struct FLightingChannels {
    /* 0x0000 */ bool bChannel0;
    /* 0x0000 */ bool bChannel1;
    /* 0x0000 */ bool bChannel2;
};

// Size: 0x40
class ULightmappedSurfaceCollection : public UObject {
    /* 0x0028 */ UModel* SourceModel;
    /* 0x0030 */ TArray<int32_t> Surfaces;
};

// Size: 0x2e0
class ALightmassCharacterIndirectDetailVolume : public AVolume {
};

// Size: 0x10
struct FLightmassDebugOptions {
    /* 0x0000 */ bool bDebugMode;
    /* 0x0000 */ bool bStatsEnabled;
    /* 0x0000 */ bool bGatherBSPSurfacesAcrossComponents;
    /* 0x0004 */ float CoplanarTolerance;
    /* 0x0008 */ bool bUseImmediateImport;
    /* 0x0008 */ bool bImmediateProcessMappings;
    /* 0x0008 */ bool bSortMappings;
    /* 0x0008 */ bool bDumpBinaryFiles;
    /* 0x0008 */ bool bDebugMaterials;
    /* 0x0008 */ bool bPadMappings;
    /* 0x0008 */ bool bDebugPaddings;
    /* 0x0008 */ bool bOnlyCalcDebugTexelMappings;
    /* 0x0009 */ bool bUseRandomColors;
    /* 0x0009 */ bool bColorBordersGreen;
    /* 0x0009 */ bool bColorByExecutionTime;
    /* 0x000c */ float ExecutionTimeDivisor;
};

// Size: 0x10
struct FLightmassDirectionalLightSettings : public FLightmassLightSettings {
    /* 0x000c */ float LightSourceAngle;
};

// Size: 0x2e0
class ALightmassImportanceVolume : public AVolume {
};

// Size: 0xc
struct FLightmassLightSettings {
    /* 0x0000 */ float IndirectLightingSaturation;
    /* 0x0004 */ float ShadowExponent;
    /* 0x0008 */ bool bUseAreaShadowsForStationaryLight;
};

// Size: 0x10
struct FLightmassMaterialInterfaceSettings {
    /* 0x0000 */ float EmissiveBoost;
    /* 0x0004 */ float DiffuseBoost;
    /* 0x0008 */ float ExportResolutionScale;
    /* 0x000c */ bool bCastShadowAsMasked;
    /* 0x000c */ bool bOverrideCastShadowAsMasked;
    /* 0x000c */ bool bOverrideEmissiveBoost;
    /* 0x000c */ bool bOverrideDiffuseBoost;
    /* 0x000c */ bool bOverrideExportResolutionScale;
};

// Size: 0xc
struct FLightmassPointLightSettings : public FLightmassLightSettings {
};

// Size: 0x2b0
class ALightmassPortal : public AActor {
    /* 0x02a8 */ ULightmassPortalComponent* PortalComponent;
};

// Size: 0x250
class ULightmassPortalComponent : public USceneComponent {
    /* 0x0240 */ UBoxComponent* PreviewBox;
};

// Size: 0x18
struct FLightmassPrimitiveSettings {
    /* 0x0000 */ bool bUseTwoSidedLighting;
    /* 0x0000 */ bool bShadowIndirectOnly;
    /* 0x0000 */ bool bUseEmissiveForStaticLighting;
    /* 0x0000 */ bool bUseVertexNormalForHemisphereGather;
    /* 0x0004 */ float EmissiveLightFalloffExponent;
    /* 0x0008 */ float EmissiveLightExplicitInfluenceRadius;
    /* 0x000c */ float EmissiveBoost;
    /* 0x0010 */ float DiffuseBoost;
    /* 0x0014 */ float FullyOccludedSamplesFraction;
};

// Size: 0x40
class ULightmassPrimitiveSettingsObject : public UObject {
    /* 0x0028 */ FLightmassPrimitiveSettings LightmassSettings;
};

// Size: 0x54
struct FLightmassWorldInfoSettings {
    /* 0x0000 */ float StaticLightingLevelScale;
    /* 0x0004 */ int32_t NumIndirectLightingBounces;
    /* 0x0008 */ int32_t NumSkyLightingBounces;
    /* 0x000c */ float IndirectLightingQuality;
    /* 0x0010 */ float IndirectLightingSmoothness;
    /* 0x0014 */ FColor EnvironmentColor;
    /* 0x0018 */ float EnvironmentIntensity;
    /* 0x001c */ float EmissiveBoost;
    /* 0x0020 */ float DiffuseBoost;
    /* 0x0024 */ uint8_t VolumeLightingMethod;
    /* 0x0025 */ bool bUseAmbientOcclusion;
    /* 0x0025 */ bool bGenerateAmbientOcclusionMaterialMask;
    /* 0x0025 */ bool bVisualizeMaterialDiffuse;
    /* 0x0025 */ bool bVisualizeAmbientOcclusion;
    /* 0x0025 */ bool bCompressLightmaps;
    /* 0x0028 */ float VolumetricLightmapDetailCellSize;
    /* 0x002c */ float VolumetricLightmapMaximumBrickMemoryMb;
    /* 0x0030 */ float VolumetricLightmapLoadingCellSize;
    /* 0x0034 */ float VolumetricLightmapSphericalHarmonicSmoothing;
    /* 0x0038 */ float VolumeLightSamplePlacementScale;
    /* 0x003c */ float DirectIlluminationOcclusionFraction;
    /* 0x0040 */ float IndirectIlluminationOcclusionFraction;
    /* 0x0044 */ float OcclusionExponent;
    /* 0x0048 */ float FullyOccludedSamplesFraction;
    /* 0x004c */ float MaxOcclusionDistance;
    /* 0x0050 */ bool bWorldPartition;
};

// Size: 0x560
class ULineBatchComponent : public UPrimitiveComponent {
};

// Size: 0x1c
struct FLinearConstraint : public FConstraintBaseParams {
    /* 0x0014 */ float Limit;
    /* 0x0018 */ uint8_t XMotion;
    /* 0x0019 */ uint8_t YMotion;
    /* 0x001a */ uint8_t ZMotion;
};

// Size: 0x68
struct FLinearDriveConstraint {
    /* 0x0000 */ FVector PositionTarget;
    /* 0x0018 */ FVector VelocityTarget;
    /* 0x0030 */ FConstraintDrive XDrive;
    /* 0x0040 */ FConstraintDrive YDrive;
    /* 0x0050 */ FConstraintDrive ZDrive;
    /* 0x0060 */ bool bAccelerationMode;
};

// Size: 0x20
struct FLinkedAnimLayerClassData {
    /* 0x0008 */ TArray<FLinkedAnimLayerInstanceData> InstancesData;
};

// Size: 0x60
struct FLinkedAnimLayerInstanceData {
    /* 0x0000 */ UAnimInstance* Instance;
    /* 0x0008 */ TMap<FName, TWeakObjectPtr<UAnimInstance>> LinkedFunctions;
};

// Size: 0x2b0
class ALocalFogVolume : public AInfo {
    /* 0x02a8 */ ULocalFogVolumeComponent* LocalFogVolumeVolume;
};

// Size: 0x280
class ULocalFogVolumeComponent : public USceneComponent {
    /* 0x0240 */ float RadialFogExtinction;
    /* 0x0244 */ float HeightFogExtinction;
    /* 0x0248 */ float HeightFogFalloff;
    /* 0x024c */ float HeightFogOffset;
    /* 0x0250 */ float FogPhaseG;
    /* 0x0254 */ FLinearColor FogAlbedo;
    /* 0x0264 */ FLinearColor FogEmissive;
    /* 0x0274 */ int32_t FogSortPriority;

    void SetFogAlbedo(FLinearColor NewValue);
    void SetFogEmissive(FLinearColor NewValue);
    void SetFogPhaseG(float NewValue);
    void SetHeightFogExtinction(float NewValue);
    void SetHeightFogFalloff(float NewValue);
    void SetHeightFogOffset(float NewValue);
    void SetRadialFogExtinction(float NewValue);
};

// Size: 0x3c0
class ULocalLightComponent : public ULightComponent {
    /* 0x0398 */ ELightUnits IntensityUnits;
    /* 0x039c */ float InverseExposureBlend;
    /* 0x03a0 */ float Radius;
    /* 0x03a4 */ float AttenuationRadius;
    /* 0x03a8 */ FLightmassPointLightSettings LightmassSettings;

    static float GetUnitsConversionFactor(ELightUnits SrcUnits, ELightUnits TargetUnits, float CosHalfConeAngle);
    void SetAttenuationRadius(float NewRadius);
    void SetIntensityUnits(ELightUnits NewIntensityUnits);
};

// Size: 0x28
class ULocalMessage : public UObject {
};

// Size: 0x2b0
class ULocalPlayer : public UPlayer {
    /* 0x0078 */ UGameViewportClient* ViewportClient;
    /* 0x00b8 */ uint8_t AspectRatioAxisConstraint;
    /* 0x00c0 */ UClass* PendingLevelPlayerControllerClass;
    /* 0x00c8 */ bool bSentSplitJoin;
    /* 0x00e0 */ int32_t ControllerId;
};

// Size: 0x58
class ULocalPlayerSaveGame : public USaveGame {
    /* 0x0028 */ ULocalPlayer* OwningPlayer;
    /* 0x0030 */ FString SaveSlotName;
    /* 0x0040 */ int32_t SavedDataVersion;
    /* 0x0044 */ int32_t LoadedDataVersion;
    /* 0x0048 */ int32_t CurrentSaveRequest;
    /* 0x004c */ int32_t LastSuccessfulSaveRequest;
    /* 0x0050 */ int32_t LastErrorSaveRequest;

    static bool AsyncLoadOrCreateSaveGameForLocalPlayer(UClass* SaveGameClass, APlayerController* LocalPlayerController, FString SlotName, FDelegate Delegate);
    bool AsyncSaveGameToSlotForLocalPlayer();
    int32_t GetInvalidDataVersion() const;
    int32_t GetLatestDataVersion() const;
    APlayerController* GetLocalPlayerController() const;
    FPlatformUserId GetPlatformUserId() const;
    int32_t GetPlatformUserIndex() const;
    FString GetSaveSlotName() const;
    int32_t GetSavedDataVersion() const;
    bool IsSaveInProgress() const;
    static ULocalPlayerSaveGame* LoadOrCreateSaveGameForLocalPlayer(UClass* SaveGameClass, APlayerController* LocalPlayerController, FString SlotName);
    void OnPostLoad();
    void OnPostSave(bool bSuccess);
    void OnPreSave();
    void OnResetToDefault();
    void ResetToDefault();
    bool SaveGameToSlotForLocalPlayer();
    bool WasLastSaveSuccessful() const;
    bool WasLoaded() const;
    bool WasSaveRequested() const;
};

// Size: 0x30
class ULocalPlayerSubsystem : public USubsystem {
};

// Size: 0x20
struct FLocalSpacePose {
    /* 0x0000 */ TArray<FTransform> Transforms;
    /* 0x0010 */ TArray<FName> Names;
};

// Size: 0x20
struct FLocationBoneSocketInfo {
    /* 0x0000 */ FName BoneSocketName;
    /* 0x0008 */ FVector Offset;
};

// Size: 0x2f0
class ALocationVolume : public AVolume {
    /* 0x02e8 */ FColor DebugColor;

    bool IsLoaded() const;
    void Load();
    void Unload();
};

// Size: 0xf0
struct FMLLevelSetModelAndBonesBinningInfo : public FTableRowBase {
    /* 0x0008 */ FString ParentBoneName;
    /* 0x0018 */ FString ActiveBoneNames;
    /* 0x0028 */ FString MLModelInferenceInfoDataTablePath;
    /* 0x0038 */ FString MLModelInferenceInfoDataTableIndex;
    /* 0x0048 */ FString MLModelInferenceForIncorrectZoneInfoDataTableIndex;
    /* 0x0058 */ TArray<int32_t> NumberOfRotationComponentsPerBone;
    /* 0x0068 */ TArray<int32_t> RotationComponentIndexes;
    /* 0x0078 */ double SignedDistanceScaling;
    /* 0x0080 */ TArray<int32_t> DebugGridResolution;
    /* 0x0090 */ TArray<double> ReferenceBoneRotations;
    /* 0x00a0 */ TArray<double> ReferenceBoneTranslations;
    /* 0x00b0 */ TArray<float> TrainingGridOrigin;
    /* 0x00c0 */ TArray<float> TrainingGridAxisX;
    /* 0x00d0 */ TArray<float> TrainingGridAxisY;
    /* 0x00e0 */ TArray<float> TrainingGridAxisZ;
};

// Size: 0x38
struct FMLLevelSetModelInferenceInfo : public FTableRowBase {
    /* 0x0008 */ FString NNEModelPath;
    /* 0x0018 */ TArray<int32_t> ModelArchitectureActivationNodeSizes;
    /* 0x0028 */ FString MLModelWeights;
};

// Size: 0x20
struct FMTDResult {
    /* 0x0000 */ FVector Direction;
    /* 0x0018 */ float Distance;
};

// Size: 0x310
class AMapBuildDataActor : public AActor {
    /* 0x02a8 */ UMapBuildDataRegistry* BuildData;
    /* 0x02b0 */ AActor* ForceLinkToActor;
    /* 0x02b8 */ FBox ActorBounds;
    /* 0x02f0 */ FName CellPackage;
    /* 0x02f8 */ FGuid LevelBuildDataId;
};

// Size: 0x2b0
class UMapBuildDataRegistry : public UObject {
    /* 0x0028 */ uint8_t LevelLightingQuality;
};

// Size: 0x14
struct FMarkerSyncAnimPosition {
    /* 0x0000 */ FName PreviousMarkerName;
    /* 0x0008 */ FName NextMarkerName;
    /* 0x0010 */ float PositionBetweenMarkers;
};

// Size: 0x20
struct FMarkerSyncData {
    /* 0x0000 */ TArray<FAnimSyncMarker> AuthoredSyncMarkers;
};

// Size: 0x278
class UMaterial : public UMaterialInterface {
    /* 0x00e0 */ UPhysicalMaterial* PhysMaterial;
    /* 0x00e8 */ UPhysicalMaterialMask* PhysMaterialMask;
    /* 0x00f0 */ UPhysicalMaterial* PhysicalMaterialMap[8];
    /* 0x0130 */ TArray<UPhysicalMaterial*> RenderTracePhysicalMaterialOutputs;
    /* 0x0140 */ uint8_t MaterialDomain;
    /* 0x0141 */ uint8_t BlendMode;
    /* 0x0142 */ uint8_t DecalBlendMode;
    /* 0x0143 */ uint8_t MaterialDecalResponse;
    /* 0x0148 */ FMaterialOverrideNanite NaniteOverrideMaterial;
    /* 0x0180 */ FDisplacementScaling DisplacementScaling;
    /* 0x0188 */ FDisplacementFadeRange DisplacementFadeRange;
    /* 0x0190 */ uint8_t ShadingModel;
    /* 0x0191 */ bool bCastDynamicShadowAsMasked;
    /* 0x0192 */ FMaterialShadingModelField ShadingModels;
    /* 0x0194 */ float OpacityMaskClipValue;
    /* 0x0198 */ bool bEnableSeparateTranslucency;
    /* 0x0198 */ bool bEnableResponsiveAA;
    /* 0x0198 */ bool bScreenSpaceReflections;
    /* 0x0198 */ bool bContactShadows;
    /* 0x0198 */ bool TwoSided;
    /* 0x0198 */ bool bIsThinSurface;
    /* 0x0198 */ bool DitheredLODTransition;
    /* 0x0198 */ bool DitherOpacityMask;
    /* 0x0199 */ bool bAllowNegativeEmissiveColor;
    /* 0x0199 */ bool bHasPixelAnimation;
    /* 0x0199 */ bool bEnableTessellation;
    /* 0x0199 */ bool bEnableDisplacementFade;
    /* 0x019a */ uint8_t TranslucencyPass;
    /* 0x019b */ uint8_t TranslucencyLightingMode;
    /* 0x019c */ bool bEnableMobileSeparateTranslucency;
    /* 0x01a0 */ int32_t NumCustomizedUVs;
    /* 0x01a4 */ float TranslucencyDirectionalLightingIntensity;
    /* 0x01a8 */ float TranslucentShadowDensityScale;
    /* 0x01ac */ float TranslucentSelfShadowDensityScale;
    /* 0x01b0 */ float TranslucentSelfShadowSecondDensityScale;
    /* 0x01b4 */ float TranslucentSelfShadowSecondOpacity;
    /* 0x01b8 */ float TranslucentBackscatteringExponent;
    /* 0x01bc */ FLinearColor TranslucentMultipleScatteringExtinction;
    /* 0x01cc */ float TranslucentShadowStartOffset;
    /* 0x01d0 */ bool bDisableDepthTest;
    /* 0x01d0 */ bool bWriteOnlyAlpha;
    /* 0x01d0 */ bool bGenerateSphericalParticleNormals;
    /* 0x01d0 */ bool bTangentSpaceNormal;
    /* 0x01d0 */ bool bUseEmissiveForDynamicAreaLighting;
    /* 0x01d0 */ bool bUsedAsSpecialEngineMaterial;
    /* 0x01d0 */ bool bSubstrateRoughnessTracking;
    /* 0x01d0 */ bool bUsedWithSkeletalMesh;
    /* 0x01d1 */ bool bUsedWithEditorCompositing;
    /* 0x01d1 */ bool bUsedWithParticleSprites;
    /* 0x01d1 */ bool bUsedWithBeamTrails;
    /* 0x01d1 */ bool bUsedWithMeshParticles;
    /* 0x01d1 */ bool bUsedWithNiagaraSprites;
    /* 0x01d1 */ bool bUsedWithNiagaraRibbons;
    /* 0x01d1 */ bool bUsedWithNiagaraMeshParticles;
    /* 0x01d1 */ bool bUsedWithGeometryCache;
    /* 0x01d2 */ bool bUsedWithMaterialCache;
    /* 0x01d2 */ bool bUsedWithStaticLighting;
    /* 0x01d2 */ bool bUsedWithMorphTargets;
    /* 0x01d2 */ bool bUsedWithSplineMeshes;
    /* 0x01d2 */ bool bUsedWithInstancedStaticMeshes;
    /* 0x01d2 */ bool bUsedWithGeometryCollections;
    /* 0x01d2 */ bool bUsesDistortion;
    /* 0x01d2 */ bool bRootNodeOverridesDefaultDistortion;
    /* 0x01d3 */ bool bUsedWithClothing;
    /* 0x01d4 */ bool bUsedWithWater;
    /* 0x01d4 */ bool bUsedWithHairStrands;
    /* 0x01d4 */ bool bUsedWithLidarPointCloud;
    /* 0x01d4 */ bool bUsedWithVirtualHeightfieldMesh;
    /* 0x01d4 */ bool bUsedWithNanite;
    /* 0x01d4 */ bool bUsedWithVolumetricCloud;
    /* 0x01d4 */ bool bUsedWithHeterogeneousVolumes;
    /* 0x01d4 */ bool bUsedWithStaticMesh;
    /* 0x01d8 */ bool bUsedWithUI;
    /* 0x01d8 */ bool bForceCompatibleWithLightFunctionAtlas;
    /* 0x01d8 */ bool bAutomaticallySetUsageInEditor;
    /* 0x01d8 */ bool bFullyRough;
    /* 0x01d8 */ bool bUseFullPrecision;
    /* 0x01d9 */ uint8_t FloatPrecisionMode;
    /* 0x01da */ bool bUseLightmapDirectionality;
    /* 0x01da */ bool bUseAlphaToCoverage;
    /* 0x01dc */ bool bForwardRenderUsePreintegratedGFForSimpleIBL;
    /* 0x01e0 */ bool bUseHQForwardReflections;
    /* 0x01e0 */ bool bForwardBlendsSkyLightCubemaps;
    /* 0x01e0 */ bool bUsePlanarForwardReflections;
    /* 0x01e0 */ bool bNormalCurvatureToRoughness;
    /* 0x01e0 */ bool AllowTranslucentCustomDepthWrites;
    /* 0x01e0 */ bool bAllowFrontLayerTranslucency;
    /* 0x01e0 */ bool bCompatibleWithLumenCardSharing;
    /* 0x01e0 */ bool Wireframe;
    /* 0x01e1 */ bool bAllowTranslucentLocalLightShadow;
    /* 0x01e4 */ float TranslucentLocalLightShadowQuality;
    /* 0x01e8 */ float TranslucentDirectionalLightShadowQuality;
    /* 0x01ec */ uint8_t ShadingRate;
    /* 0x01ed */ bool bAllowVariableRateShading;
    /* 0x01ed */ bool bCanMaskedBeAssumedOpaque;
    /* 0x01ed */ bool bIsMasked;
    /* 0x01ed */ bool bIsPreviewMaterial;
    /* 0x01ed */ bool bIsFunctionPreviewMaterial;
    /* 0x01ed */ bool bUseMaterialAttributes;
    /* 0x01ed */ bool bEnableExecWire;
    /* 0x01ed */ bool bEnableNewHLSLGenerator;
    /* 0x01ee */ bool bCastRayTracedShadows;
    /* 0x01ee */ bool bUseTranslucencyVertexFog;
    /* 0x01ee */ bool bApplyCloudFogging;
    /* 0x01ee */ bool bIsSky;
    /* 0x01ee */ bool bComputeFogPerPixel;
    /* 0x01ee */ bool bOutputTranslucentVelocity;
    /* 0x01ee */ bool bIsTranslucencyVelocityFromDepth;
    /* 0x01ee */ bool bAllowDevelopmentShaderCompile;
    /* 0x01ef */ bool bIsMaterialEditorStatsMaterial;
    /* 0x01ef */ bool bRelaxRuntimeVirtualTextureRestrictions;
    /* 0x01f0 */ uint8_t BlendableLocation;
    /* 0x01f1 */ bool BlendableOutputAlpha;
    /* 0x01f4 */ FName UserSceneTexture;
    /* 0x01fc */ FIntPoint UserTextureDivisor;
    /* 0x0204 */ FName ResolutionRelativeToInput;
    /* 0x020c */ bool bDisablePreExposureScale;
    /* 0x020c */ bool bUsedWithNeuralNetworks;
    /* 0x020c */ bool bEnableStencilTest;
    /* 0x020d */ uint8_t StencilCompare;
    /* 0x020e */ uint8_t StencilRefValue;
    /* 0x020f */ int8_t NeuralProfileId;
    /* 0x0210 */ uint8_t RefractionMode;
    /* 0x0211 */ uint8_t RefractionMethod;
    /* 0x0212 */ uint8_t RefractionCoverageMode;
    /* 0x0213 */ uint8_t PixelDepthOffsetMode;
    /* 0x0214 */ int32_t BlendablePriority;
    /* 0x0218 */ bool bIsBlendable;
    /* 0x021a */ uint16_t PreshaderGap;
    /* 0x021c */ uint32_t UsageFlagWarnings;
    /* 0x0224 */ float RefractionDepthBias;
    /* 0x0228 */ float MaxWorldPositionOffsetDisplacement;
    /* 0x022c */ bool bAlwaysEvaluateWorldPositionOffset;
    /* 0x0234 */ FGuid StateId;
};

// Size: 0x30
struct FMaterialAttributesInput : public FExpressionInput {
    /* 0x0028 */ int64_t PropertyConnectedMask;
};

// Size: 0x530
class UMaterialBillboardComponent : public UPrimitiveComponent {
    /* 0x0520 */ TArray<FMaterialSpriteElement> Elements;

    void AddElement(UMaterialInterface* Material, UCurveFloat* DistanceToOpacityCurve, bool bSizeIsInScreenSpace, float BaseSizeX, float BaseSizeY, UCurveFloat* DistanceToSizeCurve);
    void SetElements(const TArray<FMaterialSpriteElement>& NewElements);
};

// Size: 0x490
struct FMaterialCachedExpressionData {
    /* 0x0000 */ FMaterialCachedParameterEntry RuntimeEntries[9];
    /* 0x02d0 */ TArray<int32_t> ScalarPrimitiveDataIndexValues;
    /* 0x02e0 */ TArray<int32_t> VectorPrimitiveDataIndexValues;
    /* 0x02f0 */ TArray<float> ScalarValues;
    /* 0x0300 */ TArray<bool> StaticSwitchValues;
    /* 0x0310 */ TArray<bool> DynamicSwitchValues;
    /* 0x0320 */ TArray<FLinearColor> VectorValues;
    /* 0x0330 */ TArray<FVector4d> DoubleVectorValues;
    /* 0x0340 */ TArray<TSoftObjectPtr<UTexture>> TextureValues;
    /* 0x0350 */ TArray<TSoftObjectPtr<UTextureCollection>> TextureCollectionValues;
    /* 0x0360 */ TArray<TSoftObjectPtr<UFont>> FontValues;
    /* 0x0370 */ TArray<int32_t> FontPageValues;
    /* 0x0380 */ TArray<TSoftObjectPtr<URuntimeVirtualTexture>> RuntimeVirtualTextureValues;
    /* 0x0390 */ TArray<TSoftObjectPtr<USparseVolumeTexture>> SparseVolumeTextureValues;
    /* 0x03a0 */ TArray<UObject*> ReferencedTextures;
    /* 0x03b0 */ TArray<UTextureCollection*> ReferencedTextureCollections;
    /* 0x03c0 */ TArray<UClass*> ReferencedExternalCodeExpressionClasses;
    /* 0x03d0 */ TArray<FMaterialFunctionInfo> FunctionInfos;
    /* 0x03e0 */ uint32_t FunctionInfosStateCRC;
    /* 0x03e8 */ TArray<FMaterialParameterCollectionInfo> ParameterCollectionInfos;
    /* 0x03f8 */ TArray<ULandscapeGrassType*> GrassTypes;
    /* 0x0408 */ FMaterialLayersFunctionsRuntimeData MaterialLayers;
    /* 0x0460 */ TArray<FName> DynamicParameterNames;
    /* 0x0470 */ TArray<bool> QualityLevelsUsed;
    /* 0x0480 */ bool bHasMaterialLayers;
    /* 0x0480 */ bool bHasRuntimeVirtualTextureOutput;
    /* 0x0480 */ bool bHasFirstPersonOutput;
    /* 0x0480 */ bool bHasMaterialCacheOutput;
    /* 0x0480 */ bool bMaterialCacheHasNonUVDerivedExpression;
    /* 0x0480 */ bool bHasSceneColor;
    /* 0x0480 */ bool bHasPerInstanceCustomData;
    /* 0x0480 */ bool bHasPerInstanceRandom;
    /* 0x0481 */ bool bHasVertexInterpolator;
    /* 0x0481 */ bool bHasCustomizedUVs;
    /* 0x0481 */ bool bHasMeshPaintTexture;
    /* 0x0481 */ bool bHasWorldPosition;
    /* 0x0484 */ uint32_t PropertyConnectedBitmask;
    /* 0x0488 */ uint64_t PropertyConnectedMask;
};

// Size: 0x2b0
struct FMaterialCachedExpressionEditorOnlyData {
    /* 0x0000 */ FMaterialCachedParameterEntry EditorOnlyEntries;
    /* 0x0050 */ FMaterialCachedParameterEditorEntry EditorEntries[10];
    /* 0x00f0 */ TArray<bool> StaticSwitchValues;
    /* 0x0100 */ TArray<FStaticComponentMaskValue> StaticComponentMaskValues;
    /* 0x0110 */ TArray<FVector2D> ScalarMinMaxValues;
    /* 0x0120 */ TArray<TSoftObjectPtr<UCurveLinearColor>> ScalarCurveValues;
    /* 0x0130 */ TArray<TSoftObjectPtr<UCurveLinearColorAtlas>> ScalarCurveAtlasValues;
    /* 0x0140 */ TArray<FParameterChannelNames> VectorChannelNameValues;
    /* 0x0150 */ TArray<bool> VectorUsedAsChannelMaskValues;
    /* 0x0160 */ TArray<FParameterChannelNames> TextureChannelNameValues;
    /* 0x0170 */ FMaterialLayersFunctionsEditorOnlyData MaterialLayers;
    /* 0x01e0 */ TArray<FString> AssetPaths;
    /* 0x01f0 */ TArray<FName> LandscapeLayerNames;
    /* 0x0200 */ TSet<FString> ExpressionIncludeFilePaths;
    /* 0x0250 */ TSet<FName> UserSceneTextureInputs;
    /* 0x02a0 */ TArray<FName> ShaderTags;
};

// Size: 0x10
struct FMaterialCachedParameterEditorEntry {
    /* 0x0000 */ TArray<FMaterialCachedParameterEditorInfo> EditorInfo;
};

// Size: 0x30
struct FMaterialCachedParameterEditorInfo {
    /* 0x0000 */ FString Description;
    /* 0x0010 */ FName Group;
    /* 0x0018 */ int32_t SortPriority;
    /* 0x001c */ int32_t AssetIndex;
    /* 0x0020 */ FGuid ExpressionGUID;
};

// Size: 0x50
struct FMaterialCachedParameterEntry {
    /* 0x0000 */ TSet<FMaterialParameterInfo> ParameterInfoSet;
};

// Size: 0x10
struct FMaterialCachedTexturesSamplingInfo {
    /* 0x0000 */ TArray<FTextureSamplingInfo> TextureSamplingInfos;
};

// Size: 0x6b8
class UMaterialEditorOnlyData : public UMaterialInterfaceEditorOnlyData {
    /* 0x0040 */ FColorMaterialInput BaseColor;
    /* 0x0080 */ FScalarMaterialInput Metallic;
    /* 0x00b0 */ FScalarMaterialInput Specular;
    /* 0x00e0 */ FScalarMaterialInput Roughness;
    /* 0x0110 */ FScalarMaterialInput Anisotropy;
    /* 0x0140 */ FVectorMaterialInput Normal;
    /* 0x0178 */ FVectorMaterialInput Tangent;
    /* 0x01b0 */ FColorMaterialInput EmissiveColor;
    /* 0x01f0 */ FScalarMaterialInput Opacity;
    /* 0x0220 */ FScalarMaterialInput OpacityMask;
    /* 0x0250 */ FVectorMaterialInput WorldPositionOffset;
    /* 0x0288 */ FScalarMaterialInput Displacement;
    /* 0x02b8 */ FColorMaterialInput SubsurfaceColor;
    /* 0x02f8 */ FScalarMaterialInput ClearCoat;
    /* 0x0328 */ FScalarMaterialInput ClearCoatRoughness;
    /* 0x0358 */ FScalarMaterialInput AmbientOcclusion;
    /* 0x0388 */ FScalarMaterialInput Refraction;
    /* 0x03b8 */ FVector2MaterialInput CustomizedUVs[8];
    /* 0x0578 */ FMaterialAttributesInput MaterialAttributes;
    /* 0x05a8 */ FScalarMaterialInput PixelDepthOffset;
    /* 0x05d8 */ FShadingModelMaterialInput ShadingModelFromMaterialExpression;
    /* 0x0608 */ FScalarMaterialInput SurfaceThickness;
    /* 0x0638 */ FSubstrateMaterialInput FrontMaterial;
    /* 0x0668 */ FMaterialExpressionCollection ExpressionCollection;
    /* 0x0698 */ TArray<FParameterGroupData> ParameterGroupData;
    /* 0x06a8 */ int32_t SubstrateConversionVersion;
    /* 0x06ac */ int32_t SubstrateVersion;
    /* 0x06b0 */ bool bIsSubsutrateAutoConvertedAndNotSaved;
};

// Size: 0x30
struct FMaterialEditorPromotionSettings {
    /* 0x0000 */ FFilePath DefaultMaterialAsset;
    /* 0x0010 */ FFilePath DefaultDiffuseTexture;
    /* 0x0020 */ FFilePath DefaultNormalTexture;
};

// Size: 0xb0
class UMaterialExpression : public UObject {
    /* 0x0028 */ int32_t MaterialExpressionEditorX;
    /* 0x002c */ int32_t MaterialExpressionEditorY;
    /* 0x0030 */ UEdGraphNode* GraphNode;
    /* 0x0038 */ UMaterialExpression* SubgraphExpression;
    /* 0x0050 */ FGuid MaterialExpressionGuid;
    /* 0x0060 */ UMaterial* Material;
    /* 0x0068 */ UMaterialFunction* Function;
    /* 0x0070 */ FString Desc;
    /* 0x0084 */ bool bRealtimePreview;
    /* 0x0084 */ bool bNeedToUpdatePreview;
    /* 0x0088 */ bool bIsParameterExpression;
    /* 0x008c */ bool bCommentBubbleVisible;
    /* 0x008c */ bool bShowOutputNameOnPin;
    /* 0x008c */ bool bShowMaskColorsOnPin;
    /* 0x008c */ bool bHidePreviewWindow;
    /* 0x008c */ bool bCollapsed;
    /* 0x008c */ bool bShaderInputData;
    /* 0x008c */ bool bShowInputs;
    /* 0x008c */ bool bShowOutputs;
    /* 0x0090 */ TArray<FText> MenuCategories;
    /* 0x00a0 */ TArray<FExpressionOutput> Outputs;
};

// Size: 0xd8
class UMaterialExpressionAbs : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionAbsorptionMediumMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput TransmittanceColor;
};

// Size: 0xb8
class UMaterialExpressionActorPositionWS : public UMaterialExpression {
    /* 0x00b0 */ EPositionOrigin OriginType;
};

// Size: 0x108
class UMaterialExpressionAdd : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0x230
class UMaterialExpressionAntialiasedTextureMask : public UMaterialExpressionTextureSampleParameter2D {
    /* 0x0228 */ float Threshold;
    /* 0x022c */ uint8_t Channel;
};

// Size: 0x100
class UMaterialExpressionAppendVector : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0xd8
class UMaterialExpressionArccosine : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionArccosineFast : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionArcsine : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionArcsineFast : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionArctangent : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x100
class UMaterialExpressionArctangent2 : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Y;
    /* 0x00d8 */ FExpressionInput X;
};

// Size: 0x100
class UMaterialExpressionArctangent2Fast : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Y;
    /* 0x00d8 */ FExpressionInput X;
};

// Size: 0xd8
class UMaterialExpressionArctangentFast : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xe0
class UMaterialExpressionAtmosphericFogColor : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldPosition;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
};

// Size: 0xc0
class UMaterialExpressionAtmosphericLightColor : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionAtmosphericLightVector : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionBentNormalCustomOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x100
class UMaterialExpressionBindlessSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Bindless;
};

// Size: 0xd8
class UMaterialExpressionBlackBody : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput temp;
};

// Size: 0x140
class UMaterialExpressionBlendMaterialAttributes : public UMaterialExpression {
    /* 0x00b0 */ FMaterialAttributesInput A;
    /* 0x00e0 */ FMaterialAttributesInput B;
    /* 0x0110 */ FExpressionInput Alpha;
    /* 0x0138 */ uint8_t PixelAttributeBlendType;
    /* 0x0139 */ uint8_t VertexAttributeBlendType;
};

// Size: 0xb8
class UMaterialExpressionBounds : public UMaterialExpression {
    /* 0x00b0 */ uint8_t Type;
};

// Size: 0xe0
class UMaterialExpressionBreakMaterialAttributes : public UMaterialExpression {
    /* 0x00b0 */ FMaterialAttributesInput MaterialAttributes;
};

// Size: 0x138
class UMaterialExpressionBumpOffset : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinate;
    /* 0x00d8 */ FExpressionInput Height;
    /* 0x0100 */ FExpressionInput HeightRatioInput;
    /* 0x0128 */ float HeightRatio;
    /* 0x012c */ float ReferencePlane;
    /* 0x0130 */ uint32_t ConstCoordinate;
};

// Size: 0xb0
class UMaterialExpressionCameraPositionWS : public UMaterialExpression {
};

// Size: 0xc0
class UMaterialExpressionCameraVectorWS : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionCeil : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x160
class UMaterialExpressionChannelMaskParameter : public UMaterialExpressionVectorParameter {
    /* 0x0130 */ uint8_t MaskChannel;
    /* 0x0138 */ FExpressionInput Input;
};

// Size: 0x138
class UMaterialExpressionClamp : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput min;
    /* 0x0100 */ FExpressionInput max;
    /* 0x0128 */ uint8_t ClampMode;
    /* 0x012c */ float MinDefault;
    /* 0x0130 */ float MaxDefault;
};

// Size: 0xd8
class UMaterialExpressionClearCoatNormalCustomOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xc0
class UMaterialExpressionCloudSampleAttribute : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x30
struct FMaterialExpressionCollection {
    /* 0x0000 */ TArray<UMaterialExpression*> Expressions;
    /* 0x0010 */ TArray<UMaterialExpressionComment*> EditorComments;
    /* 0x0020 */ UMaterialExpression* ExpressionExecBegin;
    /* 0x0028 */ UMaterialExpression* ExpressionExecEnd;
};

// Size: 0xd0
class UMaterialExpressionCollectionParameter : public UMaterialExpression {
    /* 0x00b0 */ UMaterialParameterCollection* Collection;
    /* 0x00b8 */ FName ParameterName;
    /* 0x00c0 */ FGuid ParameterId;
};

// Size: 0x100
class UMaterialExpressionCollectionTransform : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ UMaterialParameterCollection* Collection;
    /* 0x00e0 */ FName ParameterName;
    /* 0x00e8 */ FGuid ParameterId;
    /* 0x00f8 */ EParameterCollectionTransformType TransformType;
};

// Size: 0xe8
class UMaterialExpressionColorRamp : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ float ConstInput;
    /* 0x00e0 */ UCurveLinearColor* ColorCurve;
};

// Size: 0xe8
class UMaterialExpressionComment : public UMaterialExpression {
    /* 0x00b0 */ int32_t SizeX;
    /* 0x00b4 */ int32_t SizeY;
    /* 0x00b8 */ FString Text;
    /* 0x00c8 */ FLinearColor CommentColor;
    /* 0x00d8 */ int32_t FontSize;
    /* 0x00dc */ bool bCommentBubbleVisible_InDetailsPanel;
    /* 0x00dc */ bool bColorCommentBubble;
    /* 0x00e0 */ bool bGroupMode;
};

// Size: 0xe0
class UMaterialExpressionComponentMask : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ bool R;
    /* 0x00d8 */ bool G;
    /* 0x00d8 */ bool B;
    /* 0x00d8 */ bool A;
};

// Size: 0xd0
class UMaterialExpressionComposite : public UMaterialExpression {
    /* 0x00b0 */ FString SubgraphName;
    /* 0x00c0 */ UMaterialExpressionPinBase* InputExpressions;
    /* 0x00c8 */ UMaterialExpressionPinBase* OutputExpressions;
};

// Size: 0xb8
class UMaterialExpressionConstant : public UMaterialExpression {
    /* 0x00b0 */ float R;
};

// Size: 0xb8
class UMaterialExpressionConstant2Vector : public UMaterialExpression {
    /* 0x00b0 */ float R;
    /* 0x00b4 */ float G;
};

// Size: 0xc0
class UMaterialExpressionConstant3Vector : public UMaterialExpression {
    /* 0x00b0 */ FLinearColor Constant;
};

// Size: 0xc0
class UMaterialExpressionConstant4Vector : public UMaterialExpression {
    /* 0x00b0 */ FLinearColor Constant;
};

// Size: 0xe0
class UMaterialExpressionConstantBiasScale : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ float Bias;
    /* 0x00dc */ float Scale;
};

// Size: 0xb8
class UMaterialExpressionConstantDouble : public UMaterialExpressionGenericConstant {
    /* 0x00b0 */ double Value;
};

// Size: 0xf0
class UMaterialExpressionConvert : public UMaterialExpression {
    /* 0x00b0 */ TArray<FMaterialExpressionConvertInput> ConvertInputs;
    /* 0x00c0 */ TArray<FMaterialExpressionConvertOutput> ConvertOutputs;
    /* 0x00d0 */ TArray<FMaterialExpressionConvertMapping> ConvertMappings;
    /* 0x00e0 */ FString NodeName;
};

// Size: 0x40
struct FMaterialExpressionConvertInput {
    /* 0x0000 */ FExpressionInput ExpressionInput;
    /* 0x0028 */ EMaterialExpressionConvertType Type;
    /* 0x002c */ FLinearColor DefaultValue;
};

// Size: 0x10
struct FMaterialExpressionConvertMapping {
    /* 0x0000 */ int32_t InputIndex;
    /* 0x0004 */ int32_t InputComponentIndex;
    /* 0x0008 */ int32_t OutputIndex;
    /* 0x000c */ int32_t OutputComponentIndex;
};

// Size: 0x14
struct FMaterialExpressionConvertOutput {
    /* 0x0000 */ EMaterialExpressionConvertType Type;
    /* 0x0004 */ FLinearColor DefaultValue;
};

// Size: 0xe0
class UMaterialExpressionCosine : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ float Period;
};

// Size: 0x100
class UMaterialExpressionCrossProduct : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0x120
class UMaterialExpressionCurveAtlasRowParameter : public UMaterialExpressionScalarParameter {
    /* 0x00e8 */ UCurveLinearColor* Curve;
    /* 0x00f0 */ UCurveLinearColorAtlas* Atlas;
    /* 0x00f8 */ FExpressionInput InputTime;
};

// Size: 0x120
class UMaterialExpressionCustom : public UMaterialExpression {
    /* 0x00b0 */ FString Code;
    /* 0x00c0 */ uint8_t OutputType;
    /* 0x00c8 */ FString Description;
    /* 0x00d8 */ TArray<FCustomInput> Inputs;
    /* 0x00e8 */ TArray<FCustomOutput> AdditionalOutputs;
    /* 0x00f8 */ TArray<FCustomDefine> AdditionalDefines;
    /* 0x0108 */ TArray<FString> IncludeFilePaths;
    /* 0x0118 */ bool ShowCode;
};

// Size: 0xb0
class UMaterialExpressionCustomOutput : public UMaterialExpression {
};

// Size: 0xe0
class UMaterialExpressionDBufferTexture : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ uint8_t DBufferTextureId;
};

// Size: 0xd8
class UMaterialExpressionDDX : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Value;
};

// Size: 0xd8
class UMaterialExpressionDDY : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Value;
};

// Size: 0x118
class UMaterialExpressionDataDrivenShaderPlatformInfoSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput InputTrue;
    /* 0x00d8 */ FExpressionInput InputFalse;
    /* 0x0100 */ TArray<FDataDrivenShaderPlatformInfoInput> DDSPIPropertyNames;
    /* 0x0110 */ bool bContainsInvalidProperty;

    TArray<FString> GetNameOptions() const;
};

// Size: 0xc0
class UMaterialExpressionDecalColor : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb0
class UMaterialExpressionDecalDerivative : public UMaterialExpression {
};

// Size: 0xc0
class UMaterialExpressionDecalLifetimeOpacity : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xe0
class UMaterialExpressionDecalMipmapLevel : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput TextureSize;
    /* 0x00d8 */ float ConstWidth;
    /* 0x00dc */ float ConstHeight;
};

// Size: 0xc0
class UMaterialExpressionDeltaTime : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x108
class UMaterialExpressionDepthFade : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput InOpacity;
    /* 0x00d8 */ FExpressionInput FadeDistance;
    /* 0x0100 */ float OpacityDefault;
    /* 0x0104 */ float FadeDistanceDefault;
};

// Size: 0xe0
class UMaterialExpressionDepthOfFieldFunction : public UMaterialExpression {
    /* 0x00b0 */ uint8_t FunctionValue;
    /* 0x00b8 */ FExpressionInput Depth;
};

// Size: 0xd8
class UMaterialExpressionDeriveNormalZ : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput InXY;
};

// Size: 0x110
class UMaterialExpressionDesaturation : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput Fraction;
    /* 0x0100 */ FLinearColor LuminanceFactors;
};

// Size: 0x100
class UMaterialExpressionDistance : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0xb0
class UMaterialExpressionDistanceCullFade : public UMaterialExpression {
};

// Size: 0x170
class UMaterialExpressionDistanceFieldApproxAO : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00e0 */ FExpressionInput Normal;
    /* 0x0108 */ FExpressionInput BaseDistance;
    /* 0x0130 */ float BaseDistanceDefault;
    /* 0x0138 */ FExpressionInput Radius;
    /* 0x0160 */ float RadiusDefault;
    /* 0x0164 */ uint32_t NumSteps;
    /* 0x0168 */ float StepScaleDefault;
};

// Size: 0xe0
class UMaterialExpressionDistanceFieldGradient : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
};

// Size: 0x100
class UMaterialExpressionDistanceFieldsRenderingSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput No;
    /* 0x00d8 */ FExpressionInput Yes;
};

// Size: 0xe0
class UMaterialExpressionDistanceToNearestSurface : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
};

// Size: 0x108
class UMaterialExpressionDivide : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0x100
class UMaterialExpressionDotProduct : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0x100
class UMaterialExpressionDoubleVectorParameter : public UMaterialExpressionParameter {
    /* 0x00e0 */ FVector4d DefaultValue;
};

// Size: 0xd8
class UMaterialExpressionDynamicParameter : public UMaterialExpression {
    /* 0x00b0 */ TArray<FString> ParamNames;
    /* 0x00c0 */ FLinearColor DefaultValue;
    /* 0x00d0 */ uint32_t ParameterIndex;
};

// Size: 0xd8
class UMaterialExpressionExponential : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionExponential2 : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xc0
class UMaterialExpressionExternalCodeBase : public UMaterialExpression {
    /* 0x00b0 */ TArray<FName> ExternalCodeIdentifiers;
};

// Size: 0xc0
class UMaterialExpressionEyeAdaptation : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x110
class UMaterialExpressionEyeAdaptationInverse : public UMaterialExpressionExternalCodeBase {
    /* 0x00c0 */ FExpressionInput LightValueInput;
    /* 0x00e8 */ FExpressionInput AlphaInput;
};

// Size: 0x1a0
class UMaterialExpressionFeatureLevelSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Inputs[5];
};

// Size: 0xe0
class UMaterialExpressionFirstPersonOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput FirstPersonInterpolationAlpha;
    /* 0x00d8 */ float ConstFirstPersonInterpolationAlpha;
};

// Size: 0xe0
class UMaterialExpressionFloatToUInt : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ EFloatToIntMode Mode;
};

// Size: 0xd8
class UMaterialExpressionFloor : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x100
class UMaterialExpressionFmod : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0xc0
class UMaterialExpressionFontSample : public UMaterialExpression {
    /* 0x00b0 */ UFont* Font;
    /* 0x00b8 */ int32_t FontTexturePage;
};

// Size: 0xe8
class UMaterialExpressionFontSampleParameter : public UMaterialExpressionFontSample {
    /* 0x00c0 */ FName ParameterName;
    /* 0x00c8 */ FGuid ExpressionGUID;
    /* 0x00d8 */ FName Group;
    /* 0x00e0 */ int32_t SortPriority;
};

// Size: 0xc0
class UMaterialExpressionFontSignedDistance : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionFrac : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x138
class UMaterialExpressionFresnel : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput ExponentIn;
    /* 0x00d8 */ float Exponent;
    /* 0x00e0 */ FExpressionInput BaseReflectFractionIn;
    /* 0x0108 */ float BaseReflectFraction;
    /* 0x0110 */ FExpressionInput Normal;
};

// Size: 0x130
class UMaterialExpressionFunctionInput : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Preview;
    /* 0x00d8 */ FName InputName;
    /* 0x00e0 */ FString Description;
    /* 0x00f0 */ FGuid ID;
    /* 0x0100 */ uint8_t InputType;
    /* 0x0110 */ FVector4f PreviewValue;
    /* 0x0120 */ bool bUsePreviewValueAsDefault;
    /* 0x0124 */ int32_t SortPriority;
    /* 0x0128 */ bool bCompilingFunctionPreview;
};

// Size: 0x110
class UMaterialExpressionFunctionOutput : public UMaterialExpression {
    /* 0x00b0 */ FName OutputName;
    /* 0x00b8 */ FString Description;
    /* 0x00c8 */ int32_t SortPriority;
    /* 0x00d0 */ FExpressionInput A;
    /* 0x00f8 */ bool bLastPreviewed;
    /* 0x00fc */ FGuid ID;
};

// Size: 0x128
class UMaterialExpressionGIReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput StaticIndirect;
    /* 0x0100 */ FExpressionInput DynamicIndirect;
};

// Size: 0xb0
class UMaterialExpressionGenericConstant : public UMaterialExpression {
};

// Size: 0xf0
class UMaterialExpressionGetMaterialAttributes : public UMaterialExpression {
    /* 0x00b0 */ FMaterialAttributesInput MaterialAttributes;
    /* 0x00e0 */ TArray<FGuid> AttributeGetTypes;
};

// Size: 0xb8
class UMaterialExpressionHairAttributes : public UMaterialExpression {
    /* 0x00b0 */ bool bUseTangentSpace;
};

// Size: 0x128
class UMaterialExpressionHairColor : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Melanin;
    /* 0x00d8 */ FExpressionInput Redness;
    /* 0x0100 */ FExpressionInput DyeColor;
};

// Size: 0xd8
class UMaterialExpressionHsvToRgb : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x188
class UMaterialExpressionIf : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput AGreaterThanB;
    /* 0x0128 */ FExpressionInput AEqualsB;
    /* 0x0150 */ FExpressionInput ALessThanB;
    /* 0x0178 */ float EqualsThreshold;
    /* 0x017c */ float ConstB;
    /* 0x0180 */ float ConstAEqualsB;
};

// Size: 0x128
class UMaterialExpressionIfThenElse : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Condition;
    /* 0x00d8 */ FExpressionInput TRUE;
    /* 0x0100 */ FExpressionInput FALSE;
};

// Size: 0x138
class UMaterialExpressionInverseLinearInterpolate : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Value;
    /* 0x0128 */ float ConstA;
    /* 0x012c */ float ConstB;
    /* 0x0130 */ float ConstValue;
    /* 0x0134 */ bool bClampResult;
};

// Size: 0xc0
class UMaterialExpressionIsFirstPerson : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionIsOrthographic : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x1e8
class UMaterialExpressionLegacyBlendMaterialAttributes : public UMaterialExpressionBlendMaterialAttributes {
    /* 0x0140 */ FExpressionInput VertexAttribute_UseA;
    /* 0x0168 */ FExpressionInput VertexAttribute_UseB;
    /* 0x0190 */ FExpressionInput PixelAttribute_UseA;
    /* 0x01b8 */ FExpressionInput PixelAttribute_UseB;
    /* 0x01e0 */ uint8_t BlendFunctionType;
};

// Size: 0xd8
class UMaterialExpressionLength : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xc0
class UMaterialExpressionLightVector : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb0
class UMaterialExpressionLightmapUVs : public UMaterialExpression {
};

// Size: 0x100
class UMaterialExpressionLightmassReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Realtime;
    /* 0x00d8 */ FExpressionInput Lightmass;
};

// Size: 0x138
class UMaterialExpressionLinearInterpolate : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstA;
    /* 0x012c */ float ConstB;
    /* 0x0130 */ float ConstAlpha;
};

// Size: 0xb8
class UMaterialExpressionLocalPosition : public UMaterialExpression {
    /* 0x00b0 */ EPositionIncludedOffsets IncludedOffsets;
    /* 0x00b4 */ ELocalPositionOrigin LocalOrigin;
};

// Size: 0xd8
class UMaterialExpressionLogarithm : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionLogarithm10 : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput X;
};

// Size: 0xd8
class UMaterialExpressionLogarithm2 : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput X;
};

// Size: 0x4e8
class UMaterialExpressionMakeMaterialAttributes : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Metallic;
    /* 0x0100 */ FExpressionInput Specular;
    /* 0x0128 */ FExpressionInput Roughness;
    /* 0x0150 */ FExpressionInput Anisotropy;
    /* 0x0178 */ FExpressionInput EmissiveColor;
    /* 0x01a0 */ FExpressionInput Opacity;
    /* 0x01c8 */ FExpressionInput OpacityMask;
    /* 0x01f0 */ FExpressionInput Normal;
    /* 0x0218 */ FExpressionInput Tangent;
    /* 0x0240 */ FExpressionInput WorldPositionOffset;
    /* 0x0268 */ FExpressionInput SubsurfaceColor;
    /* 0x0290 */ FExpressionInput ClearCoat;
    /* 0x02b8 */ FExpressionInput ClearCoatRoughness;
    /* 0x02e0 */ FExpressionInput AmbientOcclusion;
    /* 0x0308 */ FExpressionInput Refraction;
    /* 0x0330 */ FExpressionInput CustomizedUVs[8];
    /* 0x0470 */ FExpressionInput PixelDepthOffset;
    /* 0x0498 */ FExpressionInput ShadingModel;
    /* 0x04c0 */ FExpressionInput Displacement;
};

// Size: 0xd8
class UMaterialExpressionMapARPassthroughCameraUV : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
};

// Size: 0x260
class UMaterialExpressionMaterialAttributeLayers : public UMaterialExpression {
    /* 0x00b0 */ FMaterialAttributesInput Input;
    /* 0x00e0 */ FMaterialLayersFunctions DefaultLayers;
    /* 0x0218 */ TArray<UMaterialExpressionMaterialFunctionCall*> LayerCallers;
    /* 0x0228 */ int32_t NumActiveLayerCallers;
    /* 0x0230 */ TArray<UMaterialExpressionMaterialFunctionCall*> BlendCallers;
    /* 0x0240 */ int32_t NumActiveBlendCallers;
    /* 0x0248 */ UMaterialExpressionMaterialFunctionCall* OutputCaller;
    /* 0x0250 */ bool bIsLayerGraphBuilt;
};

// Size: 0x100
class UMaterialExpressionMaterialCache : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Value;
    /* 0x00d8 */ FExpressionInput UV;
};

// Size: 0xe8
class UMaterialExpressionMaterialFunctionCall : public UMaterialExpression {
    /* 0x00b0 */ UMaterialFunctionInterface* MaterialFunction;
    /* 0x00b8 */ TArray<FFunctionExpressionInput> FunctionInputs;
    /* 0x00c8 */ TArray<FFunctionExpressionOutput> FunctionOutputs;
    /* 0x00d8 */ FMaterialParameterInfo FunctionParameterInfo;
};

// Size: 0x110
class UMaterialExpressionMaterialLayerOutput : public UMaterialExpressionFunctionOutput {
};

// Size: 0x100
class UMaterialExpressionMaterialProxyReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Realtime;
    /* 0x00d8 */ FExpressionInput MaterialProxy;
};

// Size: 0xb8
class UMaterialExpressionMaterialSample : public UMaterialExpression {
    /* 0x00b0 */ UMaterialInterface* MaterialReference;
};

// Size: 0x108
class UMaterialExpressionMax : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0xc0
class UMaterialExpressionMeshPaintTextureCoordinateIndex : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionMeshPaintTextureObject : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x100
class UMaterialExpressionMeshPaintTextureReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput MeshPaintTexture;
};

// Size: 0x108
class UMaterialExpressionMin : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0x100
class UMaterialExpressionModulo : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
};

// Size: 0x108
class UMaterialExpressionMultiply : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0xb0
class UMaterialExpressionNamedRerouteBase : public UMaterialExpressionRerouteBase {
};

// Size: 0x100
class UMaterialExpressionNamedRerouteDeclaration : public UMaterialExpressionNamedRerouteBase {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FName Name;
    /* 0x00e0 */ FLinearColor nodeColor;
    /* 0x00f0 */ FGuid VariableGuid;
};

// Size: 0xc8
class UMaterialExpressionNamedRerouteUsage : public UMaterialExpressionNamedRerouteBase {
    /* 0x00b0 */ UMaterialExpressionNamedRerouteDeclaration* Declaration;
    /* 0x00b8 */ FGuid DeclarationGuid;
};

// Size: 0x100
class UMaterialExpressionNaniteReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Nanite;
};

// Size: 0x130
class UMaterialExpressionNeuralNetworkInput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput Input0;
    /* 0x0100 */ FExpressionInput Mask;
    /* 0x0128 */ uint8_t NeuralIndexType;
};

// Size: 0xe0
class UMaterialExpressionNeuralNetworkOutput : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ uint8_t NeuralIndexType;
};

// Size: 0x130
class UMaterialExpressionNoise : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00e0 */ FExpressionInput FilterWidth;
    /* 0x0108 */ float Scale;
    /* 0x010c */ int32_t Quality;
    /* 0x0110 */ uint8_t NoiseFunction;
    /* 0x0114 */ bool bTurbulence;
    /* 0x0118 */ int32_t Levels;
    /* 0x011c */ float OutputMin;
    /* 0x0120 */ float OutputMax;
    /* 0x0124 */ float LevelScale;
    /* 0x0128 */ bool bTiling;
    /* 0x012c */ uint32_t RepeatSize;
};

// Size: 0xd8
class UMaterialExpressionNormalize : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput VectorInput;
};

// Size: 0xc0
class UMaterialExpressionObjectBounds : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb0
class UMaterialExpressionObjectLocalBounds : public UMaterialExpression {
};

// Size: 0xb0
class UMaterialExpressionObjectOrientation : public UMaterialExpression {
};

// Size: 0xb8
class UMaterialExpressionObjectPositionWS : public UMaterialExpression {
    /* 0x00b0 */ EPositionOrigin OriginType;
};

// Size: 0xc0
class UMaterialExpressionObjectRadius : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionOneMinus : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x140
class UMaterialExpressionOperator : public UMaterialExpression {
    /* 0x00b0 */ EMaterialExpressionOperatorKind Operator;
    /* 0x00b8 */ FExpressionInput A;
    /* 0x00e0 */ FExpressionInput B;
    /* 0x0108 */ FExpressionInput C;
    /* 0x0130 */ float ConstA;
    /* 0x0134 */ float ConstB;
    /* 0x0138 */ float ConstC;
};

// Size: 0x138
class UMaterialExpressionPanner : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinate;
    /* 0x00d8 */ FExpressionInput Time;
    /* 0x0100 */ FExpressionInput Speed;
    /* 0x0128 */ float SpeedX;
    /* 0x012c */ float SpeedY;
    /* 0x0130 */ uint32_t ConstCoordinate;
    /* 0x0134 */ bool bFractionalPart;
};

// Size: 0xd8
class UMaterialExpressionParameter : public UMaterialExpression {
    /* 0x00b0 */ FName ParameterName;
    /* 0x00b8 */ FGuid ExpressionGUID;
    /* 0x00c8 */ FName Group;
    /* 0x00d0 */ int32_t SortPriority;
};

// Size: 0xc0
class UMaterialExpressionParticleColor : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleDirection : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleMacroUV : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleMotionBlurFade : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb8
class UMaterialExpressionParticlePositionWS : public UMaterialExpression {
    /* 0x00b0 */ EPositionOrigin OriginType;
};

// Size: 0xb0
class UMaterialExpressionParticleRadius : public UMaterialExpression {
};

// Size: 0xc0
class UMaterialExpressionParticleRandom : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleRelativeTime : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleSize : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleSpeed : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionParticleSpriteRotation : public UMaterialExpressionExternalCodeBase {
};

// Size: 0x208
class UMaterialExpressionParticleSubUV : public UMaterialExpressionTextureSample {
    /* 0x0200 */ bool bBlend;
};

// Size: 0xc0
class UMaterialExpressionParticleSubUVProperties : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xe0
class UMaterialExpressionPathTracingBufferTexture : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ uint8_t PathTracingBufferTextureId;
};

// Size: 0x100
class UMaterialExpressionPathTracingQualitySwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Normal;
    /* 0x00d8 */ FExpressionInput PathTraced;
};

// Size: 0x178
class UMaterialExpressionPathTracingRayTypeSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Main;
    /* 0x00d8 */ FExpressionInput Shadow;
    /* 0x0100 */ FExpressionInput IndirectDiffuse;
    /* 0x0128 */ FExpressionInput IndirectSpecular;
    /* 0x0150 */ FExpressionInput IndirectVolume;
};

// Size: 0xe0
class UMaterialExpressionPerInstanceCustomData : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput DefaultValue;
    /* 0x00d8 */ float ConstDefaultValue;
    /* 0x00dc */ uint32_t DataIndex;
};

// Size: 0xf0
class UMaterialExpressionPerInstanceCustomData3Vector : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput DefaultValue;
    /* 0x00d8 */ FLinearColor ConstDefaultValue;
    /* 0x00e8 */ uint32_t DataIndex;
};

// Size: 0xc0
class UMaterialExpressionPerInstanceFadeAmount : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionPerInstanceRandom : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc8
class UMaterialExpressionPinBase : public UMaterialExpression {
    /* 0x00b0 */ TArray<FCompositeReroute> ReroutePins;
    /* 0x00c0 */ uint8_t PinDirection;
};

// Size: 0xc0
class UMaterialExpressionPixelDepth : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb0
class UMaterialExpressionPixelNormalWS : public UMaterialExpression {
};

// Size: 0xe0
class UMaterialExpressionPostVolumeUserFlagTest : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput BitIndex;
    /* 0x00d8 */ int32_t ConstBitIndex;
};

// Size: 0x108
class UMaterialExpressionPower : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput base;
    /* 0x00d8 */ FExpressionInput Exponent;
    /* 0x0100 */ float ConstExponent;
};

// Size: 0xb0
class UMaterialExpressionPreSkinnedLocalBounds : public UMaterialExpression {
};

// Size: 0xc0
class UMaterialExpressionPreSkinnedNormal : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionPreSkinnedPosition : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb0
class UMaterialExpressionPrecomputedAOMask : public UMaterialExpression {
};

// Size: 0x100
class UMaterialExpressionPreviousFrameSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput CurrentFrame;
    /* 0x00d8 */ FExpressionInput PreviousFrame;
};

// Size: 0x178
class UMaterialExpressionQualitySwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Inputs[4];
};

// Size: 0x100
class UMaterialExpressionRayTracingQualitySwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Normal;
    /* 0x00d8 */ FExpressionInput RayTraced;
};

// Size: 0x100
class UMaterialExpressionRecordTextureStreamingInfo : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput TextureObject;
    /* 0x00d8 */ FExpressionInput Coordinates;
};

// Size: 0x100
class UMaterialExpressionReflectionCapturePassSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Reflection;
};

// Size: 0xe0
class UMaterialExpressionReflectionVectorWS : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput CustomWorldNormal;
    /* 0x00d8 */ bool bNormalizeCustomWorldNormal;
};

// Size: 0x108
class UMaterialExpressionRequiredSamplersSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput InputTrue;
    /* 0x00d8 */ FExpressionInput InputFalse;
    /* 0x0100 */ uint32_t RequiredSamplers;
};

// Size: 0xd8
class UMaterialExpressionReroute : public UMaterialExpressionRerouteBase {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xb0
class UMaterialExpressionRerouteBase : public UMaterialExpression {
};

// Size: 0xd8
class UMaterialExpressionRgbToHsv : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x158
class UMaterialExpressionRotateAboutAxis : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput NormalizedRotationAxis;
    /* 0x00d8 */ FExpressionInput RotationAngle;
    /* 0x0100 */ FExpressionInput PivotPoint;
    /* 0x0128 */ FExpressionInput position;
    /* 0x0150 */ float Period;
};

// Size: 0x110
class UMaterialExpressionRotator : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinate;
    /* 0x00d8 */ FExpressionInput Time;
    /* 0x0100 */ float CenterX;
    /* 0x0104 */ float CenterY;
    /* 0x0108 */ float Speed;
    /* 0x010c */ uint32_t ConstCoordinate;
};

// Size: 0xd8
class UMaterialExpressionRound : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xb0
class UMaterialExpressionRuntimeVirtualTextureCustomData : public UMaterialExpression {
};

// Size: 0x218
class UMaterialExpressionRuntimeVirtualTextureOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Specular;
    /* 0x0100 */ FExpressionInput Roughness;
    /* 0x0128 */ FExpressionInput Normal;
    /* 0x0150 */ FExpressionInput WorldHeight;
    /* 0x0178 */ FExpressionInput Opacity;
    /* 0x01a0 */ FExpressionInput Mask;
    /* 0x01c8 */ FExpressionInput Displacement;
    /* 0x01f0 */ FExpressionInput Mask4;
};

// Size: 0x100
class UMaterialExpressionRuntimeVirtualTextureReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput VirtualTextureOutput;
};

// Size: 0x188
class UMaterialExpressionRuntimeVirtualTextureSample : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput WorldPosition;
    /* 0x0100 */ FExpressionInput MipValue;
    /* 0x0128 */ FExpressionInput DDX;
    /* 0x0150 */ FExpressionInput DDY;
    /* 0x0178 */ URuntimeVirtualTexture* VirtualTexture;
    /* 0x0180 */ ERuntimeVirtualTextureMaterialType MaterialType;
    /* 0x0181 */ bool bSinglePhysicalSpace;
    /* 0x0182 */ bool bAdaptive;
    /* 0x0183 */ EPositionOrigin WorldPositionOriginType;
    /* 0x0184 */ uint8_t TextureAddressMode;
    /* 0x0185 */ uint8_t MipValueMode;
    /* 0x0186 */ bool bEnableFeedback;
};

// Size: 0x1b0
class UMaterialExpressionRuntimeVirtualTextureSampleParameter : public UMaterialExpressionRuntimeVirtualTextureSample {
    /* 0x0188 */ FName ParameterName;
    /* 0x0190 */ FGuid ExpressionGUID;
    /* 0x01a0 */ FName Group;
    /* 0x01a8 */ int32_t SortPriority;
};

// Size: 0xd8
class UMaterialExpressionSRGBColorToWorkingColorSpace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xe0
class UMaterialExpressionSamplePhysicsIntegerField : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldPosition;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00d9 */ uint8_t FieldTarget;
};

// Size: 0xe0
class UMaterialExpressionSamplePhysicsScalarField : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldPosition;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00d9 */ uint8_t FieldTarget;
};

// Size: 0xe0
class UMaterialExpressionSamplePhysicsVectorField : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldPosition;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00d9 */ uint8_t FieldTarget;
};

// Size: 0xd8
class UMaterialExpressionSaturate : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xb0
class UMaterialExpressionScalarBlueNoise : public UMaterialExpression {
};

// Size: 0xe8
class UMaterialExpressionScalarParameter : public UMaterialExpressionParameter {
    /* 0x00d8 */ float DefaultValue;
    /* 0x00dc */ bool bUseCustomPrimitiveData;
    /* 0x00dd */ uint8_t PrimitiveDataIndex;
    /* 0x00e0 */ float SliderMin;
    /* 0x00e4 */ float SliderMax;
};

// Size: 0x118
class UMaterialExpressionSceneColor : public UMaterialExpression {
    /* 0x00b0 */ uint8_t InputMode;
    /* 0x00b8 */ FExpressionInput Input;
    /* 0x00e0 */ FExpressionInput OffsetFraction;
    /* 0x0108 */ FVector2D ConstInput;
};

// Size: 0x118
class UMaterialExpressionSceneDepth : public UMaterialExpression {
    /* 0x00b0 */ uint8_t InputMode;
    /* 0x00b8 */ FExpressionInput Input;
    /* 0x00e0 */ FExpressionInput Coordinates;
    /* 0x0108 */ FVector2D ConstInput;
};

// Size: 0xf8
class UMaterialExpressionSceneDepthWithoutWater : public UMaterialExpression {
    /* 0x00b0 */ uint8_t InputMode;
    /* 0x00b8 */ FExpressionInput Input;
    /* 0x00e0 */ FVector2D ConstInput;
    /* 0x00f0 */ float FallbackDepth;
};

// Size: 0xb0
class UMaterialExpressionSceneTexelSize : public UMaterialExpression {
};

// Size: 0xe0
class UMaterialExpressionSceneTexture : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ uint8_t SceneTextureId;
    /* 0x00d9 */ bool bFiltered;
};

// Size: 0xc0
class UMaterialExpressionScreenPosition : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd0
class UMaterialExpressionSetMaterialAttributes : public UMaterialExpression {
    /* 0x00b0 */ TArray<FExpressionInput> Inputs;
    /* 0x00c0 */ TArray<FGuid> AttributeSetTypes;
};

// Size: 0x100
class UMaterialExpressionShaderStageSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput PixelShader;
    /* 0x00d8 */ FExpressionInput VertexShader;
};

// Size: 0xb8
class UMaterialExpressionShadingModel : public UMaterialExpression {
    /* 0x00b0 */ uint8_t ShadingModel;
};

// Size: 0x150
class UMaterialExpressionShadingPathSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Inputs[3];
};

// Size: 0x100
class UMaterialExpressionShadowReplace : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Default;
    /* 0x00d8 */ FExpressionInput Shadow;
};

// Size: 0xd8
class UMaterialExpressionSign : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xe0
class UMaterialExpressionSine : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ float Period;
};

// Size: 0x150
class UMaterialExpressionSingleLayerWaterMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput ScatteringCoefficients;
    /* 0x00d8 */ FExpressionInput AbsorptionCoefficients;
    /* 0x0100 */ FExpressionInput PhaseG;
    /* 0x0128 */ FExpressionInput ColorScaleBehindWater;
};

// Size: 0xe0
class UMaterialExpressionSkyAtmosphereAerialPerspective : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldPosition;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
};

// Size: 0xb0
class UMaterialExpressionSkyAtmosphereDistantLightScatteredLuminance : public UMaterialExpression {
};

// Size: 0xb8
class UMaterialExpressionSkyAtmosphereLightDirection : public UMaterialExpression {
    /* 0x00b0 */ int32_t LightIndex;
};

// Size: 0xe0
class UMaterialExpressionSkyAtmosphereLightDiskLuminance : public UMaterialExpression {
    /* 0x00b0 */ int32_t LightIndex;
    /* 0x00b8 */ FExpressionInput DiskAngularDiameterOverride;
};

// Size: 0xe8
class UMaterialExpressionSkyAtmosphereLightIlluminance : public UMaterialExpression {
    /* 0x00b0 */ int32_t LightIndex;
    /* 0x00b8 */ FExpressionInput WorldPosition;
    /* 0x00e0 */ EPositionOrigin WorldPositionOriginType;
};

// Size: 0xb8
class UMaterialExpressionSkyAtmosphereLightIlluminanceOnGround : public UMaterialExpression {
    /* 0x00b0 */ int32_t LightIndex;
};

// Size: 0xd8
class UMaterialExpressionSkyAtmosphereViewLuminance : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput WorldDirection;
};

// Size: 0x100
class UMaterialExpressionSkyLightEnvMapSample : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Direction;
    /* 0x00d8 */ FExpressionInput Roughness;
};

// Size: 0x138
class UMaterialExpressionSmoothStep : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput min;
    /* 0x00d8 */ FExpressionInput max;
    /* 0x0100 */ FExpressionInput Value;
    /* 0x0128 */ float ConstMin;
    /* 0x012c */ float ConstMax;
    /* 0x0130 */ float ConstValue;
};

// Size: 0x140
class UMaterialExpressionSobol : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput cell;
    /* 0x00d8 */ FExpressionInput Index;
    /* 0x0100 */ FExpressionInput Seed;
    /* 0x0128 */ uint32_t ConstIndex;
    /* 0x0130 */ FVector2D ConstSeed;
};

// Size: 0xb8
class UMaterialExpressionSparseVolumeTextureBase : public UMaterialExpression {
    /* 0x00b0 */ USparseVolumeTexture* SparseVolumeTexture;
};

// Size: 0xb8
class UMaterialExpressionSparseVolumeTextureObject : public UMaterialExpressionSparseVolumeTextureBase {
};

// Size: 0x1b0
class UMaterialExpressionSparseVolumeTextureObjectParameter : public UMaterialExpressionSparseVolumeTextureSampleParameter {
};

// Size: 0x188
class UMaterialExpressionSparseVolumeTextureSample : public UMaterialExpressionSparseVolumeTextureBase {
    /* 0x00b8 */ FExpressionInput Coordinates;
    /* 0x00e0 */ FExpressionInput TextureObject;
    /* 0x0108 */ FExpressionInput MipValue;
    /* 0x0130 */ FExpressionInput CoordinatesDX;
    /* 0x0158 */ FExpressionInput CoordinatesDY;
    /* 0x0180 */ uint8_t MipValueMode;
    /* 0x0181 */ uint8_t SamplerSource;
    /* 0x0184 */ int32_t ConstMipValue;
};

// Size: 0x1b0
class UMaterialExpressionSparseVolumeTextureSampleParameter : public UMaterialExpressionSparseVolumeTextureSample {
    /* 0x0188 */ FName ParameterName;
    /* 0x0190 */ FGuid ExpressionGUID;
    /* 0x01a0 */ FName Group;
    /* 0x01a8 */ int32_t SortPriority;
};

// Size: 0x160
class UMaterialExpressionSpeedTree : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput GeometryInput;
    /* 0x00d8 */ FExpressionInput WindInput;
    /* 0x0100 */ FExpressionInput LODInput;
    /* 0x0128 */ FExpressionInput ExtraBendWS;
    /* 0x0150 */ uint8_t GeometryType;
    /* 0x0151 */ uint8_t WindType;
    /* 0x0152 */ uint8_t LODType;
    /* 0x0154 */ float BillboardThreshold;
    /* 0x0158 */ bool bAccurateWindVelocities;
};

// Size: 0x158
class UMaterialExpressionSphereMask : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Radius;
    /* 0x0128 */ FExpressionInput Hardness;
    /* 0x0150 */ float AttenuationRadius;
    /* 0x0154 */ float HardnessPercent;
};

// Size: 0xf0
class UMaterialExpressionSphericalParticleOpacity : public UMaterialExpressionExternalCodeBase {
    /* 0x00c0 */ FExpressionInput Density;
    /* 0x00e8 */ float ConstantDensity;
};

// Size: 0xd8
class UMaterialExpressionSquareRoot : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xb8
class UMaterialExpressionStaticBool : public UMaterialExpression {
    /* 0x00b0 */ bool Value;
};

// Size: 0xe0
class UMaterialExpressionStaticBoolParameter : public UMaterialExpressionParameter {
    /* 0x00d8 */ bool DefaultValue;
    /* 0x00d8 */ bool DynamicBranch;
};

// Size: 0x108
class UMaterialExpressionStaticComponentMaskParameter : public UMaterialExpressionParameter {
    /* 0x00d8 */ FExpressionInput Input;
    /* 0x0100 */ bool DefaultR;
    /* 0x0100 */ bool DefaultG;
    /* 0x0100 */ bool DefaultB;
    /* 0x0100 */ bool DefaultA;
};

// Size: 0x130
class UMaterialExpressionStaticSwitch : public UMaterialExpression {
    /* 0x00b0 */ bool DefaultValue;
    /* 0x00b8 */ FExpressionInput A;
    /* 0x00e0 */ FExpressionInput B;
    /* 0x0108 */ FExpressionInput Value;
};

// Size: 0x130
class UMaterialExpressionStaticSwitchParameter : public UMaterialExpressionStaticBoolParameter {
    /* 0x00e0 */ FExpressionInput A;
    /* 0x0108 */ FExpressionInput B;
};

// Size: 0x108
class UMaterialExpressionStep : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Y;
    /* 0x00d8 */ FExpressionInput X;
    /* 0x0100 */ float ConstY;
    /* 0x0104 */ float ConstX;
};

// Size: 0x108
class UMaterialExpressionSubstrateAdd : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ bool bUseParameterBlending;
};

// Size: 0xb0
class UMaterialExpressionSubstrateBSDF : public UMaterialExpression {
};

// Size: 0x190
class UMaterialExpressionSubstrateConvertMaterialAttributes : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FMaterialAttributesInput MaterialAttributes;
    /* 0x00e0 */ FExpressionInput WaterScatteringCoefficients;
    /* 0x0108 */ FExpressionInput WaterAbsorptionCoefficients;
    /* 0x0130 */ FExpressionInput WaterPhaseG;
    /* 0x0158 */ FExpressionInput ColorScaleBehindWater;
    /* 0x0180 */ USubsurfaceProfile* SubsurfaceProfile;
    /* 0x0188 */ uint8_t ShadingModelOverride;
};

// Size: 0x100
class UMaterialExpressionSubstrateConvertToDecal : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput DecalMaterial;
    /* 0x00d8 */ FExpressionInput Coverage;
};

// Size: 0x1f8
class UMaterialExpressionSubstrateEyeBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput DiffuseColor;
    /* 0x00d8 */ FExpressionInput Roughness;
    /* 0x0100 */ FExpressionInput CorneaNormal;
    /* 0x0128 */ FExpressionInput IrisNormal;
    /* 0x0150 */ FExpressionInput IrisPlaneNormal;
    /* 0x0178 */ FExpressionInput IrisMask;
    /* 0x01a0 */ FExpressionInput IrisDistance;
    /* 0x01c8 */ FExpressionInput EmissiveColor;
    /* 0x01f0 */ USubsurfaceProfile* SubsurfaceProfile;
};

// Size: 0x1c8
class UMaterialExpressionSubstrateHairBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Scatter;
    /* 0x0100 */ FExpressionInput Specular;
    /* 0x0128 */ FExpressionInput Roughness;
    /* 0x0150 */ FExpressionInput Backlit;
    /* 0x0178 */ FExpressionInput Tangent;
    /* 0x01a0 */ FExpressionInput EmissiveColor;
};

// Size: 0x100
class UMaterialExpressionSubstrateHazinessToSecondaryRoughness : public UMaterialExpressionSubstrateUtilityBase {
    /* 0x00b0 */ FExpressionInput BaseRoughness;
    /* 0x00d8 */ FExpressionInput Haziness;
};

// Size: 0x130
class UMaterialExpressionSubstrateHorizontalMixing : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Background;
    /* 0x00d8 */ FExpressionInput Foreground;
    /* 0x0100 */ FExpressionInput Mix;
    /* 0x0128 */ bool bUseParameterBlending;
};

// Size: 0xd8
class UMaterialExpressionSubstrateLightFunction : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Color;
};

// Size: 0x128
class UMaterialExpressionSubstrateMetalnessToDiffuseAlbedoF0 : public UMaterialExpressionSubstrateUtilityBase {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Metallic;
    /* 0x0100 */ FExpressionInput Specular;
};

// Size: 0x100
class UMaterialExpressionSubstratePostProcess : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Color;
    /* 0x00d8 */ FExpressionInput Opacity;
};

// Size: 0x130
class UMaterialExpressionSubstrateSelect : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput SelectValue;
    /* 0x0128 */ float Threshold;
};

// Size: 0x410
class UMaterialExpressionSubstrateShadingModels : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Metallic;
    /* 0x0100 */ FExpressionInput Specular;
    /* 0x0128 */ FExpressionInput Roughness;
    /* 0x0150 */ FExpressionInput Anisotropy;
    /* 0x0178 */ FExpressionInput EmissiveColor;
    /* 0x01a0 */ FExpressionInput Normal;
    /* 0x01c8 */ FExpressionInput Tangent;
    /* 0x01f0 */ FExpressionInput SubsurfaceColor;
    /* 0x0218 */ FExpressionInput ClearCoat;
    /* 0x0240 */ FExpressionInput ClearCoatRoughness;
    /* 0x0268 */ FExpressionInput Opacity;
    /* 0x0290 */ FExpressionInput TransmittanceColor;
    /* 0x02b8 */ FExpressionInput WaterScatteringCoefficients;
    /* 0x02e0 */ FExpressionInput WaterAbsorptionCoefficients;
    /* 0x0308 */ FExpressionInput WaterPhaseG;
    /* 0x0330 */ FExpressionInput ColorScaleBehindWater;
    /* 0x0358 */ FExpressionInput ClearCoatNormal;
    /* 0x0380 */ FExpressionInput CustomTangent;
    /* 0x03a8 */ FShadingModelMaterialInput ShadingModel;
    /* 0x03d8 */ FExpressionInput ThinTranslucentSurfaceCoverage;
    /* 0x0400 */ uint8_t ShadingModelOverride;
    /* 0x0408 */ USubsurfaceProfile* SubsurfaceProfile;
};

// Size: 0x1f0
class UMaterialExpressionSubstrateSimpleClearCoatBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput DiffuseAlbedo;
    /* 0x00d8 */ FExpressionInput F0;
    /* 0x0100 */ FExpressionInput Roughness;
    /* 0x0128 */ FExpressionInput ClearCoatCoverage;
    /* 0x0150 */ FExpressionInput ClearCoatRoughness;
    /* 0x0178 */ FExpressionInput Normal;
    /* 0x01a0 */ FExpressionInput EmissiveColor;
    /* 0x01c8 */ FExpressionInput BottomNormal;
};

// Size: 0x268
class UMaterialExpressionSubstrateSingleLayerWaterBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput BaseColor;
    /* 0x00d8 */ FExpressionInput Metallic;
    /* 0x0100 */ FExpressionInput Specular;
    /* 0x0128 */ FExpressionInput Roughness;
    /* 0x0150 */ FExpressionInput Normal;
    /* 0x0178 */ FExpressionInput EmissiveColor;
    /* 0x01a0 */ FExpressionInput TopMaterialOpacity;
    /* 0x01c8 */ FExpressionInput WaterAlbedo;
    /* 0x01f0 */ FExpressionInput WaterExtinction;
    /* 0x0218 */ FExpressionInput WaterPhaseG;
    /* 0x0240 */ FExpressionInput ColorScaleBehindWater;
};

// Size: 0x398
class UMaterialExpressionSubstrateSlabBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput DiffuseAlbedo;
    /* 0x00d8 */ FExpressionInput F0;
    /* 0x0100 */ FExpressionInput F90;
    /* 0x0128 */ FExpressionInput Roughness;
    /* 0x0150 */ FExpressionInput Anisotropy;
    /* 0x0178 */ FExpressionInput Normal;
    /* 0x01a0 */ FExpressionInput Tangent;
    /* 0x01c8 */ FExpressionInput SSSMFP;
    /* 0x01f0 */ FExpressionInput SSSMFPScale;
    /* 0x0218 */ FExpressionInput SSSPhaseAnisotropy;
    /* 0x0240 */ FExpressionInput EmissiveColor;
    /* 0x0268 */ FExpressionInput SecondRoughness;
    /* 0x0290 */ FExpressionInput SecondRoughnessWeight;
    /* 0x02b8 */ FExpressionInput FuzzRoughness;
    /* 0x02e0 */ FExpressionInput FuzzAmount;
    /* 0x0308 */ FExpressionInput FuzzColor;
    /* 0x0330 */ FExpressionInput GlintValue;
    /* 0x0358 */ FExpressionInput GlintUV;
    /* 0x0380 */ USubsurfaceProfile* SubsurfaceProfile;
    /* 0x0388 */ USpecularProfile* SpecularProfile;
    /* 0x0390 */ bool bUseSSSDiffusion;
    /* 0x0394 */ uint8_t SubSurfaceType;
};

// Size: 0x178
class UMaterialExpressionSubstrateThinFilm : public UMaterialExpressionSubstrateUtilityBase {
    /* 0x00b0 */ FExpressionInput Normal;
    /* 0x00d8 */ FExpressionInput F0;
    /* 0x0100 */ FExpressionInput F90;
    /* 0x0128 */ FExpressionInput Thickness;
    /* 0x0150 */ FExpressionInput IOR;
};

// Size: 0x100
class UMaterialExpressionSubstrateTransmittanceToMFP : public UMaterialExpressionSubstrateUtilityBase {
    /* 0x00b0 */ FExpressionInput TransmittanceColor;
    /* 0x00d8 */ FExpressionInput Thickness;
};

// Size: 0x100
class UMaterialExpressionSubstrateUI : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Color;
    /* 0x00d8 */ FExpressionInput Opacity;
};

// Size: 0x128
class UMaterialExpressionSubstrateUnlitBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput EmissiveColor;
    /* 0x00d8 */ FExpressionInput TransmittanceColor;
    /* 0x0100 */ FExpressionInput Normal;
};

// Size: 0xb0
class UMaterialExpressionSubstrateUtilityBase : public UMaterialExpression {
};

// Size: 0x130
class UMaterialExpressionSubstrateVerticalLayering : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Top;
    /* 0x00d8 */ FExpressionInput base;
    /* 0x0100 */ FExpressionInput Thickness;
    /* 0x0128 */ bool bUseParameterBlending;
};

// Size: 0x158
class UMaterialExpressionSubstrateVolumetricFogCloudBSDF : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput Albedo;
    /* 0x00d8 */ FExpressionInput Extinction;
    /* 0x0100 */ FExpressionInput EmissiveColor;
    /* 0x0128 */ FExpressionInput AmbientOcclusion;
    /* 0x0150 */ bool bEmissiveOnly;
};

// Size: 0x100
class UMaterialExpressionSubstrateWeight : public UMaterialExpressionSubstrateBSDF {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput Weight;
};

// Size: 0x100
class UMaterialExpressionSubsurfaceMediumMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput MeanFreePath;
    /* 0x00d8 */ FExpressionInput ScatteringDistribution;
};

// Size: 0x108
class UMaterialExpressionSubtract : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstA;
    /* 0x0104 */ float ConstB;
};

// Size: 0x130
class UMaterialExpressionSwitch : public UMaterialExpression {
    /* 0x00b0 */ FString Description;
    /* 0x00c0 */ FExpressionInput SwitchValue;
    /* 0x00e8 */ float ConstSwitchValue;
    /* 0x00f0 */ FExpressionInput Default;
    /* 0x0118 */ float ConstDefault;
    /* 0x0120 */ TArray<FSwitchCustomInput> Inputs;
};

// Size: 0xe0
class UMaterialExpressionTangent : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ float Period;
};

// Size: 0xd8
class UMaterialExpressionTangentOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x118
class UMaterialExpressionTemporalSobol : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Index;
    /* 0x00d8 */ FExpressionInput Seed;
    /* 0x0100 */ uint32_t ConstIndex;
    /* 0x0108 */ FVector2D ConstSeed;
};

// Size: 0xc0
class UMaterialExpressionTextureBase : public UMaterialExpression {
    /* 0x00b0 */ UTexture* Texture;
    /* 0x00b8 */ uint8_t SamplerType;
    /* 0x00b9 */ bool IsDefaultMeshpaintTexture;
};

// Size: 0xb8
class UMaterialExpressionTextureCollection : public UMaterialExpression {
    /* 0x00b0 */ UTextureCollection* TextureCollection;
};

// Size: 0xe0
class UMaterialExpressionTextureCollectionParameter : public UMaterialExpressionTextureCollection {
    /* 0x00b8 */ FName ParameterName;
    /* 0x00c0 */ FGuid ExpressionGUID;
    /* 0x00d0 */ FName Group;
    /* 0x00d8 */ int32_t SortPriority;
};

// Size: 0xc0
class UMaterialExpressionTextureCoordinate : public UMaterialExpression {
    /* 0x00b0 */ int32_t CoordinateIndex;
    /* 0x00b4 */ float UTiling;
    /* 0x00b8 */ float VTiling;
    /* 0x00bc */ bool UnMirrorU;
    /* 0x00bc */ bool UnMirrorV;
};

// Size: 0xc0
class UMaterialExpressionTextureObject : public UMaterialExpressionTextureBase {
};

// Size: 0x110
class UMaterialExpressionTextureObjectFromCollection : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput TextureCollection;
    /* 0x00d8 */ UTextureCollection* TextureCollectionObject;
    /* 0x00e0 */ FExpressionInput CollectionIndex;
    /* 0x0108 */ int32_t ConstCollectionIndex;
    /* 0x010c */ ETextureCollectionMemberType TextureType;
};

// Size: 0x228
class UMaterialExpressionTextureObjectParameter : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0xe0
class UMaterialExpressionTextureProperty : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput TextureObject;
    /* 0x00d8 */ uint8_t Property;
};

// Size: 0x200
class UMaterialExpressionTextureSample : public UMaterialExpressionTextureBase {
    /* 0x00c0 */ FExpressionInput Coordinates;
    /* 0x00e8 */ FExpressionInput TextureObject;
    /* 0x0110 */ FExpressionInput MipValue;
    /* 0x0138 */ FExpressionInput CoordinatesDX;
    /* 0x0160 */ FExpressionInput CoordinatesDY;
    /* 0x0188 */ FExpressionInput AutomaticViewMipBiasValue;
    /* 0x01b0 */ uint8_t MipValueMode;
    /* 0x01b1 */ uint8_t SamplerSource;
    /* 0x01b2 */ uint8_t GatherMode;
    /* 0x01b3 */ bool AutomaticViewMipBias;
    /* 0x01b8 */ FParameterChannelNames ChannelNames;
    /* 0x01f9 */ uint8_t ConstCoordinate;
    /* 0x01fc */ int32_t ConstMipValue;
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameter : public UMaterialExpressionTextureSample {
    /* 0x0200 */ FName ParameterName;
    /* 0x0208 */ FGuid ExpressionGUID;
    /* 0x0218 */ FName Group;
    /* 0x0220 */ int32_t SortPriority;
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameter2D : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameter2DArray : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameterCube : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameterCubeArray : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0x230
class UMaterialExpressionTextureSampleParameterSubUV : public UMaterialExpressionTextureSampleParameter2D {
    /* 0x0228 */ bool bBlend;
};

// Size: 0x228
class UMaterialExpressionTextureSampleParameterVolume : public UMaterialExpressionTextureSampleParameter {
};

// Size: 0x100
class UMaterialExpressionThinTranslucentMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput TransmittanceColor;
    /* 0x00d8 */ FExpressionInput SurfaceCoverage;
};

// Size: 0xb8
class UMaterialExpressionTime : public UMaterialExpression {
    /* 0x00b0 */ bool bIgnorePause;
    /* 0x00b0 */ bool bOverride_Period;
    /* 0x00b4 */ float Period;
};

// Size: 0xe0
class UMaterialExpressionTransform : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ uint8_t TransformSourceType;
    /* 0x00d9 */ uint8_t TransformType;
};

// Size: 0x140
class UMaterialExpressionTransformPosition : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ uint8_t TransformSourceType;
    /* 0x00d9 */ uint8_t TransformType;
    /* 0x00e0 */ FExpressionInput PeriodicWorldTileSize;
    /* 0x0108 */ FExpressionInput FirstPersonInterpolationAlpha;
    /* 0x0130 */ float ConstPeriodicWorldTileSize;
    /* 0x0134 */ float ConstFirstPersonInterpolationAlpha;
    /* 0x0138 */ bool bUsesPeriodicWorldPosition;
    /* 0x0139 */ bool bUsesFirstPersonInterpolationAlpha;
};

// Size: 0xd8
class UMaterialExpressionTruncate : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xd8
class UMaterialExpressionTruncateLWC : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xc0
class UMaterialExpressionTwoSidedSign : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionUIntToFloat : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xe8
class UMaterialExpressionUserSceneTexture : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FName UserSceneTexture;
    /* 0x00e0 */ bool bFiltered;
    /* 0x00e1 */ bool bClamped;
};

// Size: 0xe8
class UMaterialExpressionVectorNoise : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ EPositionOrigin WorldPositionOriginType;
    /* 0x00d9 */ uint8_t NoiseFunction;
    /* 0x00dc */ int32_t Quality;
    /* 0x00e0 */ bool bTiling;
    /* 0x00e4 */ uint32_t TileSize;
};

// Size: 0x130
class UMaterialExpressionVectorParameter : public UMaterialExpressionParameter {
    /* 0x00d8 */ FLinearColor DefaultValue;
    /* 0x00e8 */ bool bUseCustomPrimitiveData;
    /* 0x00e9 */ uint8_t PrimitiveDataIndex;
    /* 0x00f0 */ FParameterChannelNames ChannelNames;
};

// Size: 0xc0
class UMaterialExpressionVertexColor : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xf0
class UMaterialExpressionVertexInterpolator : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0xc0
class UMaterialExpressionVertexNormalWS : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xc0
class UMaterialExpressionVertexTangentWS : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xb8
class UMaterialExpressionViewProperty : public UMaterialExpression {
    /* 0x00b0 */ uint8_t Property;
};

// Size: 0xb0
class UMaterialExpressionViewSize : public UMaterialExpression {
};

// Size: 0x100
class UMaterialExpressionVirtualTextureFeatureSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput No;
    /* 0x00d8 */ FExpressionInput Yes;
};

// Size: 0xb0
class UMaterialExpressionVolumetricAdvancedMaterialInput : public UMaterialExpression {
};

// Size: 0x1f0
class UMaterialExpressionVolumetricAdvancedMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput PhaseG;
    /* 0x00d8 */ FExpressionInput PhaseG2;
    /* 0x0100 */ FExpressionInput PhaseBlend;
    /* 0x0128 */ FExpressionInput MultiScatteringContribution;
    /* 0x0150 */ FExpressionInput MultiScatteringOcclusion;
    /* 0x0178 */ FExpressionInput MultiScatteringEccentricity;
    /* 0x01a0 */ FExpressionInput ConservativeDensity;
    /* 0x01c8 */ float ConstPhaseG;
    /* 0x01cc */ float ConstPhaseG2;
    /* 0x01d0 */ float ConstPhaseBlend;
    /* 0x01d4 */ bool PerSamplePhaseEvaluation;
    /* 0x01d8 */ uint32_t MultiScatteringApproximationOctaveCount;
    /* 0x01dc */ float ConstMultiScatteringContribution;
    /* 0x01e0 */ float ConstMultiScatteringOcclusion;
    /* 0x01e4 */ float ConstMultiScatteringEccentricity;
    /* 0x01e8 */ bool bGroundContribution;
    /* 0x01e9 */ bool bGrayScaleMaterial;
    /* 0x01ea */ bool bRayMarchVolumeShadow;
    /* 0x01eb */ bool bClampMultiScatteringContribution;
};

// Size: 0xc0
class UMaterialExpressionVolumetricCloudEmptySpaceSkippingInput : public UMaterialExpressionExternalCodeBase {
};

// Size: 0xd8
class UMaterialExpressionVolumetricCloudEmptySpaceSkippingOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ FExpressionInput ContainsMatter;
};

// Size: 0xb8
class UMaterialExpressionWorldPosition : public UMaterialExpression {
    /* 0x00b0 */ uint8_t WorldPositionShaderOffset;
};

// Size: 0x38
class UMaterialExternalCodeCollection : public UObject {
    /* 0x0028 */ TArray<FMaterialExternalCodeDeclaration> ExternalCodeDeclarations;
};

// Size: 0x70
struct FMaterialExternalCodeDeclaration {
    /* 0x0000 */ bool bIsInlined;
    /* 0x0008 */ EMaterialValueTypeBridge ReturnType;
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FString Definition;
    /* 0x0028 */ FString DefinitionDDX;
    /* 0x0038 */ FString DefinitionDDY;
    /* 0x0048 */ EDerivativeStatus Derivative;
    /* 0x0049 */ EMaterialShaderFrequency ShaderFrequency;
    /* 0x0050 */ TArray<uint8_t> Domains;
    /* 0x0060 */ TArray<FMaterialExternalCodeEnvironmentDefine> EnvironmentDefines;
};

// Size: 0xc
struct FMaterialExternalCodeEnvironmentDefine {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ EMaterialShaderFrequency ShaderFrequency;
};

// Size: 0x68
class UMaterialFunction : public UMaterialFunctionInterface {
    /* 0x0040 */ FString Description;
    /* 0x0050 */ FString UserExposedCaption;
    /* 0x0060 */ bool bExposeToLibrary;
    /* 0x0060 */ bool bEnableExecWire;
    /* 0x0060 */ bool bEnableNewHLSLGenerator;
};

// Size: 0x58
class UMaterialFunctionEditorOnlyData : public UMaterialFunctionInterfaceEditorOnlyData {
    /* 0x0028 */ FMaterialExpressionCollection ExpressionCollection;
};

// Size: 0x18
struct FMaterialFunctionInfo {
    /* 0x0000 */ FGuid StateId;
    /* 0x0010 */ UMaterialFunctionInterface* Function;
};

// Size: 0xf0
class UMaterialFunctionInstance : public UMaterialFunctionInterface {
    /* 0x0040 */ UMaterialFunctionInterface* Parent;
    /* 0x0048 */ UMaterialFunctionInterface* base;
    /* 0x0050 */ TArray<FScalarParameterValue> ScalarParameterValues;
    /* 0x0060 */ TArray<FVectorParameterValue> VectorParameterValues;
    /* 0x0070 */ TArray<FDoubleVectorParameterValue> DoubleVectorParameterValues;
    /* 0x0080 */ TArray<FTextureParameterValue> TextureParameterValues;
    /* 0x0090 */ TArray<FTextureCollectionParameterValue> TextureCollectionParameterValues;
    /* 0x00a0 */ TArray<FFontParameterValue> FontParameterValues;
    /* 0x00b0 */ TArray<FStaticSwitchParameter> StaticSwitchParameterValues;
    /* 0x00c0 */ TArray<FStaticComponentMaskParameter> StaticComponentMaskParameterValues;
    /* 0x00d0 */ TArray<FRuntimeVirtualTextureParameterValue> RuntimeVirtualTextureParameterValues;
    /* 0x00e0 */ TArray<FSparseVolumeTextureParameterValue> SparseVolumeTextureParameterValues;
};

// Size: 0x40
class UMaterialFunctionInterface : public UObject {
    /* 0x0028 */ FGuid StateId;
    /* 0x0038 */ EMaterialFunctionUsage MaterialFunctionUsage;
};

// Size: 0x28
class UMaterialFunctionInterfaceEditorOnlyData : public UObject {
};

// Size: 0x68
class UMaterialFunctionMaterialLayer : public UMaterialFunction {
};

// Size: 0x68
class UMaterialFunctionMaterialLayerBlend : public UMaterialFunction {
};

// Size: 0xf0
class UMaterialFunctionMaterialLayerBlendInstance : public UMaterialFunctionInstance {
};

// Size: 0xf0
class UMaterialFunctionMaterialLayerInstance : public UMaterialFunctionInstance {
};

// Size: 0x28
struct FMaterialInput {
    /* 0x0000 */ UMaterialExpression* Expression;
    /* 0x0008 */ int32_t OutputIndex;
    /* 0x000c */ FName InputName;
    /* 0x0014 */ int32_t Mask;
    /* 0x0018 */ int32_t MaskR;
    /* 0x001c */ int32_t MaskG;
    /* 0x0020 */ int32_t MaskB;
    /* 0x0024 */ int32_t MaskA;
};

// Size: 0x2f0
class UMaterialInstance : public UMaterialInterface {
    /* 0x00e0 */ UPhysicalMaterial* PhysMaterial;
    /* 0x00e8 */ UPhysicalMaterial* PhysicalMaterialMap[8];
    /* 0x0128 */ UMaterialInterface* Parent;
    /* 0x0130 */ FMaterialOverrideNanite NaniteOverrideMaterial;
    /* 0x0168 */ USpecularProfile* SpecularProfileOverride;
    /* 0x0170 */ bool bHasStaticPermutationResource;
    /* 0x0170 */ bool bOverrideSubsurfaceProfile;
    /* 0x0170 */ bool bOverrideSpecularProfile;
    /* 0x0170 */ bool bOverrideBlendableLocation;
    /* 0x0170 */ bool bOverrideBlendablePriority;
    /* 0x0173 */ uint8_t BlendableLocationOverride;
    /* 0x0174 */ int32_t BlendablePriorityOverride;
    /* 0x0198 */ TArray<FScalarParameterValue> ScalarParameterValues;
    /* 0x01a8 */ TArray<FVectorParameterValue> VectorParameterValues;
    /* 0x01b8 */ TArray<FDoubleVectorParameterValue> DoubleVectorParameterValues;
    /* 0x01c8 */ TArray<FTextureParameterValue> TextureParameterValues;
    /* 0x01d8 */ TArray<FTextureCollectionParameterValue> TextureCollectionParameterValues;
    /* 0x01e8 */ TArray<FRuntimeVirtualTextureParameterValue> RuntimeVirtualTextureParameterValues;
    /* 0x01f8 */ TArray<FSparseVolumeTextureParameterValue> SparseVolumeTextureParameterValues;
    /* 0x0208 */ TArray<FFontParameterValue> FontParameterValues;
    /* 0x0218 */ TArray<FUserSceneTextureOverride> UserSceneTextureOverrides;
    /* 0x0228 */ FMaterialInstanceBasePropertyOverrides BasePropertyOverrides;
    /* 0x0250 */ FStaticParameterSetRuntimeData StaticParametersRuntime;
};

// Size: 0x2b8
class AMaterialInstanceActor : public AActor {
    /* 0x02a8 */ TArray<AActor*> TargetActors;
};

// Size: 0x20
struct FMaterialInstanceBasePropertyOverrides {
    /* 0x0000 */ bool bOverride_OpacityMaskClipValue;
    /* 0x0000 */ bool bOverride_BlendMode;
    /* 0x0000 */ bool bOverride_ShadingModel;
    /* 0x0000 */ bool bOverride_DitheredLODTransition;
    /* 0x0000 */ bool bOverride_CastDynamicShadowAsMasked;
    /* 0x0000 */ bool bOverride_TwoSided;
    /* 0x0000 */ bool bOverride_bIsThinSurface;
    /* 0x0000 */ bool bOverride_OutputTranslucentVelocity;
    /* 0x0001 */ bool bOverride_bHasPixelAnimation;
    /* 0x0001 */ bool bOverride_bEnableTessellation;
    /* 0x0001 */ bool bOverride_DisplacementScaling;
    /* 0x0001 */ bool bOverride_bEnableDisplacementFade;
    /* 0x0001 */ bool bOverride_DisplacementFadeRange;
    /* 0x0001 */ bool bOverride_MaxWorldPositionOffsetDisplacement;
    /* 0x0001 */ bool bOverride_CompatibleWithLumenCardSharing;
    /* 0x0001 */ bool TwoSided;
    /* 0x0002 */ bool bIsThinSurface;
    /* 0x0002 */ bool DitheredLODTransition;
    /* 0x0002 */ bool bCastDynamicShadowAsMasked;
    /* 0x0002 */ bool bOutputTranslucentVelocity;
    /* 0x0002 */ bool bHasPixelAnimation;
    /* 0x0002 */ bool bEnableTessellation;
    /* 0x0002 */ bool bEnableDisplacementFade;
    /* 0x0002 */ bool bCompatibleWithLumenCardSharing;
    /* 0x0003 */ uint8_t BlendMode;
    /* 0x0004 */ uint8_t ShadingModel;
    /* 0x0008 */ float OpacityMaskClipValue;
    /* 0x000c */ FDisplacementScaling DisplacementScaling;
    /* 0x0014 */ FDisplacementFadeRange DisplacementFadeRange;
    /* 0x001c */ float MaxWorldPositionOffsetDisplacement;
};

// Size: 0x10
struct FMaterialInstanceCachedData {
    /* 0x0000 */ TArray<int32_t> ParentLayerIndexRemap;
};

// Size: 0x2f8
class UMaterialInstanceConstant : public UMaterialInstance {
    /* 0x02f0 */ UPhysicalMaterialMask* PhysMaterialMask;

    float K2_GetScalarParameterValue(FName ParameterName);
    UTextureCollection* K2_GetTextureCollectionParameterValue(FName ParameterName);
    UTexture* K2_GetTextureParameterValue(FName ParameterName);
    FLinearColor K2_GetVectorParameterValue(FName ParameterName);
};

// Size: 0x340
class UMaterialInstanceDynamic : public UMaterialInstance {

    void CopyInterpParameters(UMaterialInstance* Source);
    void CopyParameterOverrides(UMaterialInstance* MaterialInstance);
    bool InitializeScalarParameterAndGetIndex(const FName& ParameterName, float Value, int32_t& OutParameterIndex);
    void K2_CopyMaterialInstanceParameters(UMaterialInterface* Source, bool bQuickParametersOnly);
    float K2_GetScalarParameterValue(FName ParameterName);
    float K2_GetScalarParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo);
    UTextureCollection* K2_GetTextureCollectionParameterValue(FName ParameterName);
    UTextureCollection* K2_GetTextureCollectionParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo);
    UTexture* K2_GetTextureParameterValue(FName ParameterName);
    UTexture* K2_GetTextureParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo);
    FLinearColor K2_GetVectorParameterValue(FName ParameterName);
    FLinearColor K2_GetVectorParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo);
    void K2_InterpolateMaterialInstanceParams(UMaterialInstance* SourceA, UMaterialInstance* SourceB, float Alpha);
    void SetDoubleVectorParameterValue(FName ParameterName, FVector4 Value);
    void SetRuntimeVirtualTextureParameterValue(FName ParameterName, URuntimeVirtualTexture* Value);
    void SetRuntimeVirtualTextureParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo, URuntimeVirtualTexture* Value);
    bool SetScalarParameterByIndex(int32_t ParameterIndex, float Value);
    void SetScalarParameterValue(FName ParameterName, float Value);
    void SetScalarParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo, float Value);
    void SetSparseVolumeTextureParameterValue(FName ParameterName, USparseVolumeTexture* Value);
    void SetTextureCollectionParameterValue(FName ParameterName, UTextureCollection* Value);
    void SetTextureCollectionParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo, UTextureCollection* Value);
    void SetTextureParameterValue(FName ParameterName, UTexture* Value);
    void SetTextureParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo, UTexture* Value);
    void SetVectorParameterValue(FName ParameterName, FLinearColor Value);
    void SetVectorParameterValueByInfo(const FMaterialParameterInfo& ParameterInfo, FLinearColor Value);
};

// Size: 0xe0
class UMaterialInstanceEditorOnlyData : public UMaterialInterfaceEditorOnlyData {
    /* 0x0040 */ FStaticParameterSetEditorOnlyData StaticParameters;
};

// Size: 0xe0
class UMaterialInterface : public UObject {
    /* 0x0038 */ USubsurfaceProfile* SubsurfaceProfile;
    /* 0x0040 */ TArray<USubsurfaceProfile*> SubsurfaceProfiles;
    /* 0x0050 */ TArray<USpecularProfile*> SpecularProfiles;
    /* 0x0060 */ UNeuralProfile* NeuralProfile;
    /* 0x0088 */ FLightmassMaterialInterfaceSettings LightmassSettings;
    /* 0x0098 */ TArray<FMaterialTextureInfo> TextureStreamingData;
    /* 0x00a8 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x00b8 */ TOptional<FMaterialCachedTexturesSamplingInfo> CachedTexturesSamplingInfo;
    /* 0x00d4 */ bool bIncludedInBaseGame;

    UMaterial* GetBaseMaterial();
    uint8_t GetBlendMode() const;
    UMaterialInterface* GetNaniteOverideMaterial() const;
    FMaterialParameterInfo GetParameterInfo(uint8_t Association, FName ParameterName, UMaterialFunctionInterface* LayerFunction) const;
    UPhysicalMaterial* GetPhysicalMaterial() const;
    UPhysicalMaterial* GetPhysicalMaterialFromMap(int32_t Index) const;
    UPhysicalMaterialMask* GetPhysicalMaterialMask() const;
    void SetForceMipLevelsToBeResident(bool OverrideForceMiplevelsToBeResident, bool bForceMiplevelsToBeResidentValue, float ForceDuration, int32_t CinematicTextureGroups, bool bFastResponse);
};

// Size: 0x40
class UMaterialInterfaceEditorOnlyData : public UObject {
};

// Size: 0x138
struct FMaterialLayersFunctions : public FMaterialLayersFunctionsRuntimeData {
    /* 0x0058 */ FMaterialLayersFunctionsEditorOnlyData EditorOnly;
    /* 0x00c8 */ TArray<bool> LayerStates;
    /* 0x00d8 */ TArray<FText> LayerNames;
    /* 0x00e8 */ TArray<bool> RestrictToLayerRelatives;
    /* 0x00f8 */ TArray<bool> RestrictToBlendRelatives;
    /* 0x0108 */ TArray<FGuid> LayerGuids;
    /* 0x0118 */ TArray<EMaterialLayerLinkState> LayerLinkStates;
    /* 0x0128 */ TArray<FGuid> DeletedParentLayerGuids;
};

// Size: 0x70
struct FMaterialLayersFunctionsEditorOnlyData {
    /* 0x0000 */ TArray<bool> LayerStates;
    /* 0x0010 */ TArray<FText> LayerNames;
    /* 0x0020 */ TArray<bool> RestrictToLayerRelatives;
    /* 0x0030 */ TArray<bool> RestrictToBlendRelatives;
    /* 0x0040 */ TArray<FGuid> LayerGuids;
    /* 0x0050 */ TArray<EMaterialLayerLinkState> LayerLinkStates;
    /* 0x0060 */ TArray<FGuid> DeletedParentLayerGuids;
};

// Size: 0x58
struct FMaterialLayersFunctionsRuntimeData {
    /* 0x0000 */ TArray<UMaterialFunctionInterface*> Layers;
    /* 0x0010 */ TArray<UMaterialFunctionInterface*> Blends;
    /* 0x0020 */ FMaterialLayersFunctionsTree tree;
};

// Size: 0x20
struct FMaterialLayersFunctionsRuntimeGraphCache {
};

// Size: 0x28
struct FMaterialLayersFunctionsTree {
};

// Size: 0x38
struct FMaterialOverrideNanite {
    /* 0x0000 */ bool bEnableOverride;
    /* 0x0008 */ UMaterialInterface* OverrideMaterial;
    /* 0x0010 */ TSoftObjectPtr<UMaterialInterface> OverrideMaterialRef;
};

// Size: 0x70
class UMaterialParameterCollection : public UObject {
    /* 0x0028 */ FGuid StateId;
    /* 0x0038 */ TArray<FCollectionScalarParameter> ScalarParameters;
    /* 0x0048 */ TArray<FCollectionVectorParameter> VectorParameters;

    float GetScalarParameterDefaultValue(FName ParameterName, bool& bParameterFound) const;
    TArray<FName> GetScalarParameterNames() const;
    FLinearColor GetVectorParameterDefaultValue(FName ParameterName, bool& bParameterFound) const;
    TArray<FName> GetVectorParameterNames() const;
};

// Size: 0x58
class UMaterialParameterCollectionHLODModifier : public UWorldPartitionHLODModifier {
    /* 0x0028 */ UMaterialParameterCollection* MPC;
    /* 0x0030 */ TArray<FHLODModifierScalarParameter> ScalarParameters;
};

// Size: 0x18
struct FMaterialParameterCollectionInfo {
    /* 0x0000 */ FGuid StateId;
    /* 0x0010 */ UMaterialParameterCollection* ParameterCollection;
};

// Size: 0x120
class UMaterialParameterCollectionInstance : public UObject {
    /* 0x002c */ TWeakObjectPtr<UMaterialParameterCollection> Collection;
};

// Size: 0x10
struct FMaterialParameterInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ uint8_t Association;
    /* 0x000c */ int32_t Index;
};

// Size: 0xa0
struct FMaterialProxySettings {
    /* 0x0000 */ uint8_t TextureSizingType;
    /* 0x0004 */ FIntPoint TextureSize;
    /* 0x000c */ float TargetTexelDensityPerMeter;
    /* 0x0010 */ float MeshMaxScreenSizePercent;
    /* 0x0018 */ double MeshMinDrawDistance;
    /* 0x0020 */ float GutterSpace;
    /* 0x0024 */ float MetallicConstant;
    /* 0x0028 */ float RoughnessConstant;
    /* 0x002c */ float AnisotropyConstant;
    /* 0x0030 */ float SpecularConstant;
    /* 0x0034 */ float OpacityConstant;
    /* 0x0038 */ float OpacityMaskConstant;
    /* 0x003c */ float AmbientOcclusionConstant;
    /* 0x0040 */ uint8_t MaterialMergeType;
    /* 0x0041 */ uint8_t BlendMode;
    /* 0x0042 */ bool bAllowTwoSidedMaterial;
    /* 0x0042 */ bool bNormalMap;
    /* 0x0042 */ bool bTangentMap;
    /* 0x0042 */ bool bMetallicMap;
    /* 0x0042 */ bool bRoughnessMap;
    /* 0x0042 */ bool bAnisotropyMap;
    /* 0x0042 */ bool bSpecularMap;
    /* 0x0042 */ bool bEmissiveMap;
    /* 0x0043 */ bool bOpacityMap;
    /* 0x0043 */ bool bOpacityMaskMap;
    /* 0x0043 */ bool bAmbientOcclusionMap;
    /* 0x0044 */ FIntPoint DiffuseTextureSize;
    /* 0x004c */ FIntPoint NormalTextureSize;
    /* 0x0054 */ FIntPoint TangentTextureSize;
    /* 0x005c */ FIntPoint MetallicTextureSize;
    /* 0x0064 */ FIntPoint RoughnessTextureSize;
    /* 0x006c */ FIntPoint AnisotropyTextureSize;
    /* 0x0074 */ FIntPoint SpecularTextureSize;
    /* 0x007c */ FIntPoint EmissiveTextureSize;
    /* 0x0084 */ FIntPoint OpacityTextureSize;
    /* 0x008c */ FIntPoint OpacityMaskTextureSize;
    /* 0x0094 */ FIntPoint AmbientOcclusionTextureSize;
};

// Size: 0x18
struct FMaterialRemapIndex {
    /* 0x0000 */ uint32_t ImportVersionKey;
    /* 0x0008 */ TArray<int32_t> MaterialRemap;
};

// Size: 0x2
struct FMaterialShadingModelField {
    /* 0x0000 */ uint16_t ShadingModelField;
};

// Size: 0x28
struct FMaterialSpriteElement {
    /* 0x0000 */ UMaterialInterface* Material;
    /* 0x0008 */ UCurveFloat* DistanceToOpacityCurve;
    /* 0x0010 */ bool bSizeIsInScreenSpace;
    /* 0x0014 */ float BaseSizeX;
    /* 0x0018 */ float BaseSizeY;
    /* 0x0020 */ UCurveFloat* DistanceToSizeCurve;
};

// Size: 0x10
struct FMaterialTextureInfo {
    /* 0x0000 */ float SamplingScale;
    /* 0x0004 */ int32_t UVChannelIndex;
    /* 0x0008 */ FName TextureName;
};

// Size: 0xc
struct FMatteBoxFlag {
    /* 0x0000 */ float Pitch;
    /* 0x0004 */ float Roll;
    /* 0x0008 */ float Length;
};

// Size: 0x38
struct FMemberReference {
    /* 0x0000 */ UObject* MemberParent;
    /* 0x0008 */ FString MemberScope;
    /* 0x0018 */ FName MemberName;
    /* 0x0020 */ FGuid MemberGuid;
    /* 0x0030 */ bool bSelfContext;
    /* 0x0031 */ bool bWasDeprecated;
};

// Size: 0x128
struct FMeshApproximationSettings {
    /* 0x0000 */ EMeshApproximationType OutputType;
    /* 0x0004 */ float ApproximationAccuracy;
    /* 0x0008 */ int32_t ClampVoxelDimension;
    /* 0x000c */ bool bAttemptAutoThickening;
    /* 0x0010 */ float TargetMinThicknessMultiplier;
    /* 0x0014 */ bool bIgnoreTinyParts;
    /* 0x0018 */ float TinyPartSizeMultiplier;
    /* 0x001c */ EMeshApproximationBaseCappingType BaseCapping;
    /* 0x0020 */ float WindingThreshold;
    /* 0x0024 */ bool bFillGaps;
    /* 0x0028 */ float GapDistance;
    /* 0x002c */ EOccludedGeometryFilteringPolicy OcclusionMethod;
    /* 0x002d */ bool bOccludeFromBottom;
    /* 0x002e */ EMeshApproximationSimplificationPolicy SimplifyMethod;
    /* 0x0030 */ int32_t TargetTriCount;
    /* 0x0034 */ float TrianglesPerM;
    /* 0x0038 */ float GeometricDeviation;
    /* 0x003c */ EMeshApproximationGroundPlaneClippingPolicy GroundClipping;
    /* 0x0040 */ float GroundClippingZHeight;
    /* 0x0044 */ bool bEstimateHardNormals;
    /* 0x0048 */ float HardNormalAngle;
    /* 0x004c */ EMeshApproximationUVGenerationPolicy UVGenerationMethod;
    /* 0x0050 */ int32_t InitialPatchCount;
    /* 0x0054 */ float CurvatureAlignment;
    /* 0x0058 */ float MergingThreshold;
    /* 0x005c */ float MaxAngleDeviation;
    /* 0x0060 */ bool bGenerateNaniteEnabledMesh;
    /* 0x0061 */ ENaniteFallbackTarget NaniteFallbackTarget;
    /* 0x0064 */ float NaniteFallbackPercentTriangles;
    /* 0x0068 */ float NaniteFallbackRelativeError;
    /* 0x006c */ bool bSupportRayTracing;
    /* 0x006d */ bool bAllowDistanceField;
    /* 0x0070 */ int32_t MultiSamplingAA;
    /* 0x0074 */ int32_t RenderCaptureResolution;
    /* 0x0078 */ FMaterialProxySettings MaterialSettings;
    /* 0x0118 */ float CaptureFieldOfView;
    /* 0x011c */ float NearPlaneDist;
    /* 0x0120 */ bool bUseRenderLODMeshes;
    /* 0x0121 */ bool bEnableSimplifyPrePass;
    /* 0x0122 */ bool bEnableParallelBaking;
    /* 0x0123 */ bool bPrintDebugMessages;
    /* 0x0124 */ bool bEmitFullDebugMesh;
};

// Size: 0x50
class UMeshBudgetProjectSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bEnableStaticMeshBudget;
    /* 0x0040 */ TArray<FStaticMeshBudgetInfo> StaticMeshBudgetInfos;
};

// Size: 0x48
struct FMeshBuildSettings {
    /* 0x0000 */ bool bUseMikkTSpace;
    /* 0x0000 */ bool bRecomputeNormals;
    /* 0x0000 */ bool bRecomputeTangents;
    /* 0x0000 */ bool bComputeWeightedNormals;
    /* 0x0000 */ bool bRemoveDegenerates;
    /* 0x0000 */ bool bBuildReversedIndexBuffer;
    /* 0x0000 */ bool bUseHighPrecisionTangentBasis;
    /* 0x0000 */ bool bUseFullPrecisionUVs;
    /* 0x0001 */ bool bUseBackwardsCompatibleF16TruncUVs;
    /* 0x0001 */ bool bGenerateLightmapUVs;
    /* 0x0001 */ bool bGenerateDistanceFieldAsIfTwoSided;
    /* 0x0001 */ bool bSupportFaceRemap;
    /* 0x0004 */ int32_t MinLightmapResolution;
    /* 0x0008 */ int32_t SrcLightmapIndex;
    /* 0x000c */ int32_t DstLightmapIndex;
    /* 0x0010 */ float BuildScale;
    /* 0x0018 */ FVector BuildScale3D;
    /* 0x0030 */ float DistanceFieldResolutionScale;
    /* 0x0038 */ UStaticMesh* DistanceFieldReplacementMesh;
    /* 0x0040 */ int32_t MaxLumenMeshCards;
};

// Size: 0x570
class UMeshComponent : public UPrimitiveComponent {
    /* 0x0520 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x0530 */ UMaterialInterface* OverlayMaterial;
    /* 0x0538 */ float OverlayMaterialMaxDrawDistance;
    /* 0x0540 */ TArray<UMaterialInterface*> MaterialSlotsOverlayMaterial;
    /* 0x0550 */ bool bEnableMaterialParameterCaching;

    TArray<UMaterialInterface*> GetMaterials() const;
    UMaterialInterface* GetOverlayMaterial() const;
    float GetOverlayMaterialMaxDrawDistance() const;
    bool PrestreamMeshLODs(float Seconds);
    void PrestreamTextures(float Seconds, bool bPrioritizeCharacterTextures, int32_t CinematicTextureGroups);
    void SetColorParameterValueOnMaterials(const FName ParameterName, const FLinearColor ParameterValue);
    void SetOverlayMaterial(UMaterialInterface* NewOverlayMaterial);
    void SetOverlayMaterialMaxDrawDistance(float InMaxDrawDistance);
    void SetScalarParameterValueOnMaterials(const FName ParameterName, const float ParameterValue);
    void SetVectorParameterValueOnMaterials(const FName ParameterName, const FVector ParameterValue);
};

// Size: 0x28
class UMeshDeformer : public UObject {
};

// Size: 0x50
class UMeshDeformerCollection : public UDataAsset {
    /* 0x0030 */ TArray<TSoftObjectPtr<UMeshDeformer>> MeshDeformers;
    /* 0x0040 */ TArray<UMeshDeformerCollection*> MeshDeformerCollections;
};

// Size: 0x28
class UMeshDeformerInstance : public UObject {
};

// Size: 0x20
struct FMeshDeformerInstanceSet {
    /* 0x0000 */ TArray<UMeshDeformerInstance*> DeformerInstances;
};

// Size: 0x28
class UMeshDeformerInstanceSettings : public UObject {
};

// Size: 0x28
class IMeshDeformerProducer : public UInterface {
};

// Size: 0x10
struct FMeshDisplacementMap {
    /* 0x0000 */ UTexture2D* Texture;
    /* 0x0008 */ float Magnitude;
    /* 0x000c */ float Center;
};

// Size: 0x30
struct FMeshDrawCommandStatsBudget {
    /* 0x0000 */ FName CategoryName;
    /* 0x0008 */ TArray<FName> LinkedStatNames;
    /* 0x0018 */ int32_t PrimitiveBudget;
    /* 0x001c */ int32_t Collection;
    /* 0x0020 */ TArray<FName> Passes;
};

// Size: 0x8
struct FMeshDrawCommandStatsBudgetTotals {
    /* 0x0000 */ int32_t PrimitiveBudget;
    /* 0x0004 */ int32_t Collection;
};

// Size: 0x60
class UMeshDrawCommandStatsSettings : public UDeveloperSettings {
    /* 0x0038 */ TArray<FMeshDrawCommandStatsBudget> Budgets;
    /* 0x0048 */ TArray<FMeshDrawCommandStatsBudgetTotals> BudgetTotals;
    /* 0x0058 */ int32_t CollectionForCsvProfiler;
};

// Size: 0x18
struct FMeshInstancingSettings {
    /* 0x0000 */ UClass* ActorClassToUse;
    /* 0x0008 */ int32_t InstanceReplacementThreshold;
    /* 0x000c */ bool bSkipMeshesWithVertexColors;
    /* 0x000d */ bool bUseHLODVolumes;
    /* 0x0010 */ UClass* ISMComponentToUse;
};

// Size: 0x2e0
class AMeshMergeCullingVolume : public AVolume {
};

// Size: 0x138
struct FMeshMergingSettings {
    /* 0x0000 */ int32_t TargetLightMapResolution;
    /* 0x0004 */ EUVOutput OutputUVs[8];
    /* 0x0010 */ FMaterialProxySettings MaterialSettings;
    /* 0x00b0 */ int32_t GutterSize;
    /* 0x00b4 */ EMeshLODSelectionType LODSelectionType;
    /* 0x00b8 */ int32_t SpecificLOD;
    /* 0x00bc */ bool bGenerateLightMapUV;
    /* 0x00bc */ bool bComputedLightMapResolution;
    /* 0x00bc */ bool bPivotPointAtZero;
    /* 0x00bc */ bool bMergePhysicsData;
    /* 0x00bc */ bool bMergeMeshSockets;
    /* 0x00bc */ bool bMergeMaterials;
    /* 0x00bc */ bool bBakeVertexDataToMesh;
    /* 0x00bc */ bool bUseVertexDataForBakingMaterial;
    /* 0x00bd */ bool bUseTextureBinning;
    /* 0x00bd */ bool bReuseMeshLightmapUVs;
    /* 0x00bd */ bool bMergeEquivalentMaterials;
    /* 0x00bd */ bool bUseLandscapeCulling;
    /* 0x00bd */ bool bIncludeImposters;
    /* 0x00bd */ bool bSupportRayTracing;
    /* 0x00bd */ bool bAllowDistanceField;
    /* 0x00c0 */ FMeshNaniteSettings NaniteSettings;
};

// Size: 0x70
struct FMeshNaniteSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0000 */ bool bPreserveArea;
    /* 0x0000 */ bool bExplicitTangents;
    /* 0x0000 */ bool bLerpUVs;
    /* 0x0000 */ bool bSeparable;
    /* 0x0000 */ bool bVoxelNDF;
    /* 0x0000 */ bool bVoxelOpacity;
    /* 0x0004 */ int32_t PositionPrecision;
    /* 0x0008 */ int32_t NormalPrecision;
    /* 0x000c */ int32_t TangentPrecision;
    /* 0x0010 */ int32_t BoneWeightPrecision;
    /* 0x0014 */ uint32_t TargetMinimumResidencyInKB;
    /* 0x0018 */ float KeepPercentTriangles;
    /* 0x001c */ float TrimRelativeError;
    /* 0x0020 */ ENaniteGenerateFallback GenerateFallback;
    /* 0x0021 */ ENaniteFallbackTarget FallbackTarget;
    /* 0x0024 */ float FallbackPercentTriangles;
    /* 0x0028 */ float FallbackRelativeError;
    /* 0x002c */ float MaxEdgeLengthFactor;
    /* 0x0030 */ int32_t NumRays;
    /* 0x0034 */ int32_t VoxelLevel;
    /* 0x0038 */ float RayBackUp;
    /* 0x003c */ int32_t DisplacementUVChannel;
    /* 0x0040 */ TArray<FMeshDisplacementMap> DisplacementMaps;
    /* 0x0050 */ FNaniteAssemblyData NaniteAssemblyData;
};

// Size: 0x168
class UMeshPaintVirtualTexture : public UTexture2D {
    /* 0x0160 */ TWeakObjectPtr<UPrimitiveComponent> OwningComponent;
};

// Size: 0x130
struct FMeshProxySettings {
    /* 0x0000 */ int32_t ScreenSize;
    /* 0x0004 */ float VoxelSize;
    /* 0x0008 */ FMaterialProxySettings MaterialSettings;
    /* 0x00a8 */ float MergeDistance;
    /* 0x00ac */ FColor UnresolvedGeometryColor;
    /* 0x00b0 */ float MaxRayCastDist;
    /* 0x00b4 */ float HardAngleThreshold;
    /* 0x00b8 */ int32_t LightMapResolution;
    /* 0x00bc */ uint8_t NormalCalculationMethod;
    /* 0x00bd */ uint8_t LandscapeCullingPrecision;
    /* 0x00be */ bool bCalculateCorrectLODModel;
    /* 0x00be */ bool bOverrideVoxelSize;
    /* 0x00be */ bool bOverrideTransferDistance;
    /* 0x00be */ bool bUseHardAngleThreshold;
    /* 0x00be */ bool bComputeLightMapResolution;
    /* 0x00be */ bool bRecalculateNormals;
    /* 0x00be */ bool bUseLandscapeCulling;
    /* 0x00be */ bool bSupportRayTracing;
    /* 0x00bf */ bool bAllowDistanceField;
    /* 0x00bf */ bool bReuseMeshLightmapUVs;
    /* 0x00bf */ bool bGroupIdenticalMeshesForBaking;
    /* 0x00bf */ bool bCreateCollision;
    /* 0x00bf */ bool bAllowVertexColors;
    /* 0x00bf */ bool bGenerateLightmapUVs;
    /* 0x00c0 */ FMeshNaniteSettings NaniteSettings;
};

// Size: 0x14
struct FMeshRayTracingProxySettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0001 */ ENaniteFallbackTarget FallbackTarget;
    /* 0x0004 */ float FallbackPercentTriangles;
    /* 0x0008 */ float FallbackRelativeError;
    /* 0x000c */ float LOD1PercentTriangles;
    /* 0x0010 */ float FoliageOverOcclusionBias;
};

// Size: 0x2c
struct FMeshReductionSettings {
    /* 0x0000 */ float PercentTriangles;
    /* 0x0004 */ uint32_t MaxNumOfTriangles;
    /* 0x0008 */ float PercentVertices;
    /* 0x000c */ uint32_t MaxNumOfVerts;
    /* 0x0010 */ float MaxDeviation;
    /* 0x0014 */ float PixelError;
    /* 0x0018 */ float WeldingThreshold;
    /* 0x001c */ float HardAngleThreshold;
    /* 0x0020 */ int32_t BaseLODModel;
    /* 0x0024 */ uint8_t SilhouetteImportance;
    /* 0x0025 */ uint8_t TextureImportance;
    /* 0x0026 */ uint8_t ShadingImportance;
    /* 0x0027 */ bool bRecalculateNormals;
    /* 0x0027 */ bool bGenerateUniqueLightmapUVs;
    /* 0x0027 */ bool bKeepSymmetry;
    /* 0x0027 */ bool bVisibilityAided;
    /* 0x0027 */ bool bCullOccluded;
    /* 0x0028 */ EStaticMeshReductionTerimationCriterion TerminationCriterion;
    /* 0x0029 */ uint8_t VisibilityAggressiveness;
    /* 0x002a */ uint8_t VertexColorImportance;
};

// Size: 0xc
struct FMeshSectionInfo {
    /* 0x0000 */ int32_t MaterialIndex;
    /* 0x0004 */ bool bEnableCollision;
    /* 0x0005 */ bool bCastShadow;
    /* 0x0006 */ bool bVisibleInRayTracing;
    /* 0x0007 */ bool bAffectDistanceFieldLighting;
    /* 0x0008 */ bool bForceOpaque;
};

// Size: 0x50
struct FMeshSectionInfoMap {
    /* 0x0000 */ TMap<uint32_t, FMeshSectionInfo> Map;
};

// Size: 0x48
class UMeshSimplificationSettings : public UDeveloperSettings {
    /* 0x0038 */ FName MeshReductionModuleName;
    /* 0x0040 */ bool bMeshReductionBackwardCompatible;
};

// Size: 0x14
struct FMeshUVChannelInfo {
    /* 0x0000 */ bool bInitialized;
    /* 0x0001 */ bool bOverrideDensities;
    /* 0x0004 */ float LocalUVDensities[4];
};

// Size: 0x28
class UMeshVertexPainterKismetLibrary : public UBlueprintFunctionLibrary {

    static void PaintVerticesLerpAlongAxis(UStaticMeshComponent* StaticMeshComponent, const FLinearColor& StartColor, const FLinearColor& EndColor, EVertexPaintAxis Axis, bool bConvertToSRGB);
    static void PaintVerticesSingleColor(UStaticMeshComponent* StaticMeshComponent, const FLinearColor& FillColor, bool bConvertToSRGB);
    static void RemovePaintedVertices(UStaticMeshComponent* StaticMeshComponent);
};

// Size: 0x68
class UMicroTransactionBase : public UPlatformInterfaceBase {
    /* 0x0038 */ TArray<FPurchaseInfo> AvailableProducts;
    /* 0x0048 */ FString lastError;
    /* 0x0058 */ FString LastErrorSolution;
};

// Size: 0x8c0
struct FMinimalViewInfo {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ float FOV;
    /* 0x0034 */ float DesiredFOV;
    /* 0x0038 */ float FirstPersonFOV;
    /* 0x003c */ float FirstPersonScale;
    /* 0x0040 */ float OrthoWidth;
    /* 0x0044 */ bool bAutoCalculateOrthoPlanes;
    /* 0x0048 */ float AutoPlaneShift;
    /* 0x004c */ bool bUpdateOrthoPlanes;
    /* 0x004d */ bool bUseCameraHeightAsViewTarget;
    /* 0x0050 */ float OrthoNearClipPlane;
    /* 0x0054 */ float OrthoFarClipPlane;
    /* 0x0058 */ float PerspectiveNearClipPlane;
    /* 0x005c */ float AspectRatio;
    /* 0x0068 */ bool bConstrainAspectRatio;
    /* 0x0068 */ bool bUseFirstPersonParameters;
    /* 0x0068 */ bool bUseFieldOfViewForLOD;
    /* 0x006c */ uint8_t ProjectionMode;
    /* 0x0070 */ float PostProcessBlendWeight;
    /* 0x0080 */ FPostProcessSettings PostProcessSettings;
    /* 0x07e0 */ FVector2D OffCenterProjectionOffset;
    /* 0x0860 */ float OverscanResolutionFraction;
    /* 0x0864 */ float CropFraction;
    /* 0x0870 */ FVector4f AsymmetricCropFraction;
};

// Size: 0x1f0
class UMirrorDataTable : public UDataTable {
    /* 0x00b0 */ TArray<FMirrorFindReplaceExpression> MirrorFindReplaceExpressions;
    /* 0x00c0 */ uint8_t MirrorAxis;
    /* 0x00c1 */ bool bMirrorRootMotion;
    /* 0x00c8 */ USkeleton* Skeleton;
};

// Size: 0x14
struct FMirrorFindReplaceExpression {
    /* 0x0000 */ FName FindExpression;
    /* 0x0008 */ FName ReplaceExpression;
    /* 0x0010 */ uint8_t FindReplaceMethod;
};

// Size: 0x20
struct FMirrorTableRow : public FTableRowBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName MirroredName;
    /* 0x0018 */ uint8_t MirrorEntryType;
};

// Size: 0x268
class UModel : public UObject {
};

// Size: 0x560
class UModelComponent : public UPrimitiveComponent {
    /* 0x0538 */ UBodySetup* ModelBodySetup;
};

enum class ModulationParamMode {
    MPM_Normal = 0,
    MPM_Abs = 1,
    MPM_Direct = 2,
    MPM_MAX = 3,
};

// Size: 0x20
struct FModulatorContinuousParams {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ float Default;
    /* 0x000c */ float MinInput;
    /* 0x0010 */ float MaxInput;
    /* 0x0014 */ float MinOutput;
    /* 0x0018 */ float MaxOutput;
    /* 0x001c */ uint8_t ParamMode;
};

// Size: 0x20
struct FMontageBlendSettings {
    /* 0x0000 */ UBlendProfile* BlendProfile;
    /* 0x0008 */ FAlphaBlendArgs Blend;
    /* 0x0018 */ EMontageBlendMode BlendMode;
};

// Size: 0x40
class UMorphTarget : public UObject {
    /* 0x0028 */ USkeletalMesh* BaseSkelMesh;
};

// Size: 0x20
struct FMorphTargetImportedSourceFileInfo {
    /* 0x0000 */ FString SourceFilename;
    /* 0x0010 */ FGuid DerivedDataHash;
};

// Size: 0x120
class UMovementComponent : public UActorComponent {
    /* 0x00b8 */ USceneComponent* UpdatedComponent;
    /* 0x00c0 */ UPrimitiveComponent* UpdatedPrimitive;
    /* 0x00d0 */ FVector Velocity;
    /* 0x00e8 */ FVector PlaneConstraintNormal;
    /* 0x0100 */ FVector PlaneConstraintOrigin;
    /* 0x0118 */ bool bUpdateOnlyIfRendered;
    /* 0x0118 */ bool bAutoUpdateTickRegistration;
    /* 0x0118 */ bool bTickBeforeOwner;
    /* 0x0118 */ bool bAutoRegisterUpdatedComponent;
    /* 0x0118 */ bool bConstrainToPlane;
    /* 0x0118 */ bool bSnapToPlaneAtStart;
    /* 0x0118 */ bool bAutoRegisterPhysicsVolumeUpdates;
    /* 0x0118 */ bool bComponentShouldUpdatePhysicsVolume;
    /* 0x011b */ EPlaneConstraintAxisSetting PlaneConstraintAxisSetting;

    FVector ConstrainDirectionToPlane(FVector Direction) const;
    FVector ConstrainLocationToPlane(FVector Location) const;
    FVector ConstrainNormalToPlane(FVector Normal) const;
    float GetGravityZ() const;
    float GetMaxSpeed() const;
    APhysicsVolume* GetPhysicsVolume() const;
    EPlaneConstraintAxisSetting GetPlaneConstraintAxisSetting() const;
    FVector GetPlaneConstraintNormal() const;
    FVector GetPlaneConstraintOrigin() const;
    bool IsExceedingMaxSpeed(float MaxSpeed) const;
    bool K2_MoveUpdatedComponent(FVector Delta, FRotator NewRotation, FHitResult& OutHit, bool bSweep, bool bTeleport);
    void PhysicsVolumeChanged(APhysicsVolume* NewVolume);
    void SetPlaneConstraintAxisSetting(EPlaneConstraintAxisSetting NewAxisSetting);
    void SetPlaneConstraintEnabled(bool bEnabled);
    void SetPlaneConstraintFromVectors(FVector Forward, FVector Up);
    void SetPlaneConstraintNormal(FVector PlaneNormal);
    void SetPlaneConstraintOrigin(FVector PlaneOrigin);
    void SetUpdatedComponent(USceneComponent* NewUpdatedComponent);
    void SnapUpdatedComponentToPlane();
    void StopMovementImmediately();
};

// Size: 0x1
struct FMovementProperties {
    /* 0x0000 */ bool bCanCrouch;
    /* 0x0000 */ bool bCanJump;
    /* 0x0000 */ bool bCanWalk;
    /* 0x0000 */ bool bCanSwim;
    /* 0x0000 */ bool bCanFly;
};

// Size: 0x18
struct FMulticastRecordOptions {
    /* 0x0000 */ FString FuncPathName;
    /* 0x0010 */ bool bServerSkip;
    /* 0x0011 */ bool bClientSkip;
};

// Size: 0x78
struct FNameCurve : public FIndexedCurve {
    /* 0x0068 */ TArray<FNameCurveKey> Keys;
};

// Size: 0xc
struct FNameCurveKey {
    /* 0x0000 */ float Time;
    /* 0x0004 */ FName Value;
};

// Size: 0x10
struct FNameMapping {
    /* 0x0000 */ FName NodeName;
    /* 0x0008 */ FName BoneName;
};

// Size: 0xc
struct FNamedColor {
    /* 0x0000 */ FColor Value;
    /* 0x0004 */ FName Name;
};

// Size: 0xc
struct FNamedCurveValue {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ float Value;
};

// Size: 0x10
struct FNamedEmitterMaterial {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UMaterialInterface* Material;
};

// Size: 0xc
struct FNamedFloat {
    /* 0x0000 */ float Value;
    /* 0x0004 */ FName Name;
};

// Size: 0x10
struct FNamedNetDriver {
    /* 0x0000 */ UNetDriver* NetDriver;
};

// Size: 0x70
struct FNamedTransform {
    /* 0x0000 */ FTransform Value;
    /* 0x0060 */ FName Name;
};

// Size: 0x20
struct FNamedVector {
    /* 0x0000 */ FVector Value;
    /* 0x0018 */ FName Name;
};

// Size: 0x20
struct FNaniteAssemblyData {
    /* 0x0000 */ TArray<FNaniteAssemblyPart> Parts;
    /* 0x0010 */ TArray<FNaniteAssemblyNode> Nodes;
};

// Size: 0x50
struct FNaniteAssemblyNode {
    /* 0x0000 */ int32_t ParentIndex;
    /* 0x0004 */ int32_t PartIndex;
    /* 0x0010 */ FMatrix44f Transform;
};

// Size: 0x30
struct FNaniteAssemblyPart {
    /* 0x0000 */ FSoftObjectPath MeshObjectPath;
    /* 0x0020 */ TArray<int32_t> MaterialRemap;
};

// Size: 0x1
struct FNaniteSettings {
    /* 0x0000 */ bool bAllowMaskedMaterials;
};

// Size: 0x28
class INavAgentInterface : public UInterface {
};

// Size: 0x38
struct FNavAgentProperties : public FMovementProperties {
    /* 0x0004 */ float AgentRadius;
    /* 0x0008 */ float AgentHeight;
    /* 0x000c */ float AgentStepHeight;
    /* 0x0010 */ float NavWalkingSearchHeightScale;
    /* 0x0018 */ FSoftClassPath PreferredNavData;
};

// Size: 0x4
struct FNavAgentSelector {
    /* 0x0000 */ bool bSupportsAgent0;
    /* 0x0000 */ bool bSupportsAgent1;
    /* 0x0000 */ bool bSupportsAgent2;
    /* 0x0000 */ bool bSupportsAgent3;
    /* 0x0000 */ bool bSupportsAgent4;
    /* 0x0000 */ bool bSupportsAgent5;
    /* 0x0000 */ bool bSupportsAgent6;
    /* 0x0000 */ bool bSupportsAgent7;
    /* 0x0001 */ bool bSupportsAgent8;
    /* 0x0001 */ bool bSupportsAgent9;
    /* 0x0001 */ bool bSupportsAgent10;
    /* 0x0001 */ bool bSupportsAgent11;
    /* 0x0001 */ bool bSupportsAgent12;
    /* 0x0001 */ bool bSupportsAgent13;
    /* 0x0001 */ bool bSupportsAgent14;
    /* 0x0001 */ bool bSupportsAgent15;
};

// Size: 0x30
class UNavAreaBase : public UObject {
};

// Size: 0x58
struct FNavAvoidanceData {
};

// Size: 0x4
struct FNavAvoidanceMask {
    /* 0x0000 */ bool bGroup0;
    /* 0x0000 */ bool bGroup1;
    /* 0x0000 */ bool bGroup2;
    /* 0x0000 */ bool bGroup3;
    /* 0x0000 */ bool bGroup4;
    /* 0x0000 */ bool bGroup5;
    /* 0x0000 */ bool bGroup6;
    /* 0x0000 */ bool bGroup7;
    /* 0x0001 */ bool bGroup8;
    /* 0x0001 */ bool bGroup9;
    /* 0x0001 */ bool bGroup10;
    /* 0x0001 */ bool bGroup11;
    /* 0x0001 */ bool bGroup12;
    /* 0x0001 */ bool bGroup13;
    /* 0x0001 */ bool bGroup14;
    /* 0x0001 */ bool bGroup15;
    /* 0x0002 */ bool bGroup16;
    /* 0x0002 */ bool bGroup17;
    /* 0x0002 */ bool bGroup18;
    /* 0x0002 */ bool bGroup19;
    /* 0x0002 */ bool bGroup20;
    /* 0x0002 */ bool bGroup21;
    /* 0x0002 */ bool bGroup22;
    /* 0x0002 */ bool bGroup23;
    /* 0x0003 */ bool bGroup24;
    /* 0x0003 */ bool bGroup25;
    /* 0x0003 */ bool bGroup26;
    /* 0x0003 */ bool bGroup27;
    /* 0x0003 */ bool bGroup28;
    /* 0x0003 */ bool bGroup29;
    /* 0x0003 */ bool bGroup30;
    /* 0x0003 */ bool bGroup31;
};

// Size: 0x70
class UNavCollisionBase : public UObject {
    /* 0x0028 */ bool bIsDynamicObstacle;
};

// Size: 0x88
struct FNavDataConfig : public FNavAgentProperties {
    /* 0x0038 */ FName Name;
    /* 0x0040 */ FColor Color;
    /* 0x0048 */ FVector DefaultQueryExtent;
    /* 0x0060 */ TSoftClassPtr<AActor> NavDataClass;
};

// Size: 0x28
class INavEdgeProviderInterface : public UInterface {
};

// Size: 0x8
struct FNavLinkAuxiliaryId {
    /* 0x0000 */ uint64_t ID;
};

// Size: 0x50
class UNavLinkDefinition : public UObject {
    /* 0x0028 */ TArray<FNavigationLink> links;
    /* 0x0038 */ TArray<FNavigationSegmentLink> SegmentLinks;
};

// Size: 0x8
struct FNavLinkId {
    /* 0x0000 */ uint64_t ID;
};

// Size: 0x180
class UNavMovementComponent : public UMovementComponent {
    /* 0x0128 */ float FixedPathBrakingDistance;
    /* 0x012c */ bool bUpdateNavAgentWithOwnersCollision;
    /* 0x012c */ bool bUseAccelerationForPaths;
    /* 0x012c */ bool bUseFixedBrakingDistanceForPaths;
    /* 0x0130 */ FNavMovementProperties NavMovementProperties;
    /* 0x0138 */ FNavAgentProperties NavAgentProps;
    /* 0x0170 */ FMovementProperties MovementState;
    /* 0x0178 */ UObject* PathFollowingComp;

    FVector GetVelocityForNavMovement() const;
    bool IsCrouching() const;
    bool IsFalling() const;
    bool IsFlying() const;
    bool IsMovingOnGround() const;
    bool IsSwimming() const;
};

// Size: 0x28
class INavMovementInterface : public UInterface {

    float GetMaxSpeedForNavMovement() const;
    FVector GetVelocityForNavMovement() const;
    bool IsCrouching() const;
    bool IsFalling() const;
    bool IsFlying() const;
    bool IsMovingOnGround() const;
    bool IsSwimming() const;
    void RequestDirectMove(const FVector& MoveVelocity, bool bForceMaxSpeed);
    void RequestPathMove(const FVector& MoveInput);
    void StopActiveMovement();
    void StopMovementKeepPathing();
};

// Size: 0x8
struct FNavMovementProperties {
    /* 0x0000 */ float FixedPathBrakingDistance;
    /* 0x0004 */ bool bUpdateNavAgentWithOwnersCollision;
    /* 0x0005 */ bool bUseAccelerationForPaths;
    /* 0x0006 */ bool bUseFixedBrakingDistanceForPaths;
    /* 0x0007 */ bool bStopMovementAbortPaths;
};

// Size: 0x28
class INavPathObserverInterface : public UInterface {
};

// Size: 0x28
class INavRelevantInterface : public UInterface {
};

// Size: 0x30
class UNavigationDataChunk : public UObject {
    /* 0x0028 */ FName NavigationDataName;
};

// Size: 0x2f0
class ANavigationDataChunkActor : public APartitionActor {
    /* 0x02a8 */ TArray<UNavigationDataChunk*> NavDataChunks;
    /* 0x02b8 */ FBox DataChunkActorBounds;
};

// Size: 0x28
class INavigationDataInterface : public UInterface {
};

// Size: 0x28
class INavigationInvokerInterface : public UInterface {
};

// Size: 0x70
struct FNavigationLink : public FNavigationLinkBase {
    /* 0x0040 */ FVector Left;
    /* 0x0058 */ FVector Right;
};

// Size: 0x40
struct FNavigationLinkBase {
    /* 0x0000 */ float LeftProjectHeight;
    /* 0x0004 */ float MaxFallDownLength;
    /* 0x0018 */ float SnapRadius;
    /* 0x001c */ float SnapHeight;
    /* 0x0020 */ FNavAgentSelector SupportedAgents;
    /* 0x0024 */ bool bSupportsAgent0;
    /* 0x0024 */ bool bSupportsAgent1;
    /* 0x0024 */ bool bSupportsAgent2;
    /* 0x0024 */ bool bSupportsAgent3;
    /* 0x0024 */ bool bSupportsAgent4;
    /* 0x0024 */ bool bSupportsAgent5;
    /* 0x0024 */ bool bSupportsAgent6;
    /* 0x0024 */ bool bSupportsAgent7;
    /* 0x0025 */ bool bSupportsAgent8;
    /* 0x0025 */ bool bSupportsAgent9;
    /* 0x0025 */ bool bSupportsAgent10;
    /* 0x0025 */ bool bSupportsAgent11;
    /* 0x0025 */ bool bSupportsAgent12;
    /* 0x0025 */ bool bSupportsAgent13;
    /* 0x0025 */ bool bSupportsAgent14;
    /* 0x0025 */ bool bSupportsAgent15;
    /* 0x0028 */ uint8_t Direction;
    /* 0x0029 */ bool bUseSnapHeight;
    /* 0x0029 */ bool bSnapToCheapestArea;
    /* 0x0029 */ bool bCustomFlag0;
    /* 0x0029 */ bool bCustomFlag1;
    /* 0x0029 */ bool bCustomFlag2;
    /* 0x0029 */ bool bCustomFlag3;
    /* 0x0029 */ bool bCustomFlag4;
    /* 0x0029 */ bool bCustomFlag5;
    /* 0x002a */ bool bCustomFlag6;
    /* 0x002a */ bool bCustomFlag7;
    /* 0x0030 */ UClass* AreaClass;
};

// Size: 0x2d0
class ANavigationObjectBase : public AActor {
    /* 0x02b0 */ UCapsuleComponent* CapsuleComponent;
    /* 0x02b8 */ UBillboardComponent* GoodSprite;
    /* 0x02c0 */ UBillboardComponent* BadSprite;
    /* 0x02c8 */ bool bIsPIEPlayerStart;
};

// Size: 0xa0
struct FNavigationSegmentLink : public FNavigationLinkBase {
    /* 0x0040 */ FVector LeftStart;
    /* 0x0058 */ FVector LeftEnd;
    /* 0x0070 */ FVector RightStart;
    /* 0x0088 */ FVector RightEnd;
};

// Size: 0x28
class UNavigationSystemBase : public UObject {
};

// Size: 0x58
class UNavigationSystemConfig : public UObject {
    /* 0x0028 */ FSoftClassPath NavigationSystemClass;
    /* 0x0048 */ FNavAgentSelector SupportedAgentsMask;
    /* 0x004c */ FName DefaultAgentName;
    /* 0x0054 */ bool bIsOverriden;
};

// Size: 0xa0
class UNetActorFactory : public UNetObjectFactory {
};

// Size: 0x1e30
class UNetConnection : public UPlayer {
    /* 0x0048 */ TArray<UChildConnection*> Children;
    /* 0x0058 */ UNetDriver* Driver;
    /* 0x0060 */ UClass* PackageMapClass;
    /* 0x0068 */ UPackageMap* PackageMap;
    /* 0x0070 */ TArray<UChannel*> OpenChannels;
    /* 0x0080 */ TArray<AActor*> SentTemporaries;
    /* 0x0090 */ AActor* ViewTarget;
    /* 0x0098 */ AActor* OwningActor;
    /* 0x00a0 */ int32_t MaxPacket;
    /* 0x00a4 */ bool InternalAck;
    /* 0x0160 */ FUniqueNetIdRepl PlayerId;
    /* 0x01d8 */ double LastReceiveTime;
    /* 0x13e8 */ int32_t DefaultMaxChannelSize;
    /* 0x1710 */ TArray<UChannel*> ChannelsToTick;
};

// Size: 0x8f0
class UNetDriver : public UObject {
    /* 0x0030 */ FString NetConnectionClassName;
    /* 0x0040 */ FString ReplicationDriverClassName;
    /* 0x0050 */ FString ReplicationBridgeClassName;
    /* 0x0060 */ FNetDriverReplicationSystemConfig ReplicationSystemConfigServer;
    /* 0x007c */ FNetDriverReplicationSystemConfig ReplicationSystemConfigClient;
    /* 0x0098 */ int32_t MaxDownloadSize;
    /* 0x009c */ bool bClampListenServerTickRate;
    /* 0x00a0 */ int32_t NetServerMaxTickRate;
    /* 0x00c0 */ int32_t MaxNetTickRate;
    /* 0x00c4 */ int32_t MaxInternetClientRate;
    /* 0x00c8 */ int32_t MaxClientRate;
    /* 0x00cc */ float ServerTravelPause;
    /* 0x00d0 */ float SpawnPrioritySeconds;
    /* 0x00d4 */ float RelevantTimeout;
    /* 0x00d8 */ float KeepAliveTime;
    /* 0x00dc */ float InitialConnectTimeout;
    /* 0x00e0 */ float ConnectionTimeout;
    /* 0x00e4 */ float GracefulCloseConnectionTimeout;
    /* 0x00e8 */ float TimeoutMultiplierForUnoptimizedBuilds;
    /* 0x00f0 */ UNetConnection* ServerConnection;
    /* 0x00f8 */ TArray<UNetConnection*> ClientConnections;
    /* 0x0168 */ int32_t RecentlyDisconnectedTrackingTime;
    /* 0x01a8 */ UWorld* World;
    /* 0x01b0 */ UPackage* WorldPackage;
    /* 0x01d8 */ UClass* NetConnectionClass;
    /* 0x01e0 */ UClass* ReplicationDriverClass;
    /* 0x01e8 */ UClass* ReplicationBridgeClass;
    /* 0x0200 */ FName NetDriverName;
    /* 0x0208 */ TArray<FChannelDefinition> ChannelDefinitions;
    /* 0x0218 */ TMap<FName, FChannelDefinition> ChannelDefinitionMap;
    /* 0x0268 */ TArray<UChannel*> ActorChannelPool;
    /* 0x0288 */ UNetworkMetricsDatabase* NetworkMetricsDatabase;
    /* 0x0290 */ TMap<FName, UNetworkMetricsBaseListener*> NetworkMetricsListeners;
    /* 0x0309 */ bool bNoTimeouts;
    /* 0x0309 */ bool bNeverApplyNetworkEmulationSettings;
    /* 0x0850 */ UReplicationDriver* ReplicationDriver;
};

// Size: 0x1c
struct FNetDriverDefinition {
    /* 0x0000 */ FName DefName;
    /* 0x0008 */ FName DriverClassName;
    /* 0x0010 */ FName DriverClassNameFallback;
    /* 0x0018 */ int32_t MaxChannelsOverride;
};

// Size: 0x1c
struct FNetDriverReplicationSystemConfig {
    /* 0x0000 */ uint32_t MaxReplicatedObjectCount;
    /* 0x0004 */ uint32_t InitialNetObjectListCount;
    /* 0x0008 */ uint32_t NetObjectListGrowCount;
    /* 0x000c */ uint32_t PreAllocatedMemoryBuffersObjectCount;
    /* 0x0010 */ uint32_t MaxReplicationWriterObjectCount;
    /* 0x0014 */ uint32_t MaxDeltaCompressedObjectCount;
    /* 0x0018 */ uint32_t MaxNetObjectGroupCount;
};

// Size: 0x88
class UNetFaultConfig : public UEscalationManagerConfig {
};

// Size: 0x4
struct FNetLevelVisibilityTransactionId {
    /* 0x0000 */ uint32_t Data;
};

// Size: 0x28
class UNetPushModelHelpers : public UBlueprintFunctionLibrary {

    static void MarkPropertyDirty(UObject* Object, FName PropertyName);
    static void MarkPropertyDirtyFromRepIndex(UObject* Object, int32_t RepIndex, FName PropertyName);
};

// Size: 0x38
class UNetSubObjectFactory : public UNetObjectFactory {
};

// Size: 0x48
struct FNetViewer {
    /* 0x0000 */ UNetConnection* Connection;
    /* 0x0008 */ AActor* InViewer;
    /* 0x0010 */ AActor* ViewTarget;
    /* 0x0018 */ FVector ViewLocation;
    /* 0x0030 */ FVector ViewDir;
};

// Size: 0x20
struct FNetworkEmulationProfileDescription {
    /* 0x0000 */ FString ProfileName;
    /* 0x0010 */ FString Tooltip;
};

// Size: 0x38
struct FNetworkMetricConfig {
    /* 0x0000 */ FName MetricName;
    /* 0x0008 */ TSoftClassPtr<UNetworkMetricsBaseListener> Class;
    /* 0x0030 */ ENetworkMetricEnableMode EnableMode;
};

// Size: 0x30
class UNetworkMetricsBaseListener : public UObject {
    /* 0x0028 */ double IntervalSeconds;
};

// Size: 0x38
class UNetworkMetricsCSV : public UNetworkMetricsBaseListener {
};

// Size: 0x38
class UNetworkMetricsCSV_Replication : public UNetworkMetricsCSV {
};

// Size: 0x38
class UNetworkMetricsConfig : public UObject {
    /* 0x0028 */ TArray<FNetworkMetricConfig> Listeners;
};

// Size: 0x1b8
class UNetworkMetricsDatabase : public UObject {
};

// Size: 0x30
class UNetworkMetricsPerfCounters : public UNetworkMetricsBaseListener {
};

// Size: 0x38
class UNetworkMetricsStats : public UNetworkMetricsBaseListener {
};

// Size: 0x208
class UNetworkPhysicsComponent : public UActorComponent {
    /* 0x00b8 */ FNetworkPhysicsRewindDataDeltaSourceInputProxy ReplicatedDeltaSourceInput;
    /* 0x00d0 */ FNetworkPhysicsRewindDataDeltaSourceStateProxy ReplicatedDeltaSourceState;
    /* 0x00e8 */ FNetworkPhysicsRewindDataImportantInputProxy ReplicatedImportantInput;
    /* 0x0100 */ FNetworkPhysicsRewindDataImportantStateProxy ReplicatedImportantState;
    /* 0x0118 */ FNetworkPhysicsRewindDataInputProxy ReplicatedInputs;
    /* 0x0130 */ FNetworkPhysicsRewindDataRemoteInputProxy ReplicatedRemoteInputs;
    /* 0x0148 */ FNetworkPhysicsRewindDataStateProxy ReplicatedStates;
    /* 0x01a8 */ uint16_t InputsToNetwork_Owner;

    void MulticastReceiveImportantInputData(const FNetworkPhysicsRewindDataImportantInputProxy ServerInputs);
    void MulticastReceiveImportantStateData(const FNetworkPhysicsRewindDataImportantStateProxy ServerStates);
    void OnRep_SetReplicatedDeltaSourceInput();
    void OnRep_SetReplicatedDeltaSourceState();
    void OnRep_SetReplicatedInputs();
    void OnRep_SetReplicatedRemoteInputs();
    void OnRep_SetReplicatedStates();
    void ServerReceiveDeltaSourceInputFrame(const int32_t Frame);
    void ServerReceiveDeltaSourceStateFrame(const int32_t Frame);
    void ServerReceiveImportantInputData(const FNetworkPhysicsRewindDataImportantInputProxy ClientInputs);
    void ServerReceiveInputData(const FNetworkPhysicsRewindDataInputProxy ClientInputs);
};

// Size: 0x28
struct FNetworkPhysicsData {
    /* 0x0008 */ int32_t ServerFrame;
    /* 0x000c */ int32_t LocalFrame;
};

// Size: 0x18
struct FNetworkPhysicsRewindDataDeltaSourceInputProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataDeltaSourceStateProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataImportantInputProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataImportantStateProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataInputProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataProxy {
    /* 0x0008 */ UNetworkPhysicsComponent* Owner;
};

// Size: 0x18
struct FNetworkPhysicsRewindDataRemoteInputProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x18
struct FNetworkPhysicsRewindDataStateProxy : public FNetworkPhysicsRewindDataProxy {
};

// Size: 0x8
struct FNetworkPhysicsSettings {
    /* 0x0000 */ bool bOverrideSimProxyRepMode;
    /* 0x0004 */ EPhysicsReplicationMode SimProxyRepMode;
    /* 0x0005 */ bool bFocalParticleInPhysicsReplicationLOD;
};

// Size: 0x2d0
class UNetworkPhysicsSettingsComponent : public UActorComponent {
    /* 0x00b8 */ FNetworkPhysicsSettings GeneralSettings;
    /* 0x00c0 */ FNetworkPhysicsSettingsDefaultReplication DefaultReplicationSettings;
    /* 0x00e0 */ FNetworkPhysicsSettingsPredictiveInterpolation PredictiveInterpolationSettings;
    /* 0x0160 */ FNetworkPhysicsSettingsResimulation ResimulationSettings;
    /* 0x01d8 */ FNetworkPhysicsSettingsNetworkPhysicsComponent NetworkPhysicsComponentSettings;

    void OnComponentPhysicsStateChanged(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
};

// Size: 0x20
struct FNetworkPhysicsSettingsDefaultReplication {
    /* 0x0000 */ bool bOverrideMaxLinearHardSnapDistance;
    /* 0x0004 */ float MaxLinearHardSnapDistance;
    /* 0x0008 */ bool bOverrideDefaultLegacyHardsnapInPT;
    /* 0x000c */ bool bHardsnapInPhysicsThread;
    /* 0x0010 */ bool bOverrideCorrectConnectedBodies;
    /* 0x0014 */ bool bCorrectConnectedBodies;
    /* 0x0018 */ bool bOverrideCorrectConnectedBodiesFriction;
    /* 0x001c */ bool bCorrectConnectedBodiesFriction;
};

// Size: 0xf0
struct FNetworkPhysicsSettingsNetworkPhysicsComponent {
    /* 0x0000 */ bool bOverrideRedundantInputs;
    /* 0x0004 */ uint16_t RedundantInputs;
    /* 0x0008 */ bool bOverrideRedundantRemoteInputs;
    /* 0x000c */ uint16_t RedundantRemoteInputs;
    /* 0x0010 */ bool bOverrideRedundantStates;
    /* 0x0014 */ uint16_t RedundantStates;
    /* 0x0018 */ bool bOverrideCompareStateToTriggerRewind;
    /* 0x001c */ bool bCompareStateToTriggerRewind;
    /* 0x0020 */ bool bOverridebCompareStateToTriggerRewindIncludeSimProxies;
    /* 0x0024 */ bool bCompareStateToTriggerRewindIncludeSimProxies;
    /* 0x0028 */ bool bOverrideCompareInputToTriggerRewind;
    /* 0x002c */ bool bCompareInputToTriggerRewind;
    /* 0x0030 */ bool bOverrideEnableUnreliableFlow;
    /* 0x0034 */ bool bEnableUnreliableFlow;
    /* 0x0038 */ bool bOverrideEnableReliableFlow;
    /* 0x003c */ bool bEnableReliableFlow;
    /* 0x0040 */ bool bOverrideApplyDataInsteadOfMergeData;
    /* 0x0044 */ bool bApplyDataInsteadOfMergeData;
    /* 0x0048 */ bool bOverrideAllowInputExtrapolation;
    /* 0x004c */ bool bAllowInputExtrapolation;
    /* 0x0050 */ bool bOverrideValidateDataOnGameThread;
    /* 0x0054 */ bool bValidateDataOnGameThread;
    /* 0x0058 */ bool bOverrideApplySimProxyStateAtRuntime;
    /* 0x005c */ bool bApplySimProxyStateAtRuntime;
    /* 0x0060 */ bool bOverrideApplySimProxyInputAtRuntime;
    /* 0x0064 */ bool bApplySimProxyInputAtRuntime;
    /* 0x0068 */ FRuntimeFloatCurve InputDecayCurve;
};

// Size: 0x80
struct FNetworkPhysicsSettingsPredictiveInterpolation {
    /* 0x0000 */ bool bOverridePosCorrectionTimeBase;
    /* 0x0004 */ float PosCorrectionTimeBase;
    /* 0x0008 */ bool bOverridePosCorrectionTimeMin;
    /* 0x000c */ float PosCorrectionTimeMin;
    /* 0x0010 */ bool bOverridePosCorrectionTimeMultiplier;
    /* 0x0014 */ float PosCorrectionTimeMultiplier;
    /* 0x0018 */ bool bOverrideRotCorrectionTimeBase;
    /* 0x001c */ float RotCorrectionTimeBase;
    /* 0x0020 */ bool bOverrideRotCorrectionTimeMin;
    /* 0x0024 */ float RotCorrectionTimeMin;
    /* 0x0028 */ bool bOverrideRotCorrectionTimeMultiplier;
    /* 0x002c */ float RotCorrectionTimeMultiplier;
    /* 0x0030 */ bool bOverridePosInterpolationTimeMultiplier;
    /* 0x0034 */ float PosInterpolationTimeMultiplier;
    /* 0x0038 */ bool bOverrideRotInterpolationTimeMultiplier;
    /* 0x003c */ float RotInterpolationTimeMultiplier;
    /* 0x0040 */ bool bOverrideSoftSnapPosStrength;
    /* 0x0044 */ float SoftSnapPosStrength;
    /* 0x0048 */ bool bOverrideSoftSnapRotStrength;
    /* 0x004c */ float SoftSnapRotStrength;
    /* 0x0050 */ bool bOverrideSoftSnapToSource;
    /* 0x0054 */ bool bSoftSnapToSource;
    /* 0x0058 */ bool bOverrideDisableSoftSnap;
    /* 0x005c */ bool bDisableSoftSnap;
    /* 0x0060 */ bool bOverrideSkipVelocityRepOnPosEarlyOut;
    /* 0x0064 */ bool bSkipVelocityRepOnPosEarlyOut;
    /* 0x0068 */ bool bOverridePostResimWaitForUpdate;
    /* 0x006c */ bool bPostResimWaitForUpdate;
    /* 0x0070 */ bool bOverrideCorrectConnectedBodies;
    /* 0x0074 */ bool bCorrectConnectedBodies;
    /* 0x0078 */ bool bOverrideCorrectConnectedBodiesFriction;
    /* 0x007c */ bool bCorrectConnectedBodiesFriction;
};

// Size: 0x74
struct FNetworkPhysicsSettingsResimulation {
    /* 0x0000 */ uint32_t bOverrideResimulationErrorThreshold;
    /* 0x0004 */ uint32_t ResimulationErrorThreshold;
    /* 0x0008 */ bool bOverrideResimulationErrorPositionThreshold;
    /* 0x000c */ float ResimulationErrorPositionThreshold;
    /* 0x0010 */ bool bOverrideResimulationErrorRotationThreshold;
    /* 0x0014 */ float ResimulationErrorRotationThreshold;
    /* 0x0018 */ bool bOverrideResimulationErrorLinearVelocityThreshold;
    /* 0x001c */ float ResimulationErrorLinearVelocityThreshold;
    /* 0x0020 */ bool bOverrideResimulationErrorAngularVelocityThreshold;
    /* 0x0024 */ float ResimulationErrorAngularVelocityThreshold;
    /* 0x0028 */ bool bOverrideRuntimeCorrectionEnabled;
    /* 0x002c */ bool bRuntimeCorrectionEnabled;
    /* 0x0030 */ bool bOverrideRuntimeVelocityCorrection;
    /* 0x0034 */ bool bRuntimeVelocityCorrection;
    /* 0x0038 */ bool bOverrideRuntimeCorrectConnectedBodies;
    /* 0x003c */ bool bRuntimeCorrectConnectedBodies;
    /* 0x0040 */ bool bOverridePosStabilityMultiplier;
    /* 0x0044 */ float PosStabilityMultiplier;
    /* 0x0048 */ bool bOverrideRotStabilityMultiplier;
    /* 0x004c */ float RotStabilityMultiplier;
    /* 0x0050 */ bool bOverrideVelStabilityMultiplier;
    /* 0x0054 */ float VelStabilityMultiplier;
    /* 0x0058 */ bool bOverrideAngVelStabilityMultiplier;
    /* 0x005c */ float AngVelStabilityMultiplier;
    /* 0x0060 */ FNetworkPhysicsSettingsResimulationErrorCorrection ResimulationErrorCorrectionSettings;
};

// Size: 0x14
struct FNetworkPhysicsSettingsResimulationErrorCorrection {
    /* 0x0000 */ bool bOverrideResimErrorInterpolationSettings;
    /* 0x0004 */ float ResimErrorCorrectionDuration;
    /* 0x0008 */ float ResimErrorMaximumDistanceBeforeSnapping;
    /* 0x000c */ float ResimErrorMaximumDesyncTimeBeforeSnapping;
    /* 0x0010 */ float ResimErrorDirectionalDecayMultiplier;
};

// Size: 0x30
class UNetworkPhysicsSystem : public UWorldSubsystem {
};

// Size: 0x28
class INetworkPredictionInterface : public UInterface {
};

// Size: 0x50
class UNetworkSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bVerifyPeer;
    /* 0x0038 */ bool bEnableMultiplayerWorldOriginRebasing;
    /* 0x0040 */ TArray<FNetworkEmulationProfileDescription> NetworkEmulationProfiles;
};

// Size: 0x80
class UNetworkSubsystem : public UWorldSubsystem {
};

// Size: 0x80
class UNeuralProfile : public UObject {
    /* 0x0028 */ FNeuralProfileStruct Settings;
    /* 0x0070 */ FGuid Guid;
};

// Size: 0x48
struct FNeuralProfileStruct {
    /* 0x0000 */ ENeuralProfileFormat InputFormat;
    /* 0x0001 */ ENeuralProfileFormat OutputFormat;
    /* 0x0002 */ ENeuralProfileRuntimeType RuntimeType;
    /* 0x0008 */ UObject* NNEModelData;
    /* 0x0010 */ FIntVector4 InputDimension;
    /* 0x0020 */ FIntVector4 OutputDimension;
    /* 0x0030 */ int32_t BatchSizeOverride;
    /* 0x0034 */ ENeuralModelTileType TileSize;
    /* 0x0038 */ FIntPoint TileOverlap;
    /* 0x0040 */ ETileOverlapResolveType TileOverlapResolveType;
};

// Size: 0x48
struct FNewLevelInstanceParams {
    /* 0x0000 */ ELevelInstanceCreationType Type;
    /* 0x0001 */ ELevelInstancePivotType PivotType;
    /* 0x0008 */ AActor* PivotActor;
    /* 0x0010 */ bool bAlwaysShowDialog;
    /* 0x0018 */ UWorld* TemplateWorld;
    /* 0x0020 */ FString LevelPackageName;
    /* 0x0030 */ bool bPromptForSave;
    /* 0x0038 */ UClass* LevelInstanceClass;
    /* 0x0040 */ bool bEnableStreaming;
    /* 0x0041 */ bool bExternalActors;
    /* 0x0042 */ bool bForceExternalActors;
    /* 0x0043 */ bool bHideCreationType;
};

// Size: 0x738
class ANoPawnPlayerController : public APlayerController {
};

// Size: 0x70
struct FNodeItem {
    /* 0x0000 */ FName ParentName;
    /* 0x0010 */ FTransform Transform;
};

// Size: 0x168
class UNodeMappingContainer : public UObject {
    /* 0x0028 */ TMap<FName, FNodeItem> SourceItems;
    /* 0x0078 */ TMap<FName, FNodeItem> TargetItems;
    /* 0x00c8 */ TMap<FName, FName> SourceToTarget;
    /* 0x0118 */ TSoftObjectPtr<UObject> SourceAsset;
    /* 0x0140 */ TSoftObjectPtr<UObject> TargetAsset;
};

// Size: 0x28
class INodeMappingProviderInterface : public UInterface {
};

// Size: 0x14
struct FNodeToCodeAssociation {
};

// Size: 0x4
struct FNonBlendableFloatAnimationAttribute : public FFloatAnimationAttribute {
};

// Size: 0x4
struct FNonBlendableIntegerAnimationAttribute : public FIntegerAnimationAttribute {
};

// Size: 0x20
struct FNonBlendableQuaternionAnimationAttribute : public FQuaternionAnimationAttribute {
};

// Size: 0x60
struct FNonBlendableTransformAnimationAttribute : public FTransformAnimationAttribute {
};

// Size: 0x18
struct FNonBlendableVectorAnimationAttribute : public FVectorAnimationAttribute {
};

// Size: 0x2a8
class ANote : public AActor {
};

// Size: 0x28
class UNullHLODBuilder : public UHLODBuilder {
};

// Size: 0x58
class UNullNavSysConfig : public UNavigationSystemConfig {
};

// Size: 0x30
class UObjectElementAssetDataInterface : public UObject {
};

// Size: 0x30
class UObjectElementCounterInterface : public UObject {
};

// Size: 0x30
class UObjectElementObjectInterface : public UObject {
};

// Size: 0x30
class UObjectElementSelectionInterface : public UObject {
};

// Size: 0xa8
class UObjectLibrary : public UObject {
    /* 0x0028 */ UClass* ObjectBaseClass;
    /* 0x0030 */ bool bHasBlueprintClasses;
    /* 0x0038 */ TArray<UObject*> Objects;
    /* 0x0048 */ TArray<TWeakObjectPtr<UObject>> WeakObjects;
    /* 0x0058 */ bool bUseWeakReferences;
    /* 0x0059 */ bool bIsFullyLoaded;
};

// Size: 0x38
class UObjectReferencer : public UObject {
    /* 0x0028 */ TArray<UObject*> ReferencedObjects;
};

// Size: 0x40
class UObjectTraceWorldSubsystem : public UWorldSubsystem {
};

// Size: 0x30
class UOnlineBlueprintCallProxyBase : public UBlueprintAsyncActionBase {
};

// Size: 0x28
class UOnlineEngineInterface : public UObject {
};

// Size: 0x28
class UOnlineSession : public UObject {
};

// Size: 0x4
struct FOrbitOptions {
    /* 0x0000 */ bool bProcessDuringSpawn;
    /* 0x0000 */ bool bProcessDuringUpdate;
    /* 0x0000 */ bool bUseEmitterTime;
};

// Size: 0x108
struct FOverlapInfo {
    /* 0x0000 */ bool bFromSweep;
    /* 0x0008 */ FHitResult OverlapInfo;
};

// Size: 0x48
struct FOverlapResult {
    /* 0x0000 */ FActorInstanceHandle OverlapObjectHandle;
    /* 0x0020 */ TWeakObjectPtr<UPrimitiveComponent> Component;
    /* 0x0040 */ bool bBlockingHit;
};

// Size: 0x38
struct FOverrideAtmosphericLight {
    /* 0x0000 */ uint8_t EnabledMask;
    /* 0x0008 */ FVector Direction[2];
};

// Size: 0x38
struct FPOV {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ float FOV;
};

// Size: 0x10
struct FPSCPool {
    /* 0x0000 */ TArray<FPSCPoolElem> FreeElements;
};

// Size: 0x10
struct FPSCPoolElem {
    /* 0x0000 */ UParticleSystemComponent* PSC;
};

// Size: 0x4b8
class UPackageMapClient : public UPackageMap {
};

// Size: 0x348
class APackedLevelActor : public ALevelInstance {
};

// Size: 0x3c
struct FPacketSimulationSettings {
    /* 0x0000 */ int32_t PktLoss;
    /* 0x0004 */ int32_t PktLossMaxSize;
    /* 0x0008 */ int32_t PktLossMinSize;
    /* 0x000c */ int32_t PktOrder;
    /* 0x0010 */ int32_t PktDup;
    /* 0x0014 */ int32_t PktLag;
    /* 0x0018 */ int32_t PktLagVariance;
    /* 0x001c */ int32_t PktLagMin;
    /* 0x0020 */ int32_t PktLagMax;
    /* 0x0024 */ int32_t PktIncomingLagMin;
    /* 0x0028 */ int32_t PktIncomingLagMax;
    /* 0x002c */ int32_t PktIncomingLoss;
    /* 0x0030 */ int32_t PktJitter;
    /* 0x0034 */ int32_t PktFrameDelay;
    /* 0x0038 */ int32_t PktIncomingFrameDelay;
};

// Size: 0x318
class APainCausingVolume : public APhysicsVolume {
    /* 0x02f0 */ bool bPainCausing;
    /* 0x02f4 */ float DamagePerSec;
    /* 0x02f8 */ UClass* DamageType;
    /* 0x0300 */ float PainInterval;
    /* 0x0304 */ bool bEntryPain;
    /* 0x0304 */ bool BACKUP_bPainCausing;
    /* 0x0308 */ AController* DamageInstigator;
};

// Size: 0x40
struct FPaintedVertex {
    /* 0x0000 */ FVector position;
    /* 0x0018 */ FColor Color;
    /* 0x0020 */ FVector4 Normal;
};

// Size: 0x40
struct FParameterChannelNames {
    /* 0x0000 */ FText R;
    /* 0x0010 */ FText G;
    /* 0x0020 */ FText B;
    /* 0x0030 */ FText A;
};

// Size: 0x18
struct FParameterGroupData {
    /* 0x0000 */ FString GroupName;
    /* 0x0010 */ int32_t GroupSortPriority;
};

// Size: 0xc
struct FParticleBurst {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t CountLow;
    /* 0x0008 */ float Time;
};

// Size: 0x18
struct FParticleCurvePair {
    /* 0x0000 */ FString CurveName;
    /* 0x0010 */ UObject* CurveObject;
};

// Size: 0x10
struct FParticleEditorPromotionSettings {
    /* 0x0000 */ FFilePath DefaultParticleAsset;
};

// Size: 0x1c0
class UParticleEmitter : public UObject {
    /* 0x0028 */ FName EmitterName;
    /* 0x0030 */ int32_t SubUVDataOffset;
    /* 0x0034 */ uint8_t EmitterRenderMode;
    /* 0x0035 */ EParticleSignificanceLevel SignificanceLevel;
    /* 0x0037 */ bool bUseLegacySpawningBehavior;
    /* 0x0037 */ bool ConvertedModules;
    /* 0x0037 */ bool bIsSoloing;
    /* 0x0037 */ bool bCookedOut;
    /* 0x0037 */ bool bDisabledLODsKeepEmitterAlive;
    /* 0x0038 */ bool bDisableWhenInsignficant;
    /* 0x0040 */ TArray<UParticleLODLevel*> LODLevels;
    /* 0x0050 */ int32_t PeakActiveParticles;
    /* 0x0054 */ int32_t InitialAllocationCount;
    /* 0x0058 */ float QualityLevelSpawnRateScale;
    /* 0x005c */ uint32_t DetailModeBitmask;
};

// Size: 0x10
struct FParticleEmitterReplayFrame {
};

// Size: 0x2a8
class AParticleEventManager : public AActor {
};

// Size: 0x28
struct FParticleEvent_GenerateInfo {
    /* 0x0000 */ uint8_t Type;
    /* 0x0004 */ int32_t Frequency;
    /* 0x0008 */ int32_t ParticleFrequency;
    /* 0x000c */ bool FirstTimeOnly;
    /* 0x000c */ bool LastTimeOnly;
    /* 0x000c */ bool UseReflectedImpactVector;
    /* 0x000c */ bool bUseOrbitOffset;
    /* 0x0010 */ FName CustomName;
    /* 0x0018 */ TArray<UParticleModuleEventSendToGame*> ParticleModuleEventsToSendToGame;
};

// Size: 0xb8
class UParticleLODLevel : public UObject {
    /* 0x0028 */ int32_t Level;
    /* 0x002c */ bool bEnabled;
    /* 0x0030 */ UParticleModuleRequired* RequiredModule;
    /* 0x0038 */ TArray<UParticleModule*> Modules;
    /* 0x0048 */ UParticleModuleTypeDataBase* TypeDataModule;
    /* 0x0050 */ UParticleModuleSpawn* SpawnModule;
    /* 0x0058 */ UParticleModuleEventGenerator* EventGenerator;
    /* 0x0060 */ TArray<UParticleModuleSpawnBase*> SpawningModules;
    /* 0x0070 */ TArray<UParticleModule*> SpawnModules;
    /* 0x0080 */ TArray<UParticleModule*> UpdateModules;
    /* 0x0090 */ TArray<UParticleModuleOrbit*> OrbitModules;
    /* 0x00a0 */ TArray<UParticleModuleEventReceiverBase*> EventReceiverModules;
    /* 0x00b0 */ bool ConvertedModules;
    /* 0x00b4 */ int32_t PeakActiveParticles;
};

// Size: 0x30
class UParticleModule : public UObject {
    /* 0x0028 */ bool bSpawnModule;
    /* 0x0028 */ bool bUpdateModule;
    /* 0x0028 */ bool bFinalUpdateModule;
    /* 0x0028 */ bool bUpdateForGPUEmitter;
    /* 0x0028 */ bool bCurvesAsColor;
    /* 0x0028 */ bool b3DDrawMode;
    /* 0x0028 */ bool bSupported3DDrawMode;
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ bool bEditable;
    /* 0x0029 */ bool LODDuplicate;
    /* 0x0029 */ bool bSupportsRandomSeed;
    /* 0x0029 */ bool bRequiresLoopingNotification;
    /* 0x002a */ uint8_t LODValidity;
};

// Size: 0xa0
class UParticleModuleAcceleration : public UParticleModuleAccelerationBase {
    /* 0x0038 */ FRawDistributionVector Acceleration;
    /* 0x0098 */ bool bApplyOwnerScale;
};

// Size: 0x38
class UParticleModuleAccelerationBase : public UParticleModule {
    /* 0x0030 */ bool bAlwaysInWorldSpace;
};

// Size: 0x50
class UParticleModuleAccelerationConstant : public UParticleModuleAccelerationBase {
    /* 0x0038 */ FVector Acceleration;
};

// Size: 0x70
class UParticleModuleAccelerationDrag : public UParticleModuleAccelerationBase {
    /* 0x0038 */ UDistributionFloat* DragCoefficient;
    /* 0x0040 */ FRawDistributionFloat DragCoefficientRaw;
};

// Size: 0x70
class UParticleModuleAccelerationDragScaleOverLife : public UParticleModuleAccelerationBase {
    /* 0x0038 */ UDistributionFloat* DragScale;
    /* 0x0040 */ FRawDistributionFloat DragScaleRaw;
};

// Size: 0x98
class UParticleModuleAccelerationOverLifetime : public UParticleModuleAccelerationBase {
    /* 0x0038 */ FRawDistributionVector AccelOverLife;
};

// Size: 0x30
class UParticleModuleAttractorBase : public UParticleModule {
};

// Size: 0xc0
class UParticleModuleAttractorLine : public UParticleModuleAttractorBase {
    /* 0x0030 */ FVector EndPoint0;
    /* 0x0048 */ FVector EndPoint1;
    /* 0x0060 */ FRawDistributionFloat Range;
    /* 0x0090 */ FRawDistributionFloat Strength;
};

// Size: 0xb0
class UParticleModuleAttractorParticle : public UParticleModuleAttractorBase {
    /* 0x0030 */ FName EmitterName;
    /* 0x0038 */ FRawDistributionFloat Range;
    /* 0x0068 */ bool bStrengthByDistance;
    /* 0x0070 */ FRawDistributionFloat Strength;
    /* 0x00a0 */ bool bAffectBaseVelocity;
    /* 0x00a4 */ uint8_t SelectionMethod;
    /* 0x00a8 */ bool bRenewSource;
    /* 0x00a8 */ bool bInheritSourceVel;
    /* 0x00ac */ int32_t LastSelIndex;
};

// Size: 0xf8
class UParticleModuleAttractorPoint : public UParticleModuleAttractorBase {
    /* 0x0030 */ FRawDistributionVector position;
    /* 0x0090 */ FRawDistributionFloat Range;
    /* 0x00c0 */ FRawDistributionFloat Strength;
    /* 0x00f0 */ bool StrengthByDistance;
    /* 0x00f0 */ bool bAffectBaseVelocity;
    /* 0x00f0 */ bool bOverrideVelocity;
    /* 0x00f0 */ bool bUseWorldSpacePosition;
    /* 0x00f0 */ bool Positive_X;
    /* 0x00f0 */ bool Positive_Y;
    /* 0x00f0 */ bool Positive_Z;
    /* 0x00f0 */ bool Negative_X;
    /* 0x00f1 */ bool Negative_Y;
    /* 0x00f1 */ bool Negative_Z;
};

// Size: 0x88
class UParticleModuleAttractorPointGravity : public UParticleModuleAttractorBase {
    /* 0x0030 */ FVector position;
    /* 0x0048 */ float Radius;
    /* 0x0050 */ UDistributionFloat* Strength;
    /* 0x0058 */ FRawDistributionFloat StrengthRaw;
};

// Size: 0x30
class UParticleModuleBeamBase : public UParticleModule {
};

// Size: 0x138
class UParticleModuleBeamModifier : public UParticleModuleBeamBase {
    /* 0x0030 */ uint8_t ModifierType;
    /* 0x0034 */ FBeamModifierOptions PositionOptions;
    /* 0x0038 */ FRawDistributionVector position;
    /* 0x0098 */ FBeamModifierOptions TangentOptions;
    /* 0x00a0 */ FRawDistributionVector Tangent;
    /* 0x0100 */ bool bAbsoluteTangent;
    /* 0x0104 */ FBeamModifierOptions StrengthOptions;
    /* 0x0108 */ FRawDistributionFloat Strength;
};

// Size: 0x1c0
class UParticleModuleBeamNoise : public UParticleModuleBeamBase {
    /* 0x0030 */ bool bLowFreq_Enabled;
    /* 0x0034 */ int32_t Frequency;
    /* 0x0038 */ int32_t Frequency_LowRange;
    /* 0x0040 */ FRawDistributionVector NoiseRange;
    /* 0x00a0 */ FRawDistributionFloat NoiseRangeScale;
    /* 0x00d0 */ bool bNRScaleEmitterTime;
    /* 0x00d8 */ FRawDistributionVector NoiseSpeed;
    /* 0x0138 */ bool bSmooth;
    /* 0x013c */ float NoiseLockRadius;
    /* 0x0140 */ bool bNoiseLock;
    /* 0x0140 */ bool bOscillate;
    /* 0x0144 */ float NoiseLockTime;
    /* 0x0148 */ float NoiseTension;
    /* 0x014c */ bool bUseNoiseTangents;
    /* 0x0150 */ FRawDistributionFloat NoiseTangentStrength;
    /* 0x0180 */ int32_t NoiseTessellation;
    /* 0x0184 */ bool bTargetNoise;
    /* 0x0188 */ float FrequencyDistance;
    /* 0x018c */ bool bApplyNoiseScale;
    /* 0x0190 */ FRawDistributionFloat NoiseScale;
};

// Size: 0x148
class UParticleModuleBeamSource : public UParticleModuleBeamBase {
    /* 0x0030 */ uint8_t SourceMethod;
    /* 0x0034 */ FName SourceName;
    /* 0x003c */ bool bSourceAbsolute;
    /* 0x0040 */ FRawDistributionVector Source;
    /* 0x00a0 */ bool bLockSource;
    /* 0x00a4 */ uint8_t SourceTangentMethod;
    /* 0x00a8 */ FRawDistributionVector SourceTangent;
    /* 0x0108 */ bool bLockSourceTangent;
    /* 0x0110 */ FRawDistributionFloat SourceStrength;
    /* 0x0140 */ bool bLockSourceStength;
};

// Size: 0x150
class UParticleModuleBeamTarget : public UParticleModuleBeamBase {
    /* 0x0030 */ uint8_t TargetMethod;
    /* 0x0034 */ FName TargetName;
    /* 0x0040 */ FRawDistributionVector Target;
    /* 0x00a0 */ bool bTargetAbsolute;
    /* 0x00a0 */ bool bLockTarget;
    /* 0x00a4 */ uint8_t TargetTangentMethod;
    /* 0x00a8 */ FRawDistributionVector TargetTangent;
    /* 0x0108 */ bool bLockTargetTangent;
    /* 0x0110 */ FRawDistributionFloat TargetStrength;
    /* 0x0140 */ bool bLockTargetStength;
    /* 0x0144 */ float LockRadius;
};

// Size: 0x30
class UParticleModuleCameraBase : public UParticleModule {
};

// Size: 0x68
class UParticleModuleCameraOffset : public UParticleModuleCameraBase {
    /* 0x0030 */ FRawDistributionFloat CameraOffset;
    /* 0x0060 */ bool bSpawnTimeOnly;
    /* 0x0064 */ uint8_t UpdateMethod;
};

// Size: 0x1c0
class UParticleModuleCollision : public UParticleModuleCollisionBase {
    /* 0x0030 */ FRawDistributionVector DampingFactor;
    /* 0x0090 */ FRawDistributionVector DampingFactorRotation;
    /* 0x00f0 */ FRawDistributionFloat MaxCollisions;
    /* 0x0120 */ uint8_t CollisionCompletionOption;
    /* 0x0128 */ TArray<uint8_t> CollisionTypes;
    /* 0x0140 */ bool bApplyPhysics;
    /* 0x0140 */ bool bIgnoreTriggerVolumes;
    /* 0x0148 */ FRawDistributionFloat ParticleMass;
    /* 0x0178 */ float DirScalar;
    /* 0x017c */ bool bPawnsDoNotDecrementCount;
    /* 0x017c */ bool bOnlyVerticalNormalsDecrementCount;
    /* 0x0180 */ float VerticalFudgeFactor;
    /* 0x0188 */ FRawDistributionFloat DelayAmount;
    /* 0x01b8 */ bool bDropDetail;
    /* 0x01b8 */ bool bCollideOnlyIfVisible;
    /* 0x01b8 */ bool bIgnoreSourceActor;
    /* 0x01bc */ float MaxCollisionDistance;
};

// Size: 0x30
class UParticleModuleCollisionBase : public UParticleModule {
};

// Size: 0xa8
class UParticleModuleCollisionGPU : public UParticleModuleCollisionBase {
    /* 0x0030 */ FRawDistributionFloat Resilience;
    /* 0x0060 */ FRawDistributionFloat ResilienceScaleOverLife;
    /* 0x0090 */ float Friction;
    /* 0x0094 */ float RandomSpread;
    /* 0x0098 */ float RandomDistribution;
    /* 0x009c */ float RadiusScale;
    /* 0x00a0 */ float RadiusBias;
    /* 0x00a4 */ uint8_t Response;
    /* 0x00a5 */ uint8_t CollisionMode;
};

// Size: 0xc8
class UParticleModuleColor : public UParticleModuleColorBase {
    /* 0x0030 */ FRawDistributionVector StartColor;
    /* 0x0090 */ FRawDistributionFloat StartAlpha;
    /* 0x00c0 */ bool bClampAlpha;
};

// Size: 0x30
class UParticleModuleColorBase : public UParticleModule {
};

// Size: 0xc8
class UParticleModuleColorOverLife : public UParticleModuleColorBase {
    /* 0x0030 */ FRawDistributionVector ColorOverLife;
    /* 0x0090 */ FRawDistributionFloat AlphaOverLife;
    /* 0x00c0 */ bool bClampAlpha;
};

// Size: 0xc8
class UParticleModuleColorScaleOverLife : public UParticleModuleColorBase {
    /* 0x0030 */ FRawDistributionVector ColorScaleOverLife;
    /* 0x0090 */ FRawDistributionFloat AlphaScaleOverLife;
    /* 0x00c0 */ bool bEmitterTime;
};

// Size: 0xe8
class UParticleModuleColor_Seeded : public UParticleModuleColor {
    /* 0x00c8 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x30
class UParticleModuleEventBase : public UParticleModule {
};

// Size: 0x40
class UParticleModuleEventGenerator : public UParticleModuleEventBase {
    /* 0x0030 */ TArray<FParticleEvent_GenerateInfo> Events;
};

// Size: 0x40
class UParticleModuleEventReceiverBase : public UParticleModuleEventBase {
    /* 0x0030 */ uint8_t EventGeneratorType;
    /* 0x0034 */ FName EventName;
};

// Size: 0x48
class UParticleModuleEventReceiverKillParticles : public UParticleModuleEventReceiverBase {
    /* 0x0040 */ bool bStopSpawning;
};

// Size: 0xf0
class UParticleModuleEventReceiverSpawn : public UParticleModuleEventReceiverBase {
    /* 0x0040 */ FRawDistributionFloat SpawnCount;
    /* 0x0070 */ bool bUseParticleTime;
    /* 0x0070 */ bool bUsePSysLocation;
    /* 0x0070 */ bool bInheritVelocity;
    /* 0x0078 */ FRawDistributionVector InheritVelocityScale;
    /* 0x00d8 */ TArray<UPhysicalMaterial*> PhysicalMaterials;
    /* 0x00e8 */ bool bBanPhysicalMaterials;
};

// Size: 0x28
class UParticleModuleEventSendToGame : public UObject {
};

// Size: 0x30
class UParticleModuleKillBase : public UParticleModule {
};

// Size: 0xf8
class UParticleModuleKillBox : public UParticleModuleKillBase {
    /* 0x0030 */ FRawDistributionVector LowerLeftCorner;
    /* 0x0090 */ FRawDistributionVector UpperRightCorner;
    /* 0x00f0 */ bool bAbsolute;
    /* 0x00f0 */ bool bKillInside;
    /* 0x00f0 */ bool bAxisAlignedAndFixedSize;
};

// Size: 0x68
class UParticleModuleKillHeight : public UParticleModuleKillBase {
    /* 0x0030 */ FRawDistributionFloat Height;
    /* 0x0060 */ bool bAbsolute;
    /* 0x0060 */ bool bFloor;
    /* 0x0060 */ bool bApplyPSysScale;
};

// Size: 0x60
class UParticleModuleLifetime : public UParticleModuleLifetimeBase {
    /* 0x0030 */ FRawDistributionFloat Lifetime;
};

// Size: 0x30
class UParticleModuleLifetimeBase : public UParticleModule {
};

// Size: 0x80
class UParticleModuleLifetime_Seeded : public UParticleModuleLifetime {
    /* 0x0060 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x140
class UParticleModuleLight : public UParticleModuleLightBase {
    /* 0x0030 */ bool bUseInverseSquaredFalloff;
    /* 0x0031 */ bool bAffectsTranslucency;
    /* 0x0034 */ bool bOverrideInverseExposureBlend;
    /* 0x0038 */ bool bPreviewLightRadius;
    /* 0x003c */ float SpawnFraction;
    /* 0x0040 */ FRawDistributionVector ColorScaleOverLife;
    /* 0x00a0 */ FRawDistributionFloat BrightnessOverLife;
    /* 0x00d0 */ FRawDistributionFloat RadiusScale;
    /* 0x0100 */ FRawDistributionFloat LightExponent;
    /* 0x0130 */ float InverseExposureBlend;
    /* 0x0134 */ FLightingChannels LightingChannels;
    /* 0x0138 */ float VolumetricScatteringIntensity;
    /* 0x013c */ bool bHighQualityLights;
    /* 0x013d */ bool bShadowCastingLights;
};

// Size: 0x30
class UParticleModuleLightBase : public UParticleModule {
};

// Size: 0x160
class UParticleModuleLight_Seeded : public UParticleModuleLight {
    /* 0x0140 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x98
class UParticleModuleLocation : public UParticleModuleLocationBase {
    /* 0x0030 */ FRawDistributionVector StartLocation;
    /* 0x0090 */ float DistributeOverNPoints;
    /* 0x0094 */ float DistributeThreshold;
};

// Size: 0x30
class UParticleModuleLocationBase : public UParticleModule {
};

// Size: 0x80
class UParticleModuleLocationBoneSocket : public UParticleModuleLocationBase {
    /* 0x0030 */ uint8_t SourceType;
    /* 0x0038 */ FVector UniversalOffset;
    /* 0x0050 */ TArray<FLocationBoneSocketInfo> SourceLocations;
    /* 0x0060 */ uint8_t SelectionMethod;
    /* 0x0064 */ bool bUpdatePositionEachFrame;
    /* 0x0064 */ bool bOrientMeshEmitters;
    /* 0x0064 */ bool bInheritBoneVelocity;
    /* 0x0068 */ float InheritVelocityScale;
    /* 0x006c */ FName SkelMeshActorParamName;
    /* 0x0074 */ int32_t NumPreSelectedIndices;
};

// Size: 0x1b0
class UParticleModuleLocationDirect : public UParticleModuleLocationBase {
    /* 0x0030 */ FRawDistributionVector Location;
    /* 0x0090 */ FRawDistributionVector LocationOffset;
    /* 0x00f0 */ FRawDistributionVector ScaleFactor;
    /* 0x0150 */ FRawDistributionVector Direction;
};

// Size: 0x50
class UParticleModuleLocationEmitter : public UParticleModuleLocationBase {
    /* 0x0030 */ FName EmitterName;
    /* 0x0038 */ uint8_t SelectionMethod;
    /* 0x003c */ bool InheritSourceVelocity;
    /* 0x0040 */ float InheritSourceVelocityScale;
    /* 0x0044 */ bool bInheritSourceRotation;
    /* 0x0048 */ float InheritSourceRotationScale;
};

// Size: 0x38
class UParticleModuleLocationEmitterDirect : public UParticleModuleLocationBase {
    /* 0x0030 */ FName EmitterName;
};

// Size: 0xc8
class UParticleModuleLocationPrimitiveBase : public UParticleModuleLocationBase {
    /* 0x0030 */ bool Positive_X;
    /* 0x0030 */ bool Positive_Y;
    /* 0x0030 */ bool Positive_Z;
    /* 0x0030 */ bool Negative_X;
    /* 0x0030 */ bool Negative_Y;
    /* 0x0030 */ bool Negative_Z;
    /* 0x0030 */ bool SurfaceOnly;
    /* 0x0030 */ bool Velocity;
    /* 0x0038 */ FRawDistributionFloat VelocityScale;
    /* 0x0068 */ FRawDistributionVector StartLocation;
};

// Size: 0x138
class UParticleModuleLocationPrimitiveCylinder : public UParticleModuleLocationPrimitiveBase {
    /* 0x00c8 */ bool RadialVelocity;
    /* 0x00d0 */ FRawDistributionFloat StartRadius;
    /* 0x0100 */ FRawDistributionFloat StartHeight;
    /* 0x0130 */ uint8_t HeightAxis;
};

// Size: 0x158
class UParticleModuleLocationPrimitiveCylinder_Seeded : public UParticleModuleLocationPrimitiveCylinder {
    /* 0x0138 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0xf8
class UParticleModuleLocationPrimitiveSphere : public UParticleModuleLocationPrimitiveBase {
    /* 0x00c8 */ FRawDistributionFloat StartRadius;
};

// Size: 0x118
class UParticleModuleLocationPrimitiveSphere_Seeded : public UParticleModuleLocationPrimitiveSphere {
    /* 0x00f8 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x120
class UParticleModuleLocationPrimitiveTriangle : public UParticleModuleLocationBase {
    /* 0x0030 */ FRawDistributionVector StartOffset;
    /* 0x0090 */ FRawDistributionFloat Height;
    /* 0x00c0 */ FRawDistributionFloat Angle;
    /* 0x00f0 */ FRawDistributionFloat Thickness;
};

// Size: 0xb0
class UParticleModuleLocationSkelVertSurface : public UParticleModuleLocationBase {
    /* 0x0030 */ uint8_t SourceType;
    /* 0x0038 */ FVector UniversalOffset;
    /* 0x0050 */ bool bUpdatePositionEachFrame;
    /* 0x0050 */ bool bOrientMeshEmitters;
    /* 0x0050 */ bool bInheritBoneVelocity;
    /* 0x0054 */ float InheritVelocityScale;
    /* 0x0058 */ FName SkelMeshActorParamName;
    /* 0x0060 */ TArray<FName> ValidAssociatedBones;
    /* 0x0070 */ bool bEnforceNormalCheck;
    /* 0x0078 */ FVector NormalToCompare;
    /* 0x0090 */ float NormalCheckToleranceDegrees;
    /* 0x0094 */ float NormalCheckTolerance;
    /* 0x0098 */ TArray<int32_t> ValidMaterialIndices;
    /* 0x00a8 */ bool bInheritVertexColor;
    /* 0x00a8 */ bool bInheritUV;
    /* 0x00ac */ uint32_t InheritUVChannel;
};

// Size: 0x98
class UParticleModuleLocationWorldOffset : public UParticleModuleLocation {
};

// Size: 0xb8
class UParticleModuleLocationWorldOffset_Seeded : public UParticleModuleLocationWorldOffset {
    /* 0x0098 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0xb8
class UParticleModuleLocation_Seeded : public UParticleModuleLocation {
    /* 0x0098 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x30
class UParticleModuleMaterialBase : public UParticleModule {
};

// Size: 0x40
class UParticleModuleMeshMaterial : public UParticleModuleMaterialBase {
    /* 0x0030 */ TArray<UMaterialInterface*> MeshMaterials;
};

// Size: 0x98
class UParticleModuleMeshRotation : public UParticleModuleRotationBase {
    /* 0x0030 */ FRawDistributionVector StartRotation;
    /* 0x0090 */ bool bInheritParent;
};

// Size: 0x90
class UParticleModuleMeshRotationRate : public UParticleModuleRotationRateBase {
    /* 0x0030 */ FRawDistributionVector StartRotationRate;
};

// Size: 0x90
class UParticleModuleMeshRotationRateMultiplyLife : public UParticleModuleRotationRateBase {
    /* 0x0030 */ FRawDistributionVector LifeMultiplier;
};

// Size: 0x98
class UParticleModuleMeshRotationRateOverLife : public UParticleModuleRotationRateBase {
    /* 0x0030 */ FRawDistributionVector RotRate;
    /* 0x0090 */ bool bScaleRotRate;
};

// Size: 0xb0
class UParticleModuleMeshRotationRate_Seeded : public UParticleModuleMeshRotationRate {
    /* 0x0090 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0xb8
class UParticleModuleMeshRotation_Seeded : public UParticleModuleMeshRotation {
    /* 0x0098 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x178
class UParticleModuleOrbit : public UParticleModuleOrbitBase {
    /* 0x0038 */ uint8_t ChainMode;
    /* 0x0040 */ FRawDistributionVector OffsetAmount;
    /* 0x00a0 */ FOrbitOptions OffsetOptions;
    /* 0x00a8 */ FRawDistributionVector RotationAmount;
    /* 0x0108 */ FOrbitOptions RotationOptions;
    /* 0x0110 */ FRawDistributionVector RotationRateAmount;
    /* 0x0170 */ FOrbitOptions RotationRateOptions;
};

// Size: 0x38
class UParticleModuleOrbitBase : public UParticleModule {
    /* 0x0030 */ bool bUseEmitterTime;
};

// Size: 0x38
class UParticleModuleOrientationAxisLock : public UParticleModuleOrientationBase {
    /* 0x0030 */ uint8_t LockAxisFlags;
};

// Size: 0x30
class UParticleModuleOrientationBase : public UParticleModule {
};

// Size: 0x30
class UParticleModuleParameterBase : public UParticleModule {
};

// Size: 0x48
class UParticleModuleParameterDynamic : public UParticleModuleParameterBase {
    /* 0x0030 */ TArray<FEmitterDynamicParameter> DynamicParams;
    /* 0x0040 */ int32_t UpdateFlags;
    /* 0x0044 */ bool bUsesVelocity;
};

// Size: 0x68
class UParticleModuleParameterDynamic_Seeded : public UParticleModuleParameterDynamic {
    /* 0x0048 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x40
class UParticleModulePivotOffset : public UParticleModuleLocationBase {
    /* 0x0030 */ FVector2D PivotOffset;
};

// Size: 0x170
class UParticleModuleRequired : public UParticleModule {
    /* 0x0030 */ UMaterialInterface* Material;
    /* 0x0038 */ float MinFacingCameraBlendDistance;
    /* 0x003c */ float MaxFacingCameraBlendDistance;
    /* 0x0040 */ FVector EmitterOrigin;
    /* 0x0058 */ FRotator EmitterRotation;
    /* 0x0070 */ uint8_t ScreenAlignment;
    /* 0x0071 */ bool bUseLocalSpace;
    /* 0x0071 */ bool bKillOnDeactivate;
    /* 0x0071 */ bool bKillOnCompleted;
    /* 0x0072 */ uint8_t SortMode;
    /* 0x0073 */ bool bUseLegacyEmitterTime;
    /* 0x0073 */ bool bRemoveHMDRoll;
    /* 0x0073 */ bool bSupportLargeWorldCoordinates;
    /* 0x0073 */ bool bEmitterDurationUseRange;
    /* 0x0073 */ bool bOverrideUseVelocityForMotionBlur;
    /* 0x0073 */ bool bUseVelocityForMotionBlur;
    /* 0x0074 */ float EmitterDuration;
    /* 0x0078 */ FRawDistributionFloat SpawnRate;
    /* 0x00a8 */ TArray<FParticleBurst> BurstList;
    /* 0x00b8 */ float EmitterDelay;
    /* 0x00bc */ float EmitterDelayLow;
    /* 0x00c0 */ bool bDelayFirstLoopOnly;
    /* 0x00c1 */ uint8_t InterpolationMethod;
    /* 0x00c2 */ bool bScaleUV;
    /* 0x00c2 */ bool bEmitterDelayUseRange;
    /* 0x00c3 */ uint8_t ParticleBurstMethod;
    /* 0x00c4 */ bool bOverrideSystemMacroUV;
    /* 0x00c4 */ bool bUseMaxDrawCount;
    /* 0x00c5 */ uint8_t OpacitySourceMode;
    /* 0x00c6 */ uint8_t EmitterNormalsMode;
    /* 0x00c7 */ bool bOrbitModuleAffectsVelocityAlignment;
    /* 0x00c8 */ int32_t SubImages_Horizontal;
    /* 0x00cc */ int32_t SubImages_Vertical;
    /* 0x00d0 */ float RandomImageTime;
    /* 0x00d4 */ int32_t RandomImageChanges;
    /* 0x00d8 */ FVector MacroUVPosition;
    /* 0x00f0 */ float MacroUVRadius;
    /* 0x00f4 */ EParticleUVFlipMode UVFlippingMode;
    /* 0x00f5 */ uint8_t BoundingMode;
    /* 0x00f6 */ bool bDurationRecalcEachLoop;
    /* 0x00f8 */ FVector NormalsSphereCenter;
    /* 0x0110 */ float AlphaThreshold;
    /* 0x0114 */ int32_t EmitterLoops;
    /* 0x0118 */ UTexture2D* CutoutTexture;
    /* 0x0120 */ int32_t MaxDrawCount;
    /* 0x0124 */ float EmitterDurationLow;
    /* 0x0128 */ FVector NormalsCylinderDirection;
    /* 0x0140 */ TArray<FName> NamedMaterialOverrides;
};

// Size: 0x60
class UParticleModuleRotation : public UParticleModuleRotationBase {
    /* 0x0030 */ FRawDistributionFloat StartRotation;
};

// Size: 0x30
class UParticleModuleRotationBase : public UParticleModule {
};

// Size: 0x68
class UParticleModuleRotationOverLifetime : public UParticleModuleRotationBase {
    /* 0x0030 */ FRawDistributionFloat RotationOverLife;
    /* 0x0060 */ bool Scale;
};

// Size: 0x60
class UParticleModuleRotationRate : public UParticleModuleRotationRateBase {
    /* 0x0030 */ FRawDistributionFloat StartRotationRate;
};

// Size: 0x30
class UParticleModuleRotationRateBase : public UParticleModule {
};

// Size: 0x60
class UParticleModuleRotationRateMultiplyLife : public UParticleModuleRotationRateBase {
    /* 0x0030 */ FRawDistributionFloat LifeMultiplier;
};

// Size: 0x80
class UParticleModuleRotationRate_Seeded : public UParticleModuleRotationRate {
    /* 0x0060 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x80
class UParticleModuleRotation_Seeded : public UParticleModuleRotation {
    /* 0x0060 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x90
class UParticleModuleSize : public UParticleModuleSizeBase {
    /* 0x0030 */ FRawDistributionVector StartSize;
};

// Size: 0x30
class UParticleModuleSizeBase : public UParticleModule {
};

// Size: 0x98
class UParticleModuleSizeMultiplyLife : public UParticleModuleSizeBase {
    /* 0x0030 */ FRawDistributionVector LifeMultiplier;
    /* 0x0090 */ bool MultiplyX;
    /* 0x0090 */ bool MultiplyY;
    /* 0x0090 */ bool MultiplyZ;
};

// Size: 0x98
class UParticleModuleSizeScale : public UParticleModuleSizeBase {
    /* 0x0030 */ FRawDistributionVector SizeScale;
    /* 0x0090 */ bool EnableX;
    /* 0x0090 */ bool EnableY;
    /* 0x0090 */ bool EnableZ;
};

// Size: 0x50
class UParticleModuleSizeScaleBySpeed : public UParticleModuleSizeBase {
    /* 0x0030 */ FVector2D SpeedScale;
    /* 0x0040 */ FVector2D MaxScale;
};

// Size: 0xb0
class UParticleModuleSize_Seeded : public UParticleModuleSize {
    /* 0x0090 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x90
class UParticleModuleSourceMovement : public UParticleModuleLocationBase {
    /* 0x0030 */ FRawDistributionVector SourceMovementScale;
};

// Size: 0xe0
class UParticleModuleSpawn : public UParticleModuleSpawnBase {
    /* 0x0038 */ FRawDistributionFloat Rate;
    /* 0x0068 */ FRawDistributionFloat RateScale;
    /* 0x0098 */ TArray<FParticleBurst> BurstList;
    /* 0x00a8 */ FRawDistributionFloat BurstScale;
    /* 0x00d8 */ uint8_t ParticleBurstMethod;
    /* 0x00dc */ bool bApplyGlobalSpawnRateScale;
};

// Size: 0x38
class UParticleModuleSpawnBase : public UParticleModule {
    /* 0x0030 */ bool bProcessSpawnRate;
    /* 0x0030 */ bool bProcessBurstList;
};

// Size: 0x78
class UParticleModuleSpawnPerUnit : public UParticleModuleSpawnBase {
    /* 0x0038 */ float UnitScalar;
    /* 0x003c */ float MovementTolerance;
    /* 0x0040 */ FRawDistributionFloat SpawnPerUnit;
    /* 0x0070 */ float MaxFrameDistance;
    /* 0x0074 */ bool bIgnoreSpawnRateWhenMoving;
    /* 0x0074 */ bool bIgnoreMovementAlongX;
    /* 0x0074 */ bool bIgnoreMovementAlongY;
    /* 0x0074 */ bool bIgnoreMovementAlongZ;
};

// Size: 0x70
class UParticleModuleSubUV : public UParticleModuleSubUVBase {
    /* 0x0030 */ USubUVAnimation* Animation;
    /* 0x0038 */ FRawDistributionFloat SubImageIndex;
    /* 0x0068 */ bool bUseRealTime;
};

// Size: 0x30
class UParticleModuleSubUVBase : public UParticleModule {
};

// Size: 0xb0
class UParticleModuleSubUVMovie : public UParticleModuleSubUV {
    /* 0x0070 */ bool bUseEmitterTime;
    /* 0x0078 */ FRawDistributionFloat FrameRate;
    /* 0x00a8 */ int32_t StartingFrame;
};

// Size: 0x30
class UParticleModuleTrailBase : public UParticleModule {
};

// Size: 0x90
class UParticleModuleTrailSource : public UParticleModuleTrailBase {
    /* 0x0030 */ uint8_t SourceMethod;
    /* 0x0034 */ FName SourceName;
    /* 0x0040 */ FRawDistributionFloat SourceStrength;
    /* 0x0070 */ bool bLockSourceStength;
    /* 0x0074 */ int32_t SourceOffsetCount;
    /* 0x0078 */ TArray<FVector> SourceOffsetDefaults;
    /* 0x0088 */ uint8_t SelectionMethod;
    /* 0x008c */ bool bInheritRotation;
};

// Size: 0x48
class UParticleModuleTypeDataAnimTrail : public UParticleModuleTypeDataBase {
    /* 0x0030 */ bool bDeadTrailsOnDeactivate;
    /* 0x0030 */ bool bEnablePreviousTangentRecalculation;
    /* 0x0030 */ bool bTangentRecalculationEveryFrame;
    /* 0x0034 */ float TilingDistance;
    /* 0x0038 */ float DistanceTessellationStepSize;
    /* 0x003c */ float TangentTessellationStepSize;
    /* 0x0040 */ float WidthTessellationStepSize;
};

// Size: 0x30
class UParticleModuleTypeDataBase : public UParticleModule {
};

// Size: 0x150
class UParticleModuleTypeDataBeam2 : public UParticleModuleTypeDataBase {
    /* 0x0030 */ uint8_t BeamMethod;
    /* 0x0034 */ int32_t TextureTile;
    /* 0x0038 */ float TextureTileDistance;
    /* 0x003c */ int32_t sheets;
    /* 0x0040 */ int32_t MaxBeamCount;
    /* 0x0044 */ float Speed;
    /* 0x0048 */ int32_t InterpolationPoints;
    /* 0x004c */ bool bAlwaysOn;
    /* 0x0050 */ int32_t UpVectorStepSize;
    /* 0x0054 */ FName BranchParentName;
    /* 0x0060 */ FRawDistributionFloat Distance;
    /* 0x0090 */ uint8_t TaperMethod;
    /* 0x0098 */ FRawDistributionFloat TaperFactor;
    /* 0x00c8 */ FRawDistributionFloat TaperScale;
    /* 0x00f8 */ bool RenderGeometry;
    /* 0x00f8 */ bool RenderDirectLine;
    /* 0x00f8 */ bool RenderLines;
    /* 0x00f8 */ bool RenderTessellation;
};

// Size: 0x5d0
class UParticleModuleTypeDataGpu : public UParticleModuleTypeDataBase {
    /* 0x0030 */ FGPUSpriteEmitterInfo EmitterInfo;
    /* 0x0380 */ FGPUSpriteResourceData ResourceData;
    /* 0x05c0 */ float CameraMotionBlurAmount;
    /* 0x05c4 */ bool bClearExistingParticlesOnInit;
};

// Size: 0xb0
class UParticleModuleTypeDataMesh : public UParticleModuleTypeDataBase {
    /* 0x0030 */ UStaticMesh* Mesh;
    /* 0x0040 */ float LODSizeScale;
    /* 0x0044 */ bool bUseStaticMeshLODs;
    /* 0x0044 */ bool CastShadows;
    /* 0x0044 */ bool DoCollisions;
    /* 0x0045 */ uint8_t MeshAlignment;
    /* 0x0046 */ bool bOverrideMaterial;
    /* 0x0046 */ bool bOverrideDefaultMotionBlurSettings;
    /* 0x0046 */ bool bEnableMotionBlur;
    /* 0x0048 */ FRawDistributionVector RollPitchYawRange;
    /* 0x00a8 */ uint8_t AxisLockOption;
    /* 0x00a9 */ bool bCameraFacing;
    /* 0x00aa */ uint8_t CameraFacingUpAxisOption;
    /* 0x00ab */ uint8_t CameraFacingOption;
    /* 0x00ac */ bool bApplyParticleRotationAsSpin;
    /* 0x00ac */ bool bFaceCameraDirectionRatherThanPosition;
    /* 0x00ac */ bool bCollisionsConsiderPartilceSize;
};

// Size: 0x60
class UParticleModuleTypeDataRibbon : public UParticleModuleTypeDataBase {
    /* 0x0030 */ int32_t MaxTessellationBetweenParticles;
    /* 0x0034 */ int32_t SheetsPerTrail;
    /* 0x0038 */ int32_t MaxTrailCount;
    /* 0x003c */ int32_t MaxParticleInTrailCount;
    /* 0x0040 */ bool bDeadTrailsOnDeactivate;
    /* 0x0040 */ bool bDeadTrailsOnSourceLoss;
    /* 0x0040 */ bool bClipSourceSegement;
    /* 0x0040 */ bool bEnablePreviousTangentRecalculation;
    /* 0x0040 */ bool bTangentRecalculationEveryFrame;
    /* 0x0040 */ bool bSpawnInitialParticle;
    /* 0x0044 */ uint8_t RenderAxis;
    /* 0x0048 */ float TangentSpawningScalar;
    /* 0x004c */ bool bRenderGeometry;
    /* 0x004c */ bool bRenderSpawnPoints;
    /* 0x004c */ bool bRenderTangents;
    /* 0x004c */ bool bRenderTessellation;
    /* 0x0050 */ float TilingDistance;
    /* 0x0054 */ float DistanceTessellationStepSize;
    /* 0x0058 */ bool bEnableTangentDiffInterpScale;
    /* 0x005c */ float TangentTessellationScalar;
};

// Size: 0x30
class UParticleModuleVectorFieldBase : public UParticleModule {
};

// Size: 0x40
class UParticleModuleVectorFieldGlobal : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ bool bOverrideGlobalVectorFieldTightness;
    /* 0x0034 */ float GlobalVectorFieldScale;
    /* 0x0038 */ float GlobalVectorFieldTightness;
};

// Size: 0x90
class UParticleModuleVectorFieldLocal : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ UVectorField* VectorField;
    /* 0x0038 */ FVector RelativeTranslation;
    /* 0x0050 */ FRotator RelativeRotation;
    /* 0x0068 */ FVector RelativeScale3D;
    /* 0x0080 */ float Intensity;
    /* 0x0084 */ float Tightness;
    /* 0x0088 */ bool bIgnoreComponentTransform;
    /* 0x0088 */ bool bTileX;
    /* 0x0088 */ bool bTileY;
    /* 0x0088 */ bool bTileZ;
    /* 0x0088 */ bool bUseFixDT;
};

// Size: 0x60
class UParticleModuleVectorFieldRotation : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ FVector MinInitialRotation;
    /* 0x0048 */ FVector MaxInitialRotation;
};

// Size: 0x48
class UParticleModuleVectorFieldRotationRate : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ FVector RotationRate;
};

// Size: 0x68
class UParticleModuleVectorFieldScale : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ UDistributionFloat* VectorFieldScale;
    /* 0x0038 */ FRawDistributionFloat VectorFieldScaleRaw;
};

// Size: 0x68
class UParticleModuleVectorFieldScaleOverLife : public UParticleModuleVectorFieldBase {
    /* 0x0030 */ UDistributionFloat* VectorFieldScaleOverLife;
    /* 0x0038 */ FRawDistributionFloat VectorFieldScaleOverLifeRaw;
};

// Size: 0xc8
class UParticleModuleVelocity : public UParticleModuleVelocityBase {
    /* 0x0038 */ FRawDistributionVector startVelocity;
    /* 0x0098 */ FRawDistributionFloat StartVelocityRadial;
};

// Size: 0x38
class UParticleModuleVelocityBase : public UParticleModule {
    /* 0x0030 */ bool bInWorldSpace;
    /* 0x0030 */ bool bApplyOwnerScale;
};

// Size: 0xb0
class UParticleModuleVelocityCone : public UParticleModuleVelocityBase {
    /* 0x0038 */ FRawDistributionFloat Angle;
    /* 0x0068 */ FRawDistributionFloat Velocity;
    /* 0x0098 */ FVector Direction;
};

// Size: 0x98
class UParticleModuleVelocityInheritParent : public UParticleModuleVelocityBase {
    /* 0x0038 */ FRawDistributionVector Scale;
};

// Size: 0xa0
class UParticleModuleVelocityOverLifetime : public UParticleModuleVelocityBase {
    /* 0x0038 */ FRawDistributionVector VelOverLife;
    /* 0x0098 */ bool Absolute;
};

// Size: 0xe8
class UParticleModuleVelocity_Seeded : public UParticleModuleVelocity {
    /* 0x00c8 */ FParticleRandomSeedInfo RandomSeedInfo;
};

// Size: 0x20
struct FParticleRandomSeedInfo {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ bool bGetSeedFromInstance;
    /* 0x0008 */ bool bInstanceSeedIsIndex;
    /* 0x0008 */ bool bResetSeedOnEmitterLooping;
    /* 0x0008 */ bool bRandomlySelectSeedArray;
    /* 0x0010 */ TArray<int32_t> RandomSeeds;
};

enum class ParticleReplayState {
    PRS_Disabled = 0,
    PRS_Capturing = 1,
    PRS_Replaying = 2,
    PRS_MAX = 3,
};

// Size: 0x1c0
class UParticleSpriteEmitter : public UParticleEmitter {
};

// Size: 0xe0
struct FParticleSysParam {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ uint8_t ParamType;
    /* 0x000c */ float Scalar;
    /* 0x0010 */ float Scalar_Low;
    /* 0x0018 */ FVector Vector;
    /* 0x0030 */ FVector Vector_Low;
    /* 0x0048 */ FColor Color;
    /* 0x0050 */ AActor* Actor;
    /* 0x0058 */ UMaterialInterface* Material;
};

// Size: 0x178
class UParticleSystem : public UFXSystemAsset {
    /* 0x0050 */ float UpdateTime_FPS;
    /* 0x0054 */ float UpdateTime_Delta;
    /* 0x0058 */ float WarmupTime;
    /* 0x005c */ float WarmupTickRate;
    /* 0x0060 */ TArray<UParticleEmitter*> Emitters;
    /* 0x0070 */ UParticleSystemComponent* PreviewComponent;
    /* 0x0078 */ UInterpCurveEdSetup* CurveEdSetup;
    /* 0x0080 */ float LODDistanceCheckTime;
    /* 0x0084 */ float MacroUVRadius;
    /* 0x0088 */ TArray<float> LODDistances;
    /* 0x0098 */ TArray<FParticleSystemLOD> LODSettings;
    /* 0x00a8 */ FBox FixedRelativeBoundingBox;
    /* 0x00e0 */ float SecondsBeforeInactive;
    /* 0x00e4 */ float Delay;
    /* 0x00e8 */ float DelayLow;
    /* 0x00ec */ bool bOrientZAxisTowardCamera;
    /* 0x00ec */ bool bUseFixedRelativeBoundingBox;
    /* 0x00ec */ bool bShouldResetPeakCounts;
    /* 0x00ec */ bool bHasPhysics;
    /* 0x00ec */ bool bUseRealtimeThumbnail;
    /* 0x00ec */ bool ThumbnailImageOutOfDate;
    /* 0x00ed */ bool bUseDelayRange;
    /* 0x00ed */ bool bAllowManagedTicking;
    /* 0x00ed */ bool bAutoDeactivate;
    /* 0x00ed */ bool bRegenerateLODDuplicate;
    /* 0x00ee */ uint8_t SystemUpdateMode;
    /* 0x00ef */ uint8_t LODMethod;
    /* 0x00f0 */ EParticleSystemInsignificanceReaction InsignificantReaction;
    /* 0x00f1 */ uint8_t OcclusionBoundsMethod;
    /* 0x00f3 */ EParticleSignificanceLevel MaxSignificanceLevel;
    /* 0x00f4 */ uint32_t MinTimeBetweenTicks;
    /* 0x00f8 */ float InsignificanceDelay;
    /* 0x0100 */ FVector MacroUVPosition;
    /* 0x0118 */ FBox CustomOcclusionBounds;
    /* 0x0150 */ TArray<FLODSoloTrack> SoloTracking;
    /* 0x0160 */ TArray<FNamedEmitterMaterial> NamedMaterialSlots;

    bool ContainsEmitterType(UClass* TypeData);
};

// Size: 0x840
class UParticleSystemComponent : public UFXSystemComponent {
    /* 0x0520 */ UParticleSystem* Template;
    /* 0x0528 */ TArray<UMaterialInterface*> EmitterMaterials;
    /* 0x0538 */ TArray<USkeletalMeshComponent*> SkelMeshComponents;
    /* 0x0549 */ bool bResetOnDetach;
    /* 0x0549 */ bool bUpdateOnDedicatedServer;
    /* 0x0549 */ bool bAllowRecycling;
    /* 0x0549 */ bool bAutoManageAttachment;
    /* 0x0549 */ bool bAutoAttachWeldSimulatedBodies;
    /* 0x054a */ bool bWarmingUp;
    /* 0x054a */ bool bOverrideLODMethod;
    /* 0x054a */ bool bSkipUpdateDynamicDataDuringTick;
    /* 0x0555 */ uint8_t LODMethod;
    /* 0x0556 */ EParticleSignificanceLevel RequiredSignificance;
    /* 0x0558 */ TArray<FParticleSysParam> InstanceParameters;
    /* 0x0568 */ FMulticastInlineDelegate OnParticleSpawn;
    /* 0x0578 */ FMulticastInlineDelegate OnParticleBurst;
    /* 0x0588 */ FMulticastInlineDelegate OnParticleDeath;
    /* 0x0598 */ FMulticastInlineDelegate OnParticleCollide;
    /* 0x05a8 */ bool bOldPositionValid;
    /* 0x05b0 */ FVector OldPosition;
    /* 0x05c8 */ FVector PartSysVelocity;
    /* 0x05e0 */ float WarmupTime;
    /* 0x05e4 */ float WarmupTickRate;
    /* 0x05ec */ float SecondsBeforeInactive;
    /* 0x05f4 */ float MaxTimeBeforeForceUpdateTransform;
    /* 0x0618 */ TArray<UParticleSystemReplay*> ReplayClips;
    /* 0x0630 */ float CustomTimeDilation;
    /* 0x0688 */ TWeakObjectPtr<USceneComponent> AutoAttachParent;
    /* 0x0690 */ FName AutoAttachSocketName;
    /* 0x0698 */ EAttachmentRule AutoAttachLocationRule;
    /* 0x0699 */ EAttachmentRule AutoAttachRotationRule;
    /* 0x069a */ EAttachmentRule AutoAttachScaleRule;
    /* 0x06f0 */ FMulticastInlineDelegate OnSystemFinished;

    void BeginTrails(FName InFirstSocketName, FName InSecondSocketName, uint8_t InWidthMode, float InWidth);
    UMaterialInstanceDynamic* CreateNamedDynamicMaterialInstance(FName InName, UMaterialInterface* SourceMaterial);
    void EndTrails();
    void GenerateParticleEvent(const FName InEventName, const float InEmitterTime, const FVector InLocation, const FVector InDirection, const FVector InVelocity);
    bool GetBeamEndPoint(int32_t EmitterIndex, FVector& OutEndPoint) const;
    bool GetBeamSourcePoint(int32_t EmitterIndex, int32_t SourceIndex, FVector& OutSourcePoint) const;
    bool GetBeamSourceStrength(int32_t EmitterIndex, int32_t SourceIndex, float& OutSourceStrength) const;
    bool GetBeamSourceTangent(int32_t EmitterIndex, int32_t SourceIndex, FVector& OutTangentPoint) const;
    bool GetBeamTargetPoint(int32_t EmitterIndex, int32_t TargetIndex, FVector& OutTargetPoint) const;
    bool GetBeamTargetStrength(int32_t EmitterIndex, int32_t TargetIndex, float& OutTargetStrength) const;
    bool GetBeamTargetTangent(int32_t EmitterIndex, int32_t TargetIndex, FVector& OutTangentPoint) const;
    UMaterialInterface* GetNamedMaterial(FName InName) const;
    int32_t GetNumActiveParticles() const;
    void SetAutoAttachParams(USceneComponent* Parent, FName SocketName, uint8_t LocationType);
    void SetBeamEndPoint(int32_t EmitterIndex, FVector NewEndPoint);
    void SetBeamSourcePoint(int32_t EmitterIndex, FVector NewSourcePoint, int32_t SourceIndex);
    void SetBeamSourceStrength(int32_t EmitterIndex, float NewSourceStrength, int32_t SourceIndex);
    void SetBeamSourceTangent(int32_t EmitterIndex, FVector NewTangentPoint, int32_t SourceIndex);
    void SetBeamTargetPoint(int32_t EmitterIndex, FVector NewTargetPoint, int32_t TargetIndex);
    void SetBeamTargetStrength(int32_t EmitterIndex, float NewTargetStrength, int32_t TargetIndex);
    void SetBeamTargetTangent(int32_t EmitterIndex, FVector NewTangentPoint, int32_t TargetIndex);
    void SetMaterialParameter(FName ParameterName, UMaterialInterface* Param);
    void SetTemplate(UParticleSystem* NewTemplate);
    void SetTrailSourceData(FName InFirstSocketName, FName InSecondSocketName, uint8_t InWidthMode, float InWidth);
};

// Size: 0x20
struct FParticleSystemDynamicState {
    /* 0x0008 */ FTransformHandle Transform;
    /* 0x0018 */ UFXSystemAsset* SystemAsset;
};

// Size: 0x10
struct FParticleSystemHandle : public FStateStreamHandle {
};

// Size: 0x1
struct FParticleSystemLOD {
};

enum class ParticleSystemLODMethod {
    PARTICLESYSTEMLODMETHOD_Automatic = 0,
    PARTICLESYSTEMLODMETHOD_DirectSet = 1,
    PARTICLESYSTEMLODMETHOD_ActivateAutomatic = 2,
    PARTICLESYSTEMLODMETHOD_MAX = 3,
};

// Size: 0x40
class UParticleSystemReplay : public UObject {
    /* 0x0028 */ int32_t ClipIDNumber;
};

// Size: 0x10
struct FParticleSystemReplayFrame {
};

// Size: 0x4
struct FParticleSystemStaticState {
};

// Size: 0x30
struct FParticleSystemWorldManagerTickFunction : public FTickFunction {
};

// Size: 0x2a8
class APartitionActor : public AActor {
};

// Size: 0x10
struct FPassiveSoundMixModifier {
    /* 0x0000 */ USoundMix* SoundMix;
    /* 0x0008 */ float MinVolumeThreshold;
    /* 0x000c */ float MaxVolumeThreshold;
};

// Size: 0x28
class IPathFollowingAgentInterface : public UInterface {
};

// Size: 0x328
class APawn : public AActor {
    /* 0x02b0 */ bool bUseControllerRotationPitch;
    /* 0x02b0 */ bool bUseControllerRotationYaw;
    /* 0x02b0 */ bool bUseControllerRotationRoll;
    /* 0x02b0 */ bool bCanAffectNavigationGeneration;
    /* 0x02b0 */ bool bIsLocalViewTarget;
    /* 0x02b4 */ float BaseEyeHeight;
    /* 0x02b8 */ uint8_t AutoPossessPlayer;
    /* 0x02b9 */ EAutoPossessAI AutoPossessAI;
    /* 0x02ba */ uint16_t RemoteViewPitch16;
    /* 0x02bc */ uint8_t RemoteViewPitch;
    /* 0x02c0 */ UClass* AIControllerClass;
    /* 0x02c8 */ APlayerState* PlayerState;
    /* 0x02d0 */ AController* LastHitBy;
    /* 0x02d8 */ AController* Controller;
    /* 0x02e0 */ AController* PreviousController;
    /* 0x02ec */ FMulticastSparseDelegate ReceiveControllerChangedDelegate;
    /* 0x02ed */ FMulticastSparseDelegate ReceiveRestartedDelegate;
    /* 0x02f0 */ FVector ControlInputVector;
    /* 0x0308 */ FVector LastControlInputVector;
    /* 0x0320 */ UClass* OverrideInputComponentClass;

    void AddControllerPitchInput(float val);
    void AddControllerRollInput(float val);
    void AddControllerYawInput(float val);
    void AddMovementInput(FVector WorldDirection, float ScaleValue, bool bForce);
    FVector ConsumeMovementInputVector();
    void DetachFromControllerPendingDestroy();
    FRotator GetBaseAimRotation() const;
    FRotator GetControlRotation() const;
    AController* GetController() const;
    FVector GetLastMovementInputVector() const;
    APlayerController* GetLocalViewingPlayerController() const;
    static AActor* GetMovementBaseActor(const APawn* Pawn);
    UPawnMovementComponent* GetMovementComponent() const;
    FVector GetNavAgentLocation() const;
    UClass* GetOverrideInputComponentClass() const;
    FVector GetPendingMovementInputVector() const;
    FPlatformUserId GetPlatformUserId() const;
    bool IsBotControlled() const;
    bool IsControlled() const;
    bool IsLocallyControlled() const;
    bool IsLocallyViewed() const;
    bool IsMoveInputIgnored() const;
    bool IsPawnControlled() const;
    bool IsPlayerControlled() const;
    void OnRep_Controller();
    void OnRep_PlayerState();
    void PawnMakeNoise(float Loudness, FVector NoiseLocation, bool bUseNoiseMakerLocation, AActor* NoiseMaker);
    void ReceiveControllerChanged(AController* OldController, AController* NewController);
    void ReceivePossessed(AController* NewController);
    void ReceiveRestarted();
    void ReceiveUnpossessed(AController* OldController);
    void SetCanAffectNavigationGeneration(bool bNewValue, bool bForceUpdate);
    void SpawnDefaultController();
};

// Size: 0x188
class UPawnMovementComponent : public UNavMovementComponent {
    /* 0x0180 */ APawn* PawnOwner;

    void AddInputVector(FVector WorldVector, bool bForce);
    FVector ConsumeInputVector();
    FVector GetLastInputVector() const;
    APawn* GetPawnOwner() const;
    FVector GetPendingInputVector() const;
    bool IsMoveInputIgnored() const;
    void MulticastAsyncPhysicsStateAction(const UPrimitiveComponent* ActionComponent, const FName BoneName, const FAsyncPhysicsTimestamp Timestamp, const EPhysicsStateAction ActionType, const FVector ActionDatas, const FVector ActionPosition);
    void ServerAsyncPhysicsStateAction(const UPrimitiveComponent* ActionComponent, const FName BoneName, const FAsyncPhysicsTimestamp Timestamp, const EPhysicsStateAction ActionType, const FVector ActionDatas, const FVector ActionPosition);
};

// Size: 0xf0
class UPawnNoiseEmitterComponent : public UActorComponent {
    /* 0x00b8 */ bool bAIPerceptionSystemCompatibilityMode;
    /* 0x00c0 */ FVector LastRemoteNoisePosition;
    /* 0x00d8 */ float NoiseLifetime;
    /* 0x00dc */ float LastRemoteNoiseVolume;
    /* 0x00e0 */ float LastRemoteNoiseTime;
    /* 0x00e4 */ float LastLocalNoiseVolume;
    /* 0x00e8 */ float LastLocalNoiseTime;

    void MakeNoise(AActor* NoiseMaker, float Loudness, const FVector& NoiseLocation);
};

// Size: 0xc0
class UPendingNetGame : public UObject {
    /* 0x0030 */ UNetDriver* NetDriver;
    /* 0x0038 */ UDemoNetDriver* DemoNetDriver;
};

// Size: 0x8
struct FPerBoneBlendWeight {
    /* 0x0000 */ int32_t SourceIndex;
    /* 0x0004 */ float BlendWeight;
};

// Size: 0x10
struct FPerBoneBlendWeights {
    /* 0x0000 */ TArray<FPerBoneBlendWeight> BoneBlendWeights;
};

// Size: 0x14
struct FPerBoneInterpolation {
    /* 0x0000 */ FBoneReference BoneReference;
    /* 0x0010 */ float InterpolationSpeedPerSec;
};

// Size: 0x68
struct FPerQualityLevelFloat {
    /* 0x0010 */ float Default;
    /* 0x0018 */ TMap<int32_t, float> PerQuality;
};

// Size: 0x68
struct FPerQualityLevelInt {
    /* 0x0010 */ int32_t Default;
    /* 0x0018 */ TMap<int32_t, int32_t> PerQuality;
};

// Size: 0xf8
class UPhysicalAnimationComponent : public UActorComponent {
    /* 0x00b8 */ float StrengthMultiplyer;
    /* 0x00c0 */ USkeletalMeshComponent* SkeletalMeshComponent;

    void ApplyPhysicalAnimationProfileBelow(FName BodyName, FName ProfileName, bool bIncludeSelf, bool bClearNotFound);
    void ApplyPhysicalAnimationSettings(FName BodyName, const FPhysicalAnimationData& PhysicalAnimationData);
    void ApplyPhysicalAnimationSettingsBelow(FName BodyName, const FPhysicalAnimationData& PhysicalAnimationData, bool bIncludeSelf);
    FTransform GetBodyTargetTransform(FName BodyName) const;
    void SetSkeletalMeshComponent(USkeletalMeshComponent* InSkeletalMeshComponent);
    void SetStrengthMultiplyer(float InStrengthMultiplyer);
};

// Size: 0x24
struct FPhysicalAnimationData {
    /* 0x0000 */ FName BodyName;
    /* 0x0008 */ bool bIsLocalSimulation;
    /* 0x000c */ float OrientationStrength;
    /* 0x0010 */ float AngularVelocityStrength;
    /* 0x0014 */ float PositionStrength;
    /* 0x0018 */ float VelocityStrength;
    /* 0x001c */ float MaxLinearForce;
    /* 0x0020 */ float MaxAngularForce;
};

// Size: 0x2c
struct FPhysicalAnimationProfile {
    /* 0x0000 */ FName ProfileName;
    /* 0x0008 */ FPhysicalAnimationData PhysicalAnimationData;
};

// Size: 0x38
class UPhysicalMaterialMask : public UObject {
    /* 0x0028 */ int32_t UVChannelIndex;
    /* 0x002c */ uint8_t AddressX;
    /* 0x002d */ uint8_t AddressY;
};

// Size: 0xc
struct FPhysicalSurfaceName {
    /* 0x0000 */ uint8_t Type;
    /* 0x0004 */ FName Name;
};

// Size: 0x150
class UPhysicsAsset : public UObject {
    /* 0x0030 */ TArray<int32_t> BoundsBodies;
    /* 0x0040 */ TArray<USkeletalBodySetup*> SkeletalBodySetups;
    /* 0x0050 */ TArray<UPhysicsConstraintTemplate*> ConstraintSetup;
    /* 0x0060 */ FPhysicsAssetSolverSettings SolverSettings;
    /* 0x007c */ FSolverIterations SolverIterations;
    /* 0x0094 */ EPhysicsAssetSolverType SolverType;
    /* 0x0095 */ bool bNotForDedicatedServer;
    /* 0x0138 */ UThumbnailInfo* ThumbnailInfo;
    /* 0x0140 */ TArray<UBodySetup*> BodySetup;
};

// Size: 0x1c
struct FPhysicsAssetSolverSettings {
    /* 0x0000 */ int32_t PositionIterations;
    /* 0x0004 */ int32_t VelocityIterations;
    /* 0x0008 */ int32_t ProjectionIterations;
    /* 0x000c */ float CullDistance;
    /* 0x0010 */ float MaxDepenetrationVelocity;
    /* 0x0014 */ float FixedTimeStep;
    /* 0x0018 */ bool bUseLinearJointSolver;
    /* 0x0019 */ bool bUseManifolds;
};

// Size: 0x28
class IPhysicsBodyInstanceOwnerResolver : public UInterface {
};

// Size: 0x40
class UPhysicsCollisionHandler : public UObject {
    /* 0x0028 */ float ImpactThreshold;
    /* 0x002c */ float ImpactReFireDelay;
    /* 0x0030 */ USoundBase* DefaultImpactSound;
    /* 0x0038 */ float LastImpactSoundTime;
};

// Size: 0x28
class IPhysicsComponent : public UInterface {
};

// Size: 0x2c8
class APhysicsConstraintActor : public ARigidBodyBase {
    /* 0x02a8 */ UPhysicsConstraintComponent* ConstraintComp;
    /* 0x02b0 */ AActor* ConstraintActor1;
    /* 0x02b8 */ AActor* ConstraintActor2;
    /* 0x02c0 */ bool bDisableCollision;
};

// Size: 0x530
class UPhysicsConstraintComponent : public USceneComponent {
    /* 0x0240 */ AActor* ConstraintActor1;
    /* 0x0248 */ FConstrainComponentPropName ComponentName1;
    /* 0x0250 */ AActor* ConstraintActor2;
    /* 0x0258 */ FConstrainComponentPropName ComponentName2;
    /* 0x0270 */ UPhysicsConstraintTemplate* ConstraintSetup;
    /* 0x0278 */ FMulticastInlineDelegate OnConstraintBroken;
    /* 0x0288 */ FMulticastInlineDelegate OnPlasticDeformation;
    /* 0x0298 */ FConstraintInstance ConstraintInstance;

    void BreakConstraint();
    void GetConstrainedComponents(UPrimitiveComponent*& OutComponent1, FName& OutBoneName1, UPrimitiveComponent*& OutComponent2, FName& OutBoneName2);
    FConstraintInstanceAccessor GetConstraint();
    void GetConstraintForce(FVector& OutLinearForce, FVector& OutAngularForce);
    float GetCurrentSwing1() const;
    float GetCurrentSwing2() const;
    float GetCurrentTwist() const;
    bool IsBroken();
    bool IsProjectionEnabled() const;
    void SetAngularBreakable(bool bAngularBreakable, float AngularBreakThreshold);
    void SetAngularDriveAccelerationMode(bool bAccelerationMode);
    void SetAngularDriveMode(uint8_t DriveMode);
    void SetAngularDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
    void SetAngularOrientationDrive(bool bEnableSwingDrive, bool bEnableTwistDrive);
    void SetAngularOrientationTarget(const FRotator& InPosTarget);
    void SetAngularPlasticity(bool bAngularPlasticity, float AngularPlasticityThreshold);
    void SetAngularSwing1Limit(uint8_t MotionType, float Swing1LimitAngle);
    void SetAngularSwing2Limit(uint8_t MotionType, float Swing2LimitAngle);
    void SetAngularTwistLimit(uint8_t ConstraintType, float TwistLimitAngle);
    void SetAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive);
    void SetAngularVelocityDriveSLERP(bool bEnableSLERP);
    void SetAngularVelocityDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);
    void SetAngularVelocityTarget(const FVector& InVelTarget);
    void SetConstrainedComponents(UPrimitiveComponent* Component1, FName BoneName1, UPrimitiveComponent* Component2, FName BoneName2);
    void SetConstraintReferenceFrame(uint8_t Frame, const FTransform& RefFrame);
    void SetConstraintReferenceOrientation(uint8_t Frame, const FVector& PriAxis, const FVector& SecAxis);
    void SetConstraintReferencePosition(uint8_t Frame, const FVector& RefPosition);
    void SetContactTransferScale(float ContactTransferScale);
    void SetDisableCollision(bool bDisableCollision);
    void SetLinearBreakable(bool bLinearBreakable, float LinearBreakThreshold);
    void SetLinearDriveAccelerationMode(bool bAccelerationMode);
    void SetLinearDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
    void SetLinearPlasticity(bool bLinearPlasticity, float LinearPlasticityThreshold, uint8_t PlasticityType);
    void SetLinearPositionDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
    void SetLinearPositionTarget(const FVector& InPosTarget);
    void SetLinearVelocityDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
    void SetLinearVelocityTarget(const FVector& InVelTarget);
    void SetLinearXLimit(uint8_t ConstraintType, float LimitSize);
    void SetLinearYLimit(uint8_t ConstraintType, float LimitSize);
    void SetLinearZLimit(uint8_t ConstraintType, float LimitSize);
    void SetOrientationDriveSLERP(bool bEnableSLERP);
    void SetOrientationDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);
    void SetProjectionEnabled(bool bProjectionEnabled);
    void SetProjectionParams(float ProjectionLinearAlpha, float ProjectionAngularAlpha, float ProjectionLinearTolerance, float ProjectionAngularTolerance);
};

// Size: 0x168
struct FPhysicsConstraintProfileHandle {
    /* 0x0000 */ FConstraintProfileProperties ProfileProperties;
    /* 0x0160 */ FName ProfileName;
};

// Size: 0x420
class UPhysicsConstraintTemplate : public UObject {
    /* 0x0028 */ FConstraintInstance DefaultInstance;
    /* 0x02b0 */ TArray<FPhysicsConstraintProfileHandle> ProfileHandles;
    /* 0x02c0 */ FConstraintProfileProperties DefaultProfile;
};

// Size: 0x320
class UPhysicsFieldComponent : public USceneComponent {
};

// Size: 0x28
class UPhysicsFieldStatics : public UBlueprintFunctionLibrary {

    static int32_t EvalPhysicsIntegerField(const UObject* WorldContextObject, const FVector& WorldPosition, const uint8_t IntegerType);
    static float EvalPhysicsScalarField(const UObject* WorldContextObject, const FVector& WorldPosition, const uint8_t ScalarType);
    static FVector EvalPhysicsVectorField(const UObject* WorldContextObject, const FVector& WorldPosition, const uint8_t VectorType);
};

// Size: 0x500
class UPhysicsHandleComponent : public UActorComponent {
    /* 0x00b8 */ UPrimitiveComponent* GrabbedComponent;
    /* 0x00c8 */ bool bSoftAngularConstraint;
    /* 0x00c8 */ bool bSoftLinearConstraint;
    /* 0x00c8 */ bool bInterpolateTarget;
    /* 0x00cc */ float LinearDamping;
    /* 0x00d0 */ float LinearStiffness;
    /* 0x00d4 */ float AngularDamping;
    /* 0x00d8 */ float AngularStiffness;
    /* 0x01a0 */ float InterpolationSpeed;

    UPrimitiveComponent* GetGrabbedComponent() const;
    void GetTargetLocationAndRotation(FVector& TargetLocation, FRotator& TargetRotation) const;
    void GrabComponent(UPrimitiveComponent* Component, FName InBoneName, FVector GrabLocation, bool bConstrainRotation);
    void GrabComponentAtLocation(UPrimitiveComponent* Component, FName InBoneName, FVector GrabLocation);
    void GrabComponentAtLocationWithRotation(UPrimitiveComponent* Component, FName InBoneName, FVector Location, FRotator Rotation);
    void ReleaseComponent();
    void SetAngularDamping(float NewAngularDamping);
    void SetAngularStiffness(float NewAngularStiffness);
    void SetInterpolationSpeed(float NewInterpolationSpeed);
    void SetLinearDamping(float NewLinearDamping);
    void SetLinearStiffness(float NewLinearStiffness);
    void SetTargetLocation(FVector NewLocation);
    void SetTargetLocationAndRotation(FVector NewLocation, FRotator NewRotation);
    void SetTargetRotation(FRotator NewRotation);
};

// Size: 0x28
class UPhysicsObjectBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void ApplyRadialImpulse(UPrimitiveComponent* Component, FVector Origin, float Radius, float Strength, uint8_t Falloff, bool bApplyStrain, float Strain, bool bVelChange, float MinValue, float MaxValue);
    static bool ExtractClosestPhysicsObjectResults(const FClosestPhysicsObjectResult& Result, FName& OutName);
    static FClosestPhysicsObjectResult GetClosestPhysicsObjectFromWorldLocation(UPrimitiveComponent* Component, const FVector& WorldLocation);
    static FTransform GetPhysicsObjectWorldTransform(UPrimitiveComponent* Component, FName BoneName);
};

// Size: 0x48
struct FPhysicsPredictionSettings {
    /* 0x0000 */ bool bEnablePhysicsResimulation;
    /* 0x0004 */ float ResimulationErrorThreshold;
    /* 0x0008 */ bool bEnablePhysicsPrediction;
    /* 0x0009 */ bool bEnablePhysicsHistoryCapture;
    /* 0x000c */ float MaxSupportedLatencyPrediction;
    /* 0x0010 */ FPhysicsReplicationResimulationSettings ResimulationSettings;
    /* 0x0030 */ FPhysicsReplicationLODSettings PhysicsReplicationLODSettings;
};

// Size: 0x28
class UPhysicsQueryHandler : public UObject {
};

// Size: 0x18
struct FPhysicsReplicationLODSettings {
    /* 0x0000 */ bool bEnablePhysicsReplicationLOD;
    /* 0x0004 */ float MinimumBaseDistance;
    /* 0x0008 */ float BaseDistanceRadiusMultiplier;
    /* 0x000c */ float BaseDistancesForResimulationMode;
    /* 0x0010 */ float BaseDistancesForFullPrediction;
    /* 0x0014 */ float TimeOverDistance;
};

// Size: 0x20
struct FPhysicsReplicationResimulationSettings {
    /* 0x0000 */ bool bEnableResimulationErrorPositionThreshold;
    /* 0x0004 */ float ResimulationErrorPositionThreshold;
    /* 0x0008 */ bool bEnableResimulationErrorRotationThreshold;
    /* 0x000c */ float ResimulationErrorRotationThreshold;
    /* 0x0010 */ bool bEnableResimulationErrorLinearVelocityThreshold;
    /* 0x0014 */ float ResimulationErrorLinearVelocityThreshold;
    /* 0x0018 */ bool bEnableResimulationErrorAngularVelocityThreshold;
    /* 0x001c */ float ResimulationErrorAngularVelocityThreshold;
};

// Size: 0x248
class UPhysicsSettings : public UPhysicsSettingsCore {
    /* 0x0100 */ FPhysicsPredictionSettings PhysicsPrediction;
    /* 0x0148 */ FRigidBodyErrorCorrection PhysicErrorCorrection;
    /* 0x017c */ uint8_t LockedAxis;
    /* 0x017d */ uint8_t DefaultDegreesOfFreedom;
    /* 0x017e */ bool bSuppressFaceRemapTable;
    /* 0x017f */ bool bSupportUVFromHitResults;
    /* 0x0180 */ bool bDisableActiveActors;
    /* 0x0181 */ bool bDisableKinematicStaticPairs;
    /* 0x0182 */ bool bDisableKinematicKinematicPairs;
    /* 0x0183 */ bool bDisableCCD;
    /* 0x0184 */ float AnimPhysicsMinDeltaTime;
    /* 0x0188 */ bool bSimulateAnimPhysicsAfterReset;
    /* 0x018c */ float MinPhysicsDeltaTime;
    /* 0x0190 */ float MaxPhysicsDeltaTime;
    /* 0x0194 */ bool bSubstepping;
    /* 0x0195 */ bool bSubsteppingAsync;
    /* 0x0196 */ bool bTickPhysicsAsync;
    /* 0x0198 */ float AsyncFixedTimeStepSize;
    /* 0x019c */ float MaxSubstepDeltaTime;
    /* 0x01a0 */ int32_t MaxSubsteps;
    /* 0x01a4 */ float SyncSceneSmoothingFactor;
    /* 0x01a8 */ float InitialAverageFrameRate;
    /* 0x01ac */ int32_t PhysXTreeRebuildRate;
    /* 0x01b0 */ TArray<FPhysicalSurfaceName> PhysicalSurfaces;
    /* 0x01c0 */ FBroadphaseSettings DefaultBroadphaseSettings;
    /* 0x0240 */ float MinDeltaVelocityForHitEvents;
    /* 0x0244 */ FChaosPhysicsSettings ChaosSettings;

    int32_t GetPhysicsHistoryCount() const;
};

// Size: 0x270
class UPhysicsSpringComponent : public USceneComponent {
    /* 0x0240 */ float SpringStiffness;
    /* 0x0244 */ float SpringDamping;
    /* 0x0248 */ float SpringLengthAtRest;
    /* 0x024c */ float SpringRadius;
    /* 0x0250 */ uint8_t SpringChannel;
    /* 0x0251 */ bool bIgnoreSelf;
    /* 0x0254 */ float SpringCompression;

    float GetNormalizedCompressionScalar() const;
    FVector GetSpringCurrentEndPoint() const;
    FVector GetSpringDirection() const;
    FVector GetSpringRestingPoint() const;
};

// Size: 0x28
class UPhysicsThreadLibrary : public UBlueprintFunctionLibrary {

    static void AddForce(FBodyInstanceAsyncPhysicsTickHandle Handle, FVector Force, bool bAccelChange);
};

// Size: 0x2b0
class APhysicsThruster : public ARigidBodyBase {
    /* 0x02a8 */ UPhysicsThrusterComponent* ThrusterComponent;
};

// Size: 0x250
class UPhysicsThrusterComponent : public USceneComponent {
    /* 0x0240 */ float ThrustStrength;
};

// Size: 0x2f0
class APhysicsVolume : public AVolume {
    /* 0x02e0 */ float TerminalVelocity;
    /* 0x02e4 */ int32_t Priority;
    /* 0x02e8 */ float FluidFriction;
    /* 0x02ec */ bool bWaterVolume;
    /* 0x02ec */ bool bPhysicsOnContact;
};

// Size: 0x48
struct FPieFixupStructWithSoftObjectPath {
    /* 0x0000 */ FSoftObjectPath Path;
    /* 0x0020 */ TSoftObjectPtr<AActor> TypedPtr;
};

// Size: 0xc8
class UPieFixupTestObject : public UObject {
    /* 0x0028 */ FSoftObjectPath Path;
    /* 0x0048 */ TSoftObjectPtr<AActor> TypedPtr;
    /* 0x0070 */ FPieFixupStructWithSoftObjectPath Struct;
    /* 0x00b8 */ TArray<FPieFixupStructWithSoftObjectPath> Array;
};

// Size: 0x2c8
class APlanarReflection : public ASceneCapture {
    /* 0x02b8 */ UPlanarReflectionComponent* PlanarReflectionComponent;
    /* 0x02c0 */ bool bShowPreviewPlane;

    void OnInterpToggle(bool bEnable);
};

// Size: 0x490
class UPlanarReflectionComponent : public USceneCaptureComponent {
    /* 0x0328 */ UBoxComponent* PreviewBox;
    /* 0x0330 */ float NormalDistortionStrength;
    /* 0x0334 */ float PrefilterRoughness;
    /* 0x0338 */ float PrefilterRoughnessDistance;
    /* 0x033c */ int32_t ScreenPercentage;
    /* 0x0340 */ float ExtraFOV;
    /* 0x0344 */ float DistanceFromPlaneFadeStart;
    /* 0x0348 */ float DistanceFromPlaneFadeEnd;
    /* 0x034c */ float DistanceFromPlaneFadeoutStart;
    /* 0x0350 */ float DistanceFromPlaneFadeoutEnd;
    /* 0x0354 */ float AngleFromPlaneFadeStart;
    /* 0x0358 */ float AngleFromPlaneFadeEnd;
    /* 0x035c */ bool bShowPreviewPlane;
    /* 0x035d */ bool bRenderSceneTwoSided;
};

// Size: 0x2b0
class APlaneReflectionCapture : public AReflectionCapture {
};

// Size: 0x2c0
class UPlaneReflectionCaptureComponent : public UReflectionCaptureComponent {
    /* 0x02a8 */ float InfluenceRadiusScale;
    /* 0x02b0 */ UDrawSphereComponent* PreviewInfluenceRadius;
    /* 0x02b8 */ UBoxComponent* PreviewCaptureBox;
};

// Size: 0xd8
class UPlatformEventsComponent : public UActorComponent {
    /* 0x00b8 */ FMulticastInlineDelegate PlatformChangedToLaptopModeDelegate;
    /* 0x00c8 */ FMulticastInlineDelegate PlatformChangedToTabletModeDelegate;

    bool IsInLaptopMode();
    bool IsInTabletMode();
    void PlatformEventDelegate__DelegateSignature();
    bool SupportsConvertibleLaptops();
};

// Size: 0x290
class UPlatformGameInstance : public UGameInstance {
    /* 0x01c0 */ FMulticastInlineDelegate ApplicationWillDeactivateDelegate;
    /* 0x01d0 */ FMulticastInlineDelegate ApplicationHasReactivatedDelegate;
    /* 0x01e0 */ FMulticastInlineDelegate ApplicationWillEnterBackgroundDelegate;
    /* 0x01f0 */ FMulticastInlineDelegate ApplicationHasEnteredForegroundDelegate;
    /* 0x0200 */ FMulticastInlineDelegate ApplicationWillTerminateDelegate;
    /* 0x0210 */ FMulticastInlineDelegate ApplicationShouldUnloadResourcesDelegate;
    /* 0x0220 */ FMulticastInlineDelegate ApplicationReceivedStartupArgumentsDelegate;
    /* 0x0230 */ FMulticastInlineDelegate ApplicationRegisteredForRemoteNotificationsDelegate;
    /* 0x0240 */ FMulticastInlineDelegate ApplicationRegisteredForUserNotificationsDelegate;
    /* 0x0250 */ FMulticastInlineDelegate ApplicationFailedToRegisterForRemoteNotificationsDelegate;
    /* 0x0260 */ FMulticastInlineDelegate ApplicationReceivedRemoteNotificationDelegate;
    /* 0x0270 */ FMulticastInlineDelegate ApplicationReceivedLocalNotificationDelegate;
    /* 0x0280 */ FMulticastInlineDelegate ApplicationReceivedScreenOrientationChangedNotificationDelegate;

    void PlatformDelegate__DelegateSignature();
    void PlatformFailedToRegisterForRemoteNotificationsDelegate__DelegateSignature(FString InString);
    void PlatformReceivedLocalNotificationDelegate__DelegateSignature(FString InString, int32_t inInt, uint8_t inAppState);
    void PlatformReceivedRemoteNotificationDelegate__DelegateSignature(FString InString, uint8_t inAppState);
    void PlatformRegisteredForRemoteNotificationsDelegate__DelegateSignature(const TArray<uint8_t>& inArray);
    void PlatformRegisteredForUserNotificationsDelegate__DelegateSignature(int32_t inInt);
    void PlatformScreenOrientationChangedDelegate__DelegateSignature(uint8_t inScreenOrientation);
    void PlatformStartupArgumentsDelegate__DelegateSignature(const TArray<FString>& StartupArguments);
};

// Size: 0x38
class UPlatformInterfaceBase : public UObject {
    /* 0x0028 */ TArray<FDelegateArray> AllDelegates;
};

// Size: 0x30
struct FPlatformInterfaceData {
    /* 0x0000 */ FName DataName;
    /* 0x0008 */ uint8_t Type;
    /* 0x000c */ int32_t IntValue;
    /* 0x0010 */ float FloatValue;
    /* 0x0018 */ FString StringValue;
    /* 0x0028 */ UObject* ObjectValue;
};

// Size: 0x38
struct FPlatformInterfaceDelegateResult {
    /* 0x0000 */ bool bSuccessful;
    /* 0x0008 */ FPlatformInterfaceData Data;
};

// Size: 0xb0
class UPlatformInterfaceWebResponse : public UObject {
    /* 0x0028 */ FString OriginalURL;
    /* 0x0038 */ int32_t ResponseCode;
    /* 0x003c */ int32_t Tag;
    /* 0x0040 */ FString StringResponse;
    /* 0x0050 */ TArray<uint8_t> BinaryResponse;

    void GetHeader(int32_t HeaderIndex, FString& Header, FString& Value);
    FString GetHeaderValue(FString HeaderName);
    int32_t GetNumHeaders();
};

// Size: 0x48
class UPlayer : public UObject {
    /* 0x0030 */ APlayerController* PlayerController;
    /* 0x0038 */ int32_t CurrentNetSpeed;
    /* 0x003c */ int32_t ConfiguredInternetSpeed;
    /* 0x0040 */ int32_t ConfiguredLanSpeed;
};

// Size: 0x27e0
class APlayerCameraManager : public AActor {
    /* 0x02a8 */ APlayerController* PCOwner;
    /* 0x02b0 */ USceneComponent* TransformComponent;
    /* 0x02c0 */ float DefaultFOV;
    /* 0x02c8 */ float DefaultOrthoWidth;
    /* 0x02d0 */ float DefaultAspectRatio;
    /* 0x0340 */ FTViewTarget ViewTarget;
    /* 0x0c20 */ FTViewTarget PendingViewTarget;
    /* 0x1530 */ FCameraCacheEntry CameraCachePrivate;
    /* 0x1e00 */ FCameraCacheEntry LastFrameCameraCachePrivate;
    /* 0x26d0 */ TArray<UCameraModifier*> ModifierList;
    /* 0x26e0 */ TArray<UClass*> DefaultModifiers;
    /* 0x26f0 */ float FreeCamDistance;
    /* 0x26f8 */ FVector FreeCamOffset;
    /* 0x2710 */ FVector ViewTargetOffset;
    /* 0x2728 */ FMulticastInlineDelegate OnAudioFadeChangeEvent;
    /* 0x2750 */ TArray<TScriptInterface<ICameraLensEffectInterface>> CameraLensEffects;
    /* 0x2760 */ UCameraModifier_CameraShake* CachedCameraShakeMod;
    /* 0x2768 */ TArray<FPostProcessSettings> PostProcessBlendCache;
    /* 0x2798 */ ACameraActor* AnimCameraActor;
    /* 0x27a0 */ bool bIsOrthographic;
    /* 0x27a0 */ bool bAutoCalculateOrthoPlanes;
    /* 0x27a4 */ float AutoPlaneShift;
    /* 0x27a8 */ bool bUpdateOrthoPlanes;
    /* 0x27a8 */ bool bUseCameraHeightAsViewTarget;
    /* 0x27a8 */ bool bDefaultConstrainAspectRatio;
    /* 0x27a8 */ bool bClientSimulatingViewTarget;
    /* 0x27a9 */ bool bUseClientSideCameraUpdates;
    /* 0x27a9 */ bool bGameCameraCutThisFrame;
    /* 0x27ac */ float ViewPitchMin;
    /* 0x27b0 */ float ViewPitchMax;
    /* 0x27b4 */ float ViewYawMin;
    /* 0x27b8 */ float ViewYawMax;
    /* 0x27bc */ float ViewRollMin;
    /* 0x27c0 */ float ViewRollMax;
    /* 0x27c8 */ float ServerUpdateCameraTimeout;

    TScriptInterface<ICameraLensEffectInterface> AddGenericCameraLensEffect(UClass* LensEffectEmitterClass);
    UCameraModifier* AddNewCameraModifier(UClass* ModifierClass);
    bool BlueprintUpdateCamera(AActor* CameraTarget, FVector& NewCameraLocation, FRotator& NewCameraRotation, float& NewCameraFOV);
    void ClearCameraLensEffects();
    UCameraModifier* FindCameraModifierByClass(UClass* ModifierClass);
    FVector GetCameraLocation() const;
    FRotator GetCameraRotation() const;
    float GetFOVAngle() const;
    APlayerController* GetOwningPlayerController() const;
    void OnPhotographyMultiPartCaptureEnd();
    void OnPhotographyMultiPartCaptureStart();
    void OnPhotographySessionEnd();
    void OnPhotographySessionStart();
    void PhotographyCameraModify(const FVector NewCameraLocation, const FVector PreviousCameraLocation, const FVector OriginalCameraLocation, FVector& ResultCameraLocation);
    bool RemoveCameraModifier(UCameraModifier* ModifierToRemove);
    void RemoveGenericCameraLensEffect(TScriptInterface<ICameraLensEffectInterface> Emitter);
    void SetGameCameraCutThisFrame();
    void SetManualCameraFade(float InFadeAmount, FLinearColor Color, bool bInFadeAudio);
    void StartCameraFade(float FromAlpha, float ToAlpha, float Duration, FLinearColor Color, bool bShouldFadeAudio, bool bHoldWhenFinished);
    UCameraShakeBase* StartCameraShake(UClass* ShakeClass, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
    UCameraShakeBase* StartCameraShakeFromSource(UClass* ShakeClass, UCameraShakeSourceComponent* SourceComponent, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
    void StopAllCameraShakes(bool bImmediately);
    void StopAllCameraShakesFromSource(UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
    void StopAllInstancesOfCameraShake(UClass* Shake, bool bImmediately);
    void StopAllInstancesOfCameraShakeFromSource(UClass* Shake, UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
    void StopCameraFade();
    void StopCameraShake(UCameraShakeBase* ShakeInstance, bool bImmediately);
    void SwapPendingViewTargetWhenUsingClientSideCameraUpdates();
};

// Size: 0x738
class APlayerController : public AController {
    /* 0x0348 */ UPlayer* Player;
    /* 0x0350 */ APawn* AcknowledgedPawn;
    /* 0x0358 */ AHUD* MyHUD;
    /* 0x0360 */ APlayerCameraManager* PlayerCameraManager;
    /* 0x0368 */ UClass* PlayerCameraManagerClass;
    /* 0x0370 */ bool bAutoManageActiveCameraTarget;
    /* 0x0378 */ FRotator TargetViewRotation;
    /* 0x03a8 */ float SmoothTargetViewRotationSpeed;
    /* 0x03b0 */ TArray<AActor*> HiddenActors;
    /* 0x03c0 */ TArray<TWeakObjectPtr<UPrimitiveComponent>> HiddenPrimitiveComponents;
    /* 0x03d4 */ float LastSpectatorStateSynchTime;
    /* 0x03d8 */ FVector LastSpectatorSyncLocation;
    /* 0x03f0 */ FRotator LastSpectatorSyncRotation;
    /* 0x0408 */ int32_t ClientCap;
    /* 0x0410 */ UCheatManager* CheatManager;
    /* 0x0418 */ UClass* CheatClass;
    /* 0x0420 */ UPlayerInput* PlayerInput;
    /* 0x0428 */ TArray<FActiveForceFeedbackEffect> ActiveForceFeedbackEffects;
    /* 0x04b8 */ bool bPlayerIsWaiting;
    /* 0x04bc */ uint8_t NetPlayerIndex;
    /* 0x0518 */ UNetConnection* PendingSwapConnection;
    /* 0x0520 */ UNetConnection* NetConnection;
    /* 0x0540 */ float InputYawScale;
    /* 0x0544 */ float InputPitchScale;
    /* 0x0548 */ float InputRollScale;
    /* 0x054c */ bool bShowMouseCursor;
    /* 0x054c */ bool bEnableClickEvents;
    /* 0x054c */ bool bEnableTouchEvents;
    /* 0x054c */ bool bEnableMouseOverEvents;
    /* 0x054c */ bool bEnableTouchOverEvents;
    /* 0x054c */ bool bForceFeedbackEnabled;
    /* 0x054c */ bool bEnableMotionControls;
    /* 0x054c */ bool bEnableStreamingSource;
    /* 0x054d */ bool bStreamingSourceShouldActivate;
    /* 0x054d */ bool bStreamingSourceShouldBlockOnSlowStreaming;
    /* 0x0550 */ EStreamingSourcePriority StreamingSourcePriority;
    /* 0x0554 */ FColor StreamingSourceDebugColor;
    /* 0x0558 */ TArray<FStreamingSourceShape> StreamingSourceShapes;
    /* 0x0568 */ float ForceFeedbackScale;
    /* 0x0570 */ TArray<FKey> ClickEventKeys;
    /* 0x0580 */ uint8_t DefaultMouseCursor;
    /* 0x0581 */ uint8_t CurrentMouseCursor;
    /* 0x0582 */ uint8_t DefaultClickTraceChannel;
    /* 0x0583 */ uint8_t CurrentClickTraceChannel;
    /* 0x0584 */ float HitResultTraceDistance;
    /* 0x0588 */ uint16_t SeamlessTravelCount;
    /* 0x058a */ uint16_t LastCompletedSeamlessTravelCount;
    /* 0x0610 */ UInputComponent* InactiveStateInputComponent;
    /* 0x0618 */ bool bShouldPerformFullTickWhenPaused;
    /* 0x0630 */ UTouchInterface* CurrentTouchInterface;
    /* 0x0638 */ UClass* OverridePlayerInputClass;
    /* 0x06b8 */ ASpectatorPawn* SpectatorPawn;
    /* 0x06c4 */ bool bIsLocalPlayerController;
    /* 0x06c8 */ FVector SpawnLocation;
    /* 0x0700 */ FUniqueNetIdRepl CachedConnectionPlayerId;
    /* 0x0730 */ uint32_t ClientHandshakeId;

    void ActivateTouchInterface(UTouchInterface* NewTouchInterface);
    void AddPitchInput(float val);
    void AddRollInput(float val);
    void AddYawInput(float val);
    void Camera(FName NewMode);
    bool CanRestartPlayer();
    void ClearAudioListenerAttenuationOverride();
    void ClearAudioListenerOverride();
    void ClientAckTimeDilation(float TimeDilation, int32_t ServerStep);
    void ClientAckUpdateLevelVisibility(FName PackageName, FNetLevelVisibilityTransactionId TransactionId, bool bClientAckCanMakeVisible);
    void ClientAddTextureStreamingLoc(FVector InLoc, float Duration, bool bOverrideLocation);
    void ClientCancelPendingMapChange();
    void ClientCapBandwidth(int32_t Cap);
    void ClientClearCameraLensEffects();
    void ClientCommitMapChange();
    void ClientEnableNetworkVoice(bool bEnable);
    void ClientEndOnlineSession();
    void ClientFlushLevelStreaming();
    void ClientForceGarbageCollection();
    void ClientGameEnded(AActor* EndGameFocus, bool bIsWinner);
    void ClientGotoState(FName NewState);
    void ClientIgnoreLookInput(bool bIgnore);
    void ClientIgnoreMoveInput(bool bIgnore);
    void ClientMessage(FString S, FName Type, float MsgLifeTime);
    void ClientMutePlayer(FUniqueNetIdRepl PlayerId);
    void ClientPlayForceFeedback_Internal(UForceFeedbackEffect* ForceFeedbackEffect, FForceFeedbackParameters Params);
    void ClientPlaySound(USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier);
    void ClientPlaySoundAtLocation(USoundBase* Sound, FVector Location, float VolumeMultiplier, float PitchMultiplier);
    void ClientPrepareMapChange(FName LevelName, bool bFirst, bool bLast);
    void ClientPrestreamTextures(AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int32_t CinematicTextureGroups);
    void ClientReceiveLocalizedMessage(UClass* Message, int32_t Switch, APlayerState* RelatedPlayerState_1, APlayerState* RelatedPlayerState_2, UObject* OptionalObject);
    void ClientRepObjRef(UObject* Object);
    void ClientReset();
    void ClientRestart(APawn* NewPawn);
    void ClientRetryClientRestart(APawn* NewPawn);
    void ClientReturnToMainMenuWithTextReason(const FText ReturnReason);
    void ClientSetBlockOnAsyncLoading();
    void ClientSetCameraFade(bool bEnableFading, FColor FadeColor, FVector2D FadeAlpha, float FadeTime, bool bFadeAudio, bool bHoldWhenFinished);
    void ClientSetCameraMode(FName NewCamMode);
    void ClientSetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD);
    void ClientSetForceMipLevelsToBeResident(UMaterialInterface* Material, float ForceDuration, int32_t CinematicTextureGroups);
    void ClientSetHUD(UClass* NewHUDClass);
    void ClientSetSpectatorWaiting(bool bWaiting);
    void ClientSetViewTarget(AActor* A, FViewTargetTransitionParams TransitionParams);
    void ClientSetupNetworkPhysicsTimestamp(FAsyncPhysicsTimestamp Timestamp);
    void ClientSpawnCameraLensEffect(UClass* LensEffectEmitterClass);
    void ClientSpawnGenericCameraLensEffect(UClass* LensEffectEmitterClass);
    void ClientStartCameraShake(UClass* Shake, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
    void ClientStartCameraShakeFromSource(UClass* Shake, UCameraShakeSourceComponent* SourceComponent);
    void ClientStartOnlineSession();
    void ClientStopCameraShake(UClass* Shake, bool bImmediately);
    void ClientStopCameraShakesFromSource(UCameraShakeSourceComponent* SourceComponent, bool bImmediately);
    void ClientStopForceFeedback(UForceFeedbackEffect* ForceFeedbackEffect, FName Tag);
    void ClientTeamMessage(APlayerState* SenderPlayerState, FString S, FName Type, float MsgLifeTime);
    void ClientTravel(FString URL, uint8_t TravelType, bool bSeamless, FGuid MapPackageGuid);
    void ClientTravelInternal(FString URL, uint8_t TravelType, bool bSeamless, FGuid MapPackageGuid);
    void ClientUnmutePlayer(FUniqueNetIdRepl PlayerId);
    void ClientUnmutePlayers(const TArray<FUniqueNetIdRepl> PlayerIds);
    void ClientUpdateLevelStreamingStatus(FName PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int32_t LODIndex, FNetLevelVisibilityTransactionId TransactionId, bool bNewShouldBlockOnUnload);
    void ClientUpdateMultipleLevelsStreamingStatus(const TArray<FUpdateLevelStreamingLevelStatus> LevelStatuses);
    void ClientVoiceHandshakeComplete();
    void ClientWasKicked(const FText KickReason);
    void ConsoleKey(FKey Key);
    bool DeprojectMousePositionToWorld(FVector& WorldLocation, FVector& WorldDirection) const;
    bool DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, FVector& WorldLocation, FVector& WorldDirection) const;
    void EnableCheats();
    void FOV(float NewFOV);
    float GetDeprecatedInputPitchScale() const;
    float GetDeprecatedInputRollScale() const;
    float GetDeprecatedInputYawScale() const;
    FVector GetFocalLocation() const;
    AHUD* GetHUD() const;
    bool GetHitResultUnderCursor(uint8_t TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;
    bool GetHitResultUnderCursorByChannel(uint8_t TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;
    bool GetHitResultUnderCursorForObjects(const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;
    bool GetHitResultUnderFinger(uint8_t FingerIndex, uint8_t TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;
    bool GetHitResultUnderFingerByChannel(uint8_t FingerIndex, uint8_t TraceChannel, bool bTraceComplex, FHitResult& HitResult) const;
    bool GetHitResultUnderFingerForObjects(uint8_t FingerIndex, const TArray<uint8_t>& ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;
    float GetInputAnalogKeyState(FKey Key) const;
    void GetInputAnalogStickState(uint8_t WhichStick, float& StickX, float& StickY) const;
    float GetInputKeyTimeDown(FKey Key) const;
    void GetInputMotionState(FVector& Tilt, FVector& RotationRate, FVector& Gravity, FVector& Acceleration) const;
    void GetInputMouseDelta(float& DeltaX, float& DeltaY) const;
    void GetInputTouchState(uint8_t FingerIndex, float& LocationX, float& LocationY, bool& bIsCurrentlyPressed) const;
    FVector GetInputVectorKeyState(FKey Key) const;
    bool GetMousePosition(float& LocationX, float& LocationY) const;
    UClass* GetOverridePlayerInputClass() const;
    FPlatformUserId GetPlatformUserId() const;
    ASpectatorPawn* GetSpectatorPawn() const;
    void GetStreamingSourceLocationAndRotation(FVector& OutLocation, FRotator& OutRotation) const;
    EStreamingSourcePriority GetStreamingSourcePriority() const;
    void GetStreamingSourceShapes(TArray<FStreamingSourceShape>& OutShapes) const;
    void GetViewportSize(int32_t& SizeX, int32_t& SizeY) const;
    bool IsInputKeyDown(FKey Key) const;
    bool IsPrimaryPlayer() const;
    bool IsStreamingSourceEnabled() const;
    void K2_ClientPlayForceFeedback(UForceFeedbackEffect* ForceFeedbackEffect, FName Tag, bool bLooping, bool bIgnoreTimeDilation, bool bPlayWhilePaused);
    void LocalTravel(FString URL);
    void OnServerStartedVisualLogger(bool bIsLogging);
    void Pause();
    void PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, uint8_t action, FLatentActionInfo LatentInfo);
    void PlayHapticEffect(UHapticFeedbackEffect_Base* HapticEffect, EControllerHand Hand, float Scale, bool bLoop);
    bool ProjectWorldLocationToScreen(FVector WorldLocation, FVector2D& ScreenLocation, bool bPlayerViewportRelative) const;
    void ResetControllerDeadZones();
    void ResetControllerLightColor();
    void ResetControllerTriggerReleaseThresholds();
    void RestartLevel();
    void SendToConsole(FString Command);
    void ServerAcknowledgePossession(APawn* P);
    void ServerBlockPlayer(FUniqueNetIdRepl PlayerId);
    void ServerCamera(FName NewMode);
    void ServerChangeName(FString S);
    void ServerCheckClientPossession();
    void ServerCheckClientPossessionReliable();
    void ServerExec(FString Msg);
    void ServerExecRPC(FString Msg);
    void ServerMutePlayer(FUniqueNetIdRepl PlayerId);
    void ServerNotifyLoadedWorld(FName WorldPackageName);
    void ServerPause();
    void ServerRestartPlayer();
    void ServerSendLatestAsyncPhysicsTimestamp(FAsyncPhysicsTimestamp Timestamp);
    void ServerSetSpectatorLocation(FVector NewLoc, FRotator NewRot);
    void ServerSetSpectatorWaiting(bool bWaiting);
    void ServerShortTimeout();
    void ServerToggleAILogging();
    void ServerUnblockPlayer(FUniqueNetIdRepl PlayerId);
    void ServerUnmutePlayer(FUniqueNetIdRepl PlayerId);
    void ServerUpdateCamera(FVector_NetQuantize CamLoc, int32_t CamPitchAndYaw);
    void ServerUpdateLevelVisibility(const FUpdateLevelVisibilityLevelInfo LevelVisibility);
    void ServerUpdateMultipleLevelsVisibility(const TArray<FUpdateLevelVisibilityLevelInfo> LevelVisibilities);
    void ServerVerifyViewTarget();
    void ServerViewNextPlayer();
    void ServerViewPrevPlayer();
    void ServerViewSelf(FViewTargetTransitionParams TransitionParams);
    void SetAudioListenerAttenuationOverride(USceneComponent* AttachToComponent, FVector AttenuationLocationOVerride);
    void SetAudioListenerOverride(USceneComponent* AttachToComponent, FVector Location, FRotator Rotation);
    void SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning);
    void SetControllerDeadZones(const float LeftDeadZone, const float RightDeadZone);
    void SetControllerGyroAutoCalibration(bool bEnabled);
    void SetControllerLightColor(FColor Color);
    void SetControllerTriggerReleaseThresholds(const float LeftThreshold, const float RightThreshold);
    void SetDeprecatedInputPitchScale(float NewValue);
    void SetDeprecatedInputRollScale(float NewValue);
    void SetDeprecatedInputYawScale(float NewValue);
    void SetDisableHaptics(bool bNewDisabled);
    void SetHapticsByValue(const float Frequency, const float Amplitude, EControllerHand Hand);
    void SetMotionControlsEnabled(bool bEnabled);
    void SetMouseCursorWidget(uint8_t Cursor, UUserWidget* CursorWidget);
    void SetMouseLocation(const int32_t X, const int32_t Y);
    void SetName(FString S);
    void SetViewTargetWithBlend(AActor* NewViewTarget, float BlendTime, uint8_t BlendFunc, float BlendExp, bool bLockOutgoing);
    void SetVirtualJoystickVisibility(bool bVisible);
    void StartFire(uint8_t FireModeNum);
    void StopHapticEffect(EControllerHand Hand);
    bool StreamingSourceShouldActivate() const;
    bool StreamingSourceShouldBlockOnSlowStreaming() const;
    void SwitchLevel(FString URL);
    void TestServerLevelVisibilityChange(const FName PackageName, const FName Filename);
    void ToggleSpeaking(bool bInSpeaking);
    bool WasInputKeyJustPressed(FKey Key) const;
    bool WasInputKeyJustReleased(FKey Key) const;
};

// Size: 0x498
class UPlayerInput : public UObject {
    /* 0x01a0 */ TArray<FKeyBind> DebugExecBindings;
    /* 0x01e0 */ TArray<FName> InvertedAxis;

    void ClearSmoothing();
    APlayerController* GetOuterAPlayerController() const;
    void InvertAxis(const FName AxisName);
    void InvertAxisKey(const FKey AxisKey);
    void SetBind(FName BindName, FString Command);
    void SetMouseSensitivity(const float Sensitivity);
};

// Size: 0x58
struct FPlayerMuteList {
    /* 0x0050 */ bool bHasVoiceHandshakeCompleted;
    /* 0x0054 */ int32_t VoiceChannelIdx;
};

// Size: 0x2d8
class APlayerStart : public ANavigationObjectBase {
    /* 0x02d0 */ FName PlayerStartTag;
};

// Size: 0x2d8
class APlayerStartPIE : public APlayerStart {
};

// Size: 0x360
class APlayerState : public AInfo {
    /* 0x02a8 */ float Score;
    /* 0x02ac */ int32_t PlayerId;
    /* 0x02b0 */ uint8_t CompressedPing;
    /* 0x02b2 */ bool bShouldUpdateReplicatedPing;
    /* 0x02b2 */ bool bIsSpectator;
    /* 0x02b2 */ bool bOnlySpectator;
    /* 0x02b2 */ bool bIsABot;
    /* 0x02b2 */ bool bIsInactive;
    /* 0x02b2 */ bool bFromPreviousLevel;
    /* 0x02b4 */ int32_t StartTime;
    /* 0x02b8 */ FUniqueNetIdRepl UniqueID;
    /* 0x02e8 */ UClass* EngineMessageClass;
    /* 0x02f8 */ FString SavedNetworkAddress;
    /* 0x0310 */ FMulticastInlineDelegate OnPawnSet;
    /* 0x0320 */ APawn* PawnPrivate;
    /* 0x0340 */ FString PlayerNamePrivate;

    FUniqueNetIdRepl BP_GetUniqueId() const;
    uint8_t GetCompressedPing() const;
    APawn* GetPawn() const;
    float GetPingInMilliseconds() const;
    APlayerController* GetPlayerController() const;
    int32_t GetPlayerId() const;
    FString GetPlayerName() const;
    float GetScore() const;
    bool IsABot() const;
    bool IsOnlyASpectator() const;
    bool IsSpectator() const;
    void OnPawnPrivateDestroyed(AActor* InActor);
    void OnRep_PlayerId();
    void OnRep_PlayerName();
    void OnRep_Score();
    void OnRep_UniqueId();
    void OnRep_bIsInactive();
    void ReceiveCopyProperties(APlayerState* NewPlayerState);
    void ReceiveOverrideWith(APlayerState* OldPlayerState);
};

// Size: 0x40
class UPlayerStateCountLimiterConfig : public UNetObjectCountLimiterConfig {
};

// Size: 0x28
class UPluginBlueprintLibrary : public UBlueprintFunctionLibrary {

    static TArray<FString> GetAdditionalPluginSearchPaths();
    static TArray<FString> GetAdditionalProjectPluginSearchPaths();
    static TArray<FString> GetEnabledPluginNames();
    static bool GetPluginBaseDir(FString PluginName, FString& OutBaseDir);
    static bool GetPluginContentDir(FString PluginName, FString& OutContentDir);
    static bool GetPluginDescription(FString PluginName, FString& OutDescription);
    static bool GetPluginDescriptorFilePath(FString PluginName, FString& OutFilePath);
    static bool GetPluginEditorCustomVirtualPath(FString PluginName, FString& OutVirtualPath);
    static bool GetPluginMountedAssetPath(FString PluginName, FString& OutAssetPath);
    static bool GetPluginNameForObjectPath(const FSoftObjectPath& ObjectPath, FString& OutPluginName);
    static bool GetPluginVersion(FString PluginName, int32_t& OutVersion);
    static bool GetPluginVersionName(FString PluginName, FString& OutVersionName);
    static bool IsPluginMounted(FString PluginName);
};

// Size: 0xa0
class UPluginCommandlet : public UCommandlet {
};

// Size: 0x20
struct FPluginRedirect {
    /* 0x0000 */ FString OldPluginName;
    /* 0x0010 */ FString NewPluginName;
};

// Size: 0x130
struct FPointDamageEvent : public FDamageEvent {
    /* 0x0010 */ float Damage;
    /* 0x0018 */ FVector_NetQuantizeNormal ShotDirection;
    /* 0x0030 */ FHitResult HitInfo;
};

// Size: 0x2c0
class APointLight : public ALight {
    /* 0x02b8 */ UPointLightComponent* PointLightComponent;

    void SetLightFalloffExponent(float NewLightFalloffExponent);
    void SetRadius(float NewRadius);
};

// Size: 0x3d0
class UPointLightComponent : public ULocalLightComponent {
    /* 0x03b8 */ bool bUseInverseSquaredFalloff;
    /* 0x03bc */ float LightFalloffExponent;
    /* 0x03c0 */ float SourceRadius;
    /* 0x03c4 */ float SoftSourceRadius;
    /* 0x03c8 */ float SourceLength;

    void SetInverseExposureBlend(float NewInverseExposureBlend);
    void SetLightFalloffExponent(float NewLightFalloffExponent);
    void SetSoftSourceRadius(float bNewValue);
    void SetSourceLength(float NewValue);
    void SetSourceRadius(float bNewValue);
    void SetUseInverseSquaredFalloff(bool bNewValue);
};

// Size: 0x8
struct FPointerToUberGraphFrame {
};

// Size: 0x38
class UPolys : public UObject {
};

// Size: 0x10
struct FPooledCameraShakes {
    /* 0x0000 */ TArray<UCameraShakeBase*> PooledShakes;
};

// Size: 0x110
class UPoseAsset : public UAnimationAsset {
    /* 0x0080 */ FPoseDataContainer PoseContainer;
    /* 0x00f0 */ bool bAdditivePose;
    /* 0x00f4 */ int32_t BasePoseIndex;
    /* 0x00f8 */ FName RetargetSource;
    /* 0x0100 */ TArray<FTransform> RetargetSourceAssetReferencePose;
};

// Size: 0x8
struct FPoseAssetInfluence {
    /* 0x0000 */ int32_t PoseIndex;
    /* 0x0004 */ int32_t BoneTransformIndex;
};

// Size: 0x10
struct FPoseAssetInfluences {
    /* 0x0000 */ TArray<FPoseAssetInfluence> Influences;
};

// Size: 0x20
struct FPoseData {
    /* 0x0000 */ TArray<FTransform> LocalSpacePose;
    /* 0x0010 */ TArray<float> CurveData;
};

// Size: 0x70
struct FPoseDataContainer {
    /* 0x0000 */ TArray<FName> PoseFNames;
    /* 0x0020 */ TArray<FName> Tracks;
    /* 0x0030 */ TArray<int32_t> TrackBoneIndices;
    /* 0x0040 */ TArray<FPoseAssetInfluences> TrackPoseInfluenceIndices;
    /* 0x0050 */ TArray<FPoseData> Poses;
    /* 0x0060 */ TArray<FAnimCurveBase> Curves;
};

// Size: 0x10
struct FPoseLink : public FPoseLinkBase {
};

// Size: 0x10
struct FPoseLinkBase {
    /* 0x0008 */ int32_t LinkID;
};

// Size: 0x38
struct FPoseSnapshot {
    /* 0x0000 */ TArray<FTransform> LocalTransforms;
    /* 0x0010 */ TArray<FName> BoneNames;
    /* 0x0020 */ FName SkeletalMeshName;
    /* 0x0028 */ FName SnapshotName;
    /* 0x0030 */ bool bIsValid;
};

// Size: 0x28
class UPoseWatch : public UObject {
};

// Size: 0x28
class UPoseWatchElement : public UObject {
};

// Size: 0x28
class UPoseWatchFolder : public UObject {
};

// Size: 0x28
class UPoseWatchPoseElement : public UPoseWatchElement {
};

// Size: 0xa50
class UPoseableMeshComponent : public USkinnedMeshComponent {

    void CopyPoseFromSkeletalComponent(USkeletalMeshComponent* InComponentToCopy);
    FVector GetBoneLocationByName(FName BoneName, uint8_t BoneSpace);
    FRotator GetBoneRotationByName(FName BoneName, uint8_t BoneSpace);
    FVector GetBoneScaleByName(FName BoneName, uint8_t BoneSpace);
    FTransform GetBoneTransformByName(FName BoneName, uint8_t BoneSpace);
    void ResetBoneTransformByName(FName BoneName);
    void SetBoneLocationByName(FName BoneName, FVector InLocation, uint8_t BoneSpace);
    void SetBoneRotationByName(FName BoneName, FRotator InRotation, uint8_t BoneSpace);
    void SetBoneScaleByName(FName BoneName, FVector InScale3D, uint8_t BoneSpace);
    void SetBoneTransformByName(FName BoneName, const FTransform& InTransform, uint8_t BoneSpace);
};

// Size: 0x9c0
class UPostProcessComponent : public USceneComponent {
    /* 0x0250 */ FPostProcessSettings Settings;
    /* 0x09b0 */ float Priority;
    /* 0x09b4 */ float BlendRadius;
    /* 0x09b8 */ float BlendWeight;
    /* 0x09bc */ bool bEnabled;
    /* 0x09bc */ bool bUnbound;

    void AddOrUpdateBlendable(TScriptInterface<IBlendableInterface> InBlendableObject, float InWeight);
};

// Size: 0x760
struct FPostProcessSettings {
    /* 0x0000 */ bool bOverride_TemperatureType;
    /* 0x0000 */ bool bOverride_WhiteTemp;
    /* 0x0000 */ bool bOverride_WhiteTint;
    /* 0x0000 */ bool bOverride_ColorSaturation;
    /* 0x0000 */ bool bOverride_ColorContrast;
    /* 0x0000 */ bool bOverride_ColorGamma;
    /* 0x0000 */ bool bOverride_ColorGain;
    /* 0x0000 */ bool bOverride_ColorOffset;
    /* 0x0001 */ bool bOverride_ColorSaturationShadows;
    /* 0x0001 */ bool bOverride_ColorContrastShadows;
    /* 0x0001 */ bool bOverride_ColorGammaShadows;
    /* 0x0001 */ bool bOverride_ColorGainShadows;
    /* 0x0001 */ bool bOverride_ColorOffsetShadows;
    /* 0x0001 */ bool bOverride_ColorSaturationMidtones;
    /* 0x0001 */ bool bOverride_ColorContrastMidtones;
    /* 0x0001 */ bool bOverride_ColorGammaMidtones;
    /* 0x0002 */ bool bOverride_ColorGainMidtones;
    /* 0x0002 */ bool bOverride_ColorOffsetMidtones;
    /* 0x0002 */ bool bOverride_ColorSaturationHighlights;
    /* 0x0002 */ bool bOverride_ColorContrastHighlights;
    /* 0x0002 */ bool bOverride_ColorGammaHighlights;
    /* 0x0002 */ bool bOverride_ColorGainHighlights;
    /* 0x0002 */ bool bOverride_ColorOffsetHighlights;
    /* 0x0002 */ bool bOverride_ColorCorrectionShadowsMax;
    /* 0x0003 */ bool bOverride_ColorCorrectionHighlightsMin;
    /* 0x0003 */ bool bOverride_ColorCorrectionHighlightsMax;
    /* 0x0003 */ bool bOverride_BlueCorrection;
    /* 0x0003 */ bool bOverride_ExpandGamut;
    /* 0x0003 */ bool bOverride_ToneCurveAmount;
    /* 0x0003 */ bool bOverride_FilmSlope;
    /* 0x0003 */ bool bOverride_FilmToe;
    /* 0x0003 */ bool bOverride_FilmShoulder;
    /* 0x0004 */ bool bOverride_FilmBlackClip;
    /* 0x0004 */ bool bOverride_FilmWhiteClip;
    /* 0x0004 */ bool bOverride_SceneColorTint;
    /* 0x0004 */ bool bOverride_SceneFringeIntensity;
    /* 0x0004 */ bool bOverride_ChromaticAberrationStartOffset;
    /* 0x0004 */ bool bOverride_bMegaLights;
    /* 0x0004 */ bool bOverride_AmbientCubemapTint;
    /* 0x0004 */ bool bOverride_AmbientCubemapIntensity;
    /* 0x0005 */ bool bOverride_BloomMethod;
    /* 0x0005 */ bool bOverride_BloomIntensity;
    /* 0x0005 */ bool bOverride_BloomThreshold;
    /* 0x0005 */ bool bOverride_Bloom1Tint;
    /* 0x0005 */ bool bOverride_Bloom1Size;
    /* 0x0005 */ bool bOverride_Bloom2Size;
    /* 0x0005 */ bool bOverride_Bloom2Tint;
    /* 0x0005 */ bool bOverride_Bloom3Tint;
    /* 0x0006 */ bool bOverride_Bloom3Size;
    /* 0x0006 */ bool bOverride_Bloom4Tint;
    /* 0x0006 */ bool bOverride_Bloom4Size;
    /* 0x0006 */ bool bOverride_Bloom5Tint;
    /* 0x0006 */ bool bOverride_Bloom5Size;
    /* 0x0006 */ bool bOverride_Bloom6Tint;
    /* 0x0006 */ bool bOverride_Bloom6Size;
    /* 0x0006 */ bool bOverride_BloomSizeScale;
    /* 0x0007 */ bool bOverride_BloomConvolutionTexture;
    /* 0x0007 */ bool bOverride_BloomConvolutionScatterDispersion;
    /* 0x0007 */ bool bOverride_BloomConvolutionSize;
    /* 0x0007 */ bool bOverride_BloomConvolutionCenterUV;
    /* 0x0007 */ bool bOverride_BloomConvolutionPreFilter;
    /* 0x0007 */ bool bOverride_BloomConvolutionPreFilterMin;
    /* 0x0007 */ bool bOverride_BloomConvolutionPreFilterMax;
    /* 0x0007 */ bool bOverride_BloomConvolutionPreFilterMult;
    /* 0x0008 */ bool bOverride_BloomConvolutionBufferScale;
    /* 0x0008 */ bool bOverride_BloomDirtMaskIntensity;
    /* 0x0008 */ bool bOverride_BloomDirtMaskTint;
    /* 0x0008 */ bool bOverride_BloomDirtMask;
    /* 0x0008 */ bool bOverride_CameraShutterSpeed;
    /* 0x0008 */ bool bOverride_CameraISO;
    /* 0x0008 */ bool bOverride_AutoExposureMethod;
    /* 0x0008 */ bool bOverride_AutoExposureLowPercent;
    /* 0x0009 */ bool bOverride_AutoExposureHighPercent;
    /* 0x0009 */ bool bOverride_AutoExposureMinBrightness;
    /* 0x0009 */ bool bOverride_AutoExposureMaxBrightness;
    /* 0x0009 */ bool bOverride_AutoExposureCalibrationConstant;
    /* 0x0009 */ bool bOverride_AutoExposureSpeedUp;
    /* 0x0009 */ bool bOverride_AutoExposureSpeedDown;
    /* 0x0009 */ bool bOverride_AutoExposureBias;
    /* 0x0009 */ bool bOverride_AutoExposureBiasCurve;
    /* 0x000a */ bool bOverride_AutoExposureMeterMask;
    /* 0x000a */ bool bOverride_AutoExposureApplyPhysicalCameraExposure;
    /* 0x000a */ bool bOverride_HistogramLogMin;
    /* 0x000a */ bool bOverride_HistogramLogMax;
    /* 0x000a */ bool bOverride_LocalExposureMethod;
    /* 0x000a */ bool bOverride_LocalExposureContrastScale;
    /* 0x000a */ bool bOverride_LocalExposureHighlightContrastScale;
    /* 0x000a */ bool bOverride_LocalExposureShadowContrastScale;
    /* 0x000b */ bool bOverride_LocalExposureHighlightContrastCurve;
    /* 0x000b */ bool bOverride_LocalExposureShadowContrastCurve;
    /* 0x000b */ bool bOverride_LocalExposureHighlightThreshold;
    /* 0x000b */ bool bOverride_LocalExposureShadowThreshold;
    /* 0x000b */ bool bOverride_LocalExposureDetailStrength;
    /* 0x000b */ bool bOverride_LocalExposureBlurredLuminanceBlend;
    /* 0x000b */ bool bOverride_LocalExposureBlurredLuminanceKernelSizePercent;
    /* 0x000b */ bool bOverride_LocalExposureHighlightThresholdStrength;
    /* 0x000c */ bool bOverride_LocalExposureShadowThresholdStrength;
    /* 0x000c */ bool bOverride_LocalExposureMiddleGreyBias;
    /* 0x000c */ bool bOverride_LensFlareIntensity;
    /* 0x000c */ bool bOverride_LensFlareTint;
    /* 0x000c */ bool bOverride_LensFlareTints;
    /* 0x000c */ bool bOverride_LensFlareBokehSize;
    /* 0x000c */ bool bOverride_LensFlareBokehShape;
    /* 0x000c */ bool bOverride_LensFlareThreshold;
    /* 0x000d */ bool bOverride_VignetteIntensity;
    /* 0x000d */ bool bOverride_Sharpen;
    /* 0x000d */ bool bOverride_GrainIntensity;
    /* 0x000d */ bool bOverride_GrainJitter;
    /* 0x000d */ bool bOverride_FilmGrainIntensity;
    /* 0x000d */ bool bOverride_FilmGrainIntensityShadows;
    /* 0x000d */ bool bOverride_FilmGrainIntensityMidtones;
    /* 0x000d */ bool bOverride_FilmGrainIntensityHighlights;
    /* 0x000e */ bool bOverride_FilmGrainShadowsMax;
    /* 0x000e */ bool bOverride_FilmGrainHighlightsMin;
    /* 0x000e */ bool bOverride_FilmGrainHighlightsMax;
    /* 0x000e */ bool bOverride_FilmGrainTexelSize;
    /* 0x000e */ bool bOverride_FilmGrainTexture;
    /* 0x000e */ bool bOverride_AmbientOcclusionIntensity;
    /* 0x000e */ bool bOverride_AmbientOcclusionStaticFraction;
    /* 0x000e */ bool bOverride_AmbientOcclusionRadius;
    /* 0x000f */ bool bOverride_AmbientOcclusionFadeDistance;
    /* 0x000f */ bool bOverride_AmbientOcclusionFadeRadius;
    /* 0x000f */ bool bOverride_AmbientOcclusionDistance;
    /* 0x000f */ bool bOverride_AmbientOcclusionRadiusInWS;
    /* 0x000f */ bool bOverride_AmbientOcclusionPower;
    /* 0x000f */ bool bOverride_AmbientOcclusionBias;
    /* 0x000f */ bool bOverride_AmbientOcclusionQuality;
    /* 0x000f */ bool bOverride_AmbientOcclusionMipBlend;
    /* 0x0010 */ bool bOverride_AmbientOcclusionMipScale;
    /* 0x0010 */ bool bOverride_AmbientOcclusionMipThreshold;
    /* 0x0010 */ bool bOverride_AmbientOcclusionTemporalBlendWeight;
    /* 0x0014 */ bool bOverride_RayTracingAO;
    /* 0x0014 */ bool bOverride_RayTracingAOSamplesPerPixel;
    /* 0x0014 */ bool bOverride_RayTracingAOIntensity;
    /* 0x0014 */ bool bOverride_RayTracingAORadius;
    /* 0x0018 */ bool bOverride_LPVIntensity;
    /* 0x0018 */ bool bOverride_LPVDirectionalOcclusionIntensity;
    /* 0x0018 */ bool bOverride_LPVDirectionalOcclusionRadius;
    /* 0x0018 */ bool bOverride_LPVDiffuseOcclusionExponent;
    /* 0x0018 */ bool bOverride_LPVSpecularOcclusionExponent;
    /* 0x0018 */ bool bOverride_LPVDiffuseOcclusionIntensity;
    /* 0x0018 */ bool bOverride_LPVSpecularOcclusionIntensity;
    /* 0x0018 */ bool bOverride_LPVSize;
    /* 0x0019 */ bool bOverride_LPVSecondaryOcclusionIntensity;
    /* 0x0019 */ bool bOverride_LPVSecondaryBounceIntensity;
    /* 0x0019 */ bool bOverride_LPVGeometryVolumeBias;
    /* 0x0019 */ bool bOverride_LPVVplInjectionBias;
    /* 0x0019 */ bool bOverride_LPVEmissiveInjectionIntensity;
    /* 0x0019 */ bool bOverride_LPVFadeRange;
    /* 0x0019 */ bool bOverride_LPVDirectionalOcclusionFadeRange;
    /* 0x0019 */ bool bOverride_IndirectLightingColor;
    /* 0x001a */ bool bOverride_IndirectLightingIntensity;
    /* 0x001a */ bool bOverride_ColorGradingIntensity;
    /* 0x001a */ bool bOverride_ColorGradingLUT;
    /* 0x001a */ bool bOverride_DepthOfFieldFocalDistance;
    /* 0x001a */ bool bOverride_DepthOfFieldFstop;
    /* 0x001a */ bool bOverride_DepthOfFieldMinFstop;
    /* 0x001a */ bool bOverride_DepthOfFieldBladeCount;
    /* 0x001a */ bool bOverride_DepthOfFieldSensorWidth;
    /* 0x001b */ bool bOverride_DepthOfFieldSqueezeFactor;
    /* 0x001b */ bool bOverride_DepthOfFieldDepthBlurRadius;
    /* 0x001b */ bool bOverride_DepthOfFieldUseHairDepth;
    /* 0x001b */ bool bOverride_DepthOfFieldPetzvalBokeh;
    /* 0x001b */ bool bOverride_DepthOfFieldPetzvalBokehFalloff;
    /* 0x001b */ bool bOverride_DepthOfFieldPetzvalExclusionBoxExtents;
    /* 0x001b */ bool bOverride_DepthOfFieldPetzvalExclusionBoxRadius;
    /* 0x001b */ bool bOverride_DepthOfFieldAspectRatioScalar;
    /* 0x001c */ bool bOverride_DepthOfFieldMatteBoxFlags;
    /* 0x001c */ bool bOverride_DepthOfFieldBarrelRadius;
    /* 0x001c */ bool bOverride_DepthOfFieldBarrelLength;
    /* 0x001c */ bool bOverride_DepthOfFieldDepthBlurAmount;
    /* 0x001c */ bool bOverride_DepthOfFieldFocalRegion;
    /* 0x001c */ bool bOverride_DepthOfFieldNearTransitionRegion;
    /* 0x001c */ bool bOverride_DepthOfFieldFarTransitionRegion;
    /* 0x001c */ bool bOverride_DepthOfFieldScale;
    /* 0x001d */ bool bOverride_DepthOfFieldNearBlurSize;
    /* 0x001d */ bool bOverride_DepthOfFieldFarBlurSize;
    /* 0x001d */ bool bOverride_MobileHQGaussian;
    /* 0x001d */ bool bOverride_DepthOfFieldOcclusion;
    /* 0x001d */ bool bOverride_DepthOfFieldSkyFocusDistance;
    /* 0x001d */ bool bOverride_DepthOfFieldVignetteSize;
    /* 0x001d */ bool bOverride_MotionBlurAmount;
    /* 0x001d */ bool bOverride_MotionBlurMax;
    /* 0x001e */ bool bOverride_MotionBlurTargetFPS;
    /* 0x001e */ bool bOverride_MotionBlurPerObjectSize;
    /* 0x001e */ bool bOverride_ScreenPercentage;
    /* 0x001e */ bool bOverride_ReflectionMethod;
    /* 0x001e */ bool bOverride_LumenReflectionQuality;
    /* 0x001e */ bool bOverride_ScreenSpaceReflectionIntensity;
    /* 0x001e */ bool bOverride_ScreenSpaceReflectionQuality;
    /* 0x001e */ bool bOverride_ScreenSpaceReflectionMaxRoughness;
    /* 0x001f */ bool bOverride_ScreenSpaceReflectionRoughnessScale;
    /* 0x001f */ bool bOverride_UserFlags;
    /* 0x0020 */ bool bOverride_ReflectionsType;
    /* 0x0020 */ bool bOverride_RayTracingReflectionsMaxRoughness;
    /* 0x0020 */ bool bOverride_RayTracingReflectionsMaxBounces;
    /* 0x0020 */ bool bOverride_RayTracingReflectionsSamplesPerPixel;
    /* 0x0020 */ bool bOverride_RayTracingReflectionsShadows;
    /* 0x0020 */ bool bOverride_RayTracingReflectionsTranslucency;
    /* 0x0020 */ bool bOverride_TranslucencyType;
    /* 0x0020 */ bool bOverride_RayTracingTranslucencyMaxRoughness;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyRefractionRays;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencySamplesPerPixel;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyShadows;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyRefraction;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyMaxPrimaryHitEvents;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyMaxSecondaryHitEvents;
    /* 0x0021 */ bool bOverride_RayTracingTranslucencyUseRayTracedRefraction;
    /* 0x0021 */ bool bOverride_DynamicGlobalIlluminationMethod;
    /* 0x0022 */ bool bOverride_LumenSceneLightingQuality;
    /* 0x0022 */ bool bOverride_LumenSceneDetail;
    /* 0x0022 */ bool bOverride_LumenSceneViewDistance;
    /* 0x0022 */ bool bOverride_LumenSceneLightingUpdateSpeed;
    /* 0x0022 */ bool bOverride_LumenFinalGatherQuality;
    /* 0x0022 */ bool bOverride_LumenFinalGatherLightingUpdateSpeed;
    /* 0x0022 */ bool bOverride_LumenFinalGatherScreenTraces;
    /* 0x0022 */ bool bOverride_LumenMaxTraceDistance;
    /* 0x0023 */ bool bOverride_LumenDiffuseColorBoost;
    /* 0x0023 */ bool bOverride_LumenSkylightLeaking;
    /* 0x0023 */ bool bOverride_LumenSkylightLeakingTint;
    /* 0x0023 */ bool bOverride_LumenFullSkylightLeakingDistance;
    /* 0x0024 */ bool bOverride_LumenRayLightingMode;
    /* 0x0024 */ bool bOverride_LumenReflectionsScreenTraces;
    /* 0x0024 */ bool bOverride_LumenFrontLayerTranslucencyReflections;
    /* 0x0028 */ bool bOverride_LumenMaxRoughnessToTraceReflections;
    /* 0x0028 */ bool bOverride_LumenMaxReflectionBounces;
    /* 0x0028 */ bool bOverride_LumenMaxRefractionBounces;
    /* 0x002c */ bool bOverride_LumenSurfaceCacheResolution;
    /* 0x0030 */ bool bOverride_RayTracingGI;
    /* 0x0030 */ bool bOverride_RayTracingGIMaxBounces;
    /* 0x0030 */ bool bOverride_RayTracingGISamplesPerPixel;
    /* 0x0030 */ bool bOverride_PathTracingMaxBounces;
    /* 0x0030 */ bool bOverride_PathTracingSamplesPerPixel;
    /* 0x0030 */ bool bOverride_PathTracingMaxPathIntensity;
    /* 0x0030 */ bool bOverride_PathTracingEnableEmissiveMaterials;
    /* 0x0030 */ bool bOverride_PathTracingEnableReferenceDOF;
    /* 0x0031 */ bool bOverride_PathTracingEnableReferenceAtmosphere;
    /* 0x0031 */ bool bOverride_PathTracingEnableDenoiser;
    /* 0x0031 */ bool bOverride_PathTracingIncludeEmissive;
    /* 0x0031 */ bool bOverride_PathTracingIncludeDiffuse;
    /* 0x0031 */ bool bOverride_PathTracingIncludeIndirectDiffuse;
    /* 0x0031 */ bool bOverride_PathTracingIncludeSpecular;
    /* 0x0031 */ bool bOverride_PathTracingIncludeIndirectSpecular;
    /* 0x0031 */ bool bOverride_PathTracingIncludeVolume;
    /* 0x0032 */ bool bOverride_PathTracingIncludeIndirectVolume;
    /* 0x0034 */ bool bMobileHQGaussian;
    /* 0x0035 */ uint8_t BloomMethod;
    /* 0x0036 */ uint8_t AutoExposureMethod;
    /* 0x0037 */ uint8_t TemperatureType;
    /* 0x0038 */ float WhiteTemp;
    /* 0x003c */ float WhiteTint;
    /* 0x0040 */ FVector4 ColorSaturation;
    /* 0x0060 */ FVector4 ColorContrast;
    /* 0x0080 */ FVector4 ColorGamma;
    /* 0x00a0 */ FVector4 ColorGain;
    /* 0x00c0 */ FVector4 ColorOffset;
    /* 0x00e0 */ FVector4 ColorSaturationShadows;
    /* 0x0100 */ FVector4 ColorContrastShadows;
    /* 0x0120 */ FVector4 ColorGammaShadows;
    /* 0x0140 */ FVector4 ColorGainShadows;
    /* 0x0160 */ FVector4 ColorOffsetShadows;
    /* 0x0180 */ FVector4 ColorSaturationMidtones;
    /* 0x01a0 */ FVector4 ColorContrastMidtones;
    /* 0x01c0 */ FVector4 ColorGammaMidtones;
    /* 0x01e0 */ FVector4 ColorGainMidtones;
    /* 0x0200 */ FVector4 ColorOffsetMidtones;
    /* 0x0220 */ FVector4 ColorSaturationHighlights;
    /* 0x0240 */ FVector4 ColorContrastHighlights;
    /* 0x0260 */ FVector4 ColorGammaHighlights;
    /* 0x0280 */ FVector4 ColorGainHighlights;
    /* 0x02a0 */ FVector4 ColorOffsetHighlights;
    /* 0x02c0 */ float ColorCorrectionHighlightsMin;
    /* 0x02c4 */ float ColorCorrectionHighlightsMax;
    /* 0x02c8 */ float ColorCorrectionShadowsMax;
    /* 0x02cc */ float BlueCorrection;
    /* 0x02d0 */ float ExpandGamut;
    /* 0x02d4 */ float ToneCurveAmount;
    /* 0x02d8 */ float FilmSlope;
    /* 0x02dc */ float FilmToe;
    /* 0x02e0 */ float FilmShoulder;
    /* 0x02e4 */ float FilmBlackClip;
    /* 0x02e8 */ float FilmWhiteClip;
    /* 0x02ec */ FLinearColor SceneColorTint;
    /* 0x02fc */ float SceneFringeIntensity;
    /* 0x0300 */ float ChromaticAberrationStartOffset;
    /* 0x0304 */ float BloomIntensity;
    /* 0x0308 */ float BloomThreshold;
    /* 0x030c */ float BloomSizeScale;
    /* 0x0310 */ float Bloom1Size;
    /* 0x0314 */ float Bloom2Size;
    /* 0x0318 */ float Bloom3Size;
    /* 0x031c */ float Bloom4Size;
    /* 0x0320 */ float Bloom5Size;
    /* 0x0324 */ float Bloom6Size;
    /* 0x0328 */ FLinearColor Bloom1Tint;
    /* 0x0338 */ FLinearColor Bloom2Tint;
    /* 0x0348 */ FLinearColor Bloom3Tint;
    /* 0x0358 */ FLinearColor Bloom4Tint;
    /* 0x0368 */ FLinearColor Bloom5Tint;
    /* 0x0378 */ FLinearColor Bloom6Tint;
    /* 0x0388 */ float BloomConvolutionScatterDispersion;
    /* 0x038c */ float BloomConvolutionSize;
    /* 0x0390 */ UTexture2D* BloomConvolutionTexture;
    /* 0x0398 */ FVector2D BloomConvolutionCenterUV;
    /* 0x03a8 */ float BloomConvolutionPreFilterMin;
    /* 0x03ac */ float BloomConvolutionPreFilterMax;
    /* 0x03b0 */ float BloomConvolutionPreFilterMult;
    /* 0x03b4 */ float BloomConvolutionBufferScale;
    /* 0x03b8 */ UTexture* BloomDirtMask;
    /* 0x03c0 */ float BloomDirtMaskIntensity;
    /* 0x03c4 */ FLinearColor BloomDirtMaskTint;
    /* 0x03d4 */ uint8_t DynamicGlobalIlluminationMethod;
    /* 0x03d8 */ FLinearColor IndirectLightingColor;
    /* 0x03e8 */ float IndirectLightingIntensity;
    /* 0x03ec */ ELumenRayLightingModeOverride LumenRayLightingMode;
    /* 0x03f0 */ float LumenSceneLightingQuality;
    /* 0x03f4 */ float LumenSceneDetail;
    /* 0x03f8 */ float LumenSceneViewDistance;
    /* 0x03fc */ float LumenSceneLightingUpdateSpeed;
    /* 0x0400 */ float LumenFinalGatherQuality;
    /* 0x0404 */ float LumenFinalGatherLightingUpdateSpeed;
    /* 0x0408 */ bool LumenFinalGatherScreenTraces;
    /* 0x040c */ float LumenMaxTraceDistance;
    /* 0x0410 */ float LumenDiffuseColorBoost;
    /* 0x0414 */ float LumenSkylightLeaking;
    /* 0x0418 */ FLinearColor LumenSkylightLeakingTint;
    /* 0x0428 */ float LumenFullSkylightLeakingDistance;
    /* 0x042c */ float LumenSurfaceCacheResolution;
    /* 0x0430 */ uint8_t ReflectionMethod;
    /* 0x0431 */ EReflectionsType ReflectionsType;
    /* 0x0434 */ float LumenReflectionQuality;
    /* 0x0438 */ bool LumenReflectionsScreenTraces;
    /* 0x0438 */ bool LumenFrontLayerTranslucencyReflections;
    /* 0x043c */ float LumenMaxRoughnessToTraceReflections;
    /* 0x0440 */ int32_t LumenMaxReflectionBounces;
    /* 0x0444 */ int32_t LumenMaxRefractionBounces;
    /* 0x0448 */ float ScreenSpaceReflectionIntensity;
    /* 0x044c */ float ScreenSpaceReflectionQuality;
    /* 0x0450 */ float ScreenSpaceReflectionMaxRoughness;
    /* 0x0454 */ bool bMegaLights;
    /* 0x0458 */ FLinearColor AmbientCubemapTint;
    /* 0x0468 */ float AmbientCubemapIntensity;
    /* 0x0470 */ UTextureCube* AmbientCubemap;
    /* 0x0478 */ float CameraShutterSpeed;
    /* 0x047c */ float CameraISO;
    /* 0x0480 */ float DepthOfFieldFstop;
    /* 0x0484 */ float DepthOfFieldMinFstop;
    /* 0x0488 */ int32_t DepthOfFieldBladeCount;
    /* 0x048c */ float AutoExposureBias;
    /* 0x0490 */ float AutoExposureBiasBackup;
    /* 0x0494 */ bool bOverride_AutoExposureBiasBackup;
    /* 0x0498 */ bool AutoExposureApplyPhysicalCameraExposure;
    /* 0x04a0 */ UCurveFloat* AutoExposureBiasCurve;
    /* 0x04a8 */ UTexture* AutoExposureMeterMask;
    /* 0x04b0 */ float AutoExposureLowPercent;
    /* 0x04b4 */ float AutoExposureHighPercent;
    /* 0x04b8 */ float AutoExposureMinBrightness;
    /* 0x04bc */ float AutoExposureMaxBrightness;
    /* 0x04c0 */ float AutoExposureSpeedUp;
    /* 0x04c4 */ float AutoExposureSpeedDown;
    /* 0x04c8 */ float HistogramLogMin;
    /* 0x04cc */ float HistogramLogMax;
    /* 0x04d0 */ float AutoExposureCalibrationConstant;
    /* 0x04d4 */ ELocalExposureMethod LocalExposureMethod;
    /* 0x04d8 */ float LocalExposureContrastScale;
    /* 0x04dc */ float LocalExposureHighlightContrastScale;
    /* 0x04e0 */ float LocalExposureShadowContrastScale;
    /* 0x04e8 */ UCurveFloat* LocalExposureHighlightContrastCurve;
    /* 0x04f0 */ UCurveFloat* LocalExposureShadowContrastCurve;
    /* 0x04f8 */ float LocalExposureHighlightThreshold;
    /* 0x04fc */ float LocalExposureShadowThreshold;
    /* 0x0500 */ float LocalExposureDetailStrength;
    /* 0x0504 */ float LocalExposureBlurredLuminanceBlend;
    /* 0x0508 */ float LocalExposureBlurredLuminanceKernelSizePercent;
    /* 0x050c */ float LocalExposureHighlightThresholdStrength;
    /* 0x0510 */ float LocalExposureShadowThresholdStrength;
    /* 0x0514 */ float LocalExposureMiddleGreyBias;
    /* 0x0518 */ float LensFlareIntensity;
    /* 0x051c */ FLinearColor LensFlareTint;
    /* 0x052c */ float LensFlareBokehSize;
    /* 0x0530 */ float LensFlareThreshold;
    /* 0x0538 */ UTexture* LensFlareBokehShape;
    /* 0x0540 */ FLinearColor LensFlareTints[8];
    /* 0x05c0 */ float VignetteIntensity;
    /* 0x05c4 */ float Sharpen;
    /* 0x05c8 */ float GrainJitter;
    /* 0x05cc */ float GrainIntensity;
    /* 0x05d0 */ float FilmGrainIntensity;
    /* 0x05d4 */ float FilmGrainIntensityShadows;
    /* 0x05d8 */ float FilmGrainIntensityMidtones;
    /* 0x05dc */ float FilmGrainIntensityHighlights;
    /* 0x05e0 */ float FilmGrainShadowsMax;
    /* 0x05e4 */ float FilmGrainHighlightsMin;
    /* 0x05e8 */ float FilmGrainHighlightsMax;
    /* 0x05ec */ float FilmGrainTexelSize;
    /* 0x05f0 */ UTexture2D* FilmGrainTexture;
    /* 0x05f8 */ float AmbientOcclusionIntensity;
    /* 0x05fc */ float AmbientOcclusionStaticFraction;
    /* 0x0600 */ float AmbientOcclusionRadius;
    /* 0x0604 */ bool AmbientOcclusionRadiusInWS;
    /* 0x0608 */ float AmbientOcclusionFadeDistance;
    /* 0x060c */ float AmbientOcclusionFadeRadius;
    /* 0x0610 */ float AmbientOcclusionDistance;
    /* 0x0614 */ float AmbientOcclusionPower;
    /* 0x0618 */ float AmbientOcclusionBias;
    /* 0x061c */ float AmbientOcclusionQuality;
    /* 0x0620 */ float AmbientOcclusionMipBlend;
    /* 0x0624 */ float AmbientOcclusionMipScale;
    /* 0x0628 */ float AmbientOcclusionMipThreshold;
    /* 0x062c */ float AmbientOcclusionTemporalBlendWeight;
    /* 0x0630 */ bool RayTracingAO;
    /* 0x0634 */ int32_t RayTracingAOSamplesPerPixel;
    /* 0x0638 */ float RayTracingAOIntensity;
    /* 0x063c */ float RayTracingAORadius;
    /* 0x0640 */ float ColorGradingIntensity;
    /* 0x0648 */ UTexture* ColorGradingLUT;
    /* 0x0650 */ float DepthOfFieldSensorWidth;
    /* 0x0654 */ float DepthOfFieldSqueezeFactor;
    /* 0x0658 */ float DepthOfFieldFocalDistance;
    /* 0x065c */ float DepthOfFieldDepthBlurAmount;
    /* 0x0660 */ float DepthOfFieldDepthBlurRadius;
    /* 0x0664 */ bool DepthOfFieldUseHairDepth;
    /* 0x0668 */ float DepthOfFieldPetzvalBokeh;
    /* 0x066c */ float DepthOfFieldPetzvalBokehFalloff;
    /* 0x0670 */ FVector2f DepthOfFieldPetzvalExclusionBoxExtents;
    /* 0x0678 */ float DepthOfFieldPetzvalExclusionBoxRadius;
    /* 0x067c */ float DepthOfFieldAspectRatioScalar;
    /* 0x0680 */ float DepthOfFieldBarrelRadius;
    /* 0x0684 */ float DepthOfFieldBarrelLength;
    /* 0x0688 */ FMatteBoxFlag DepthOfFieldMatteBoxFlags[3];
    /* 0x06ac */ float DepthOfFieldFocalRegion;
    /* 0x06b0 */ float DepthOfFieldNearTransitionRegion;
    /* 0x06b4 */ float DepthOfFieldFarTransitionRegion;
    /* 0x06b8 */ float DepthOfFieldScale;
    /* 0x06bc */ float DepthOfFieldNearBlurSize;
    /* 0x06c0 */ float DepthOfFieldFarBlurSize;
    /* 0x06c4 */ float DepthOfFieldOcclusion;
    /* 0x06c8 */ float DepthOfFieldSkyFocusDistance;
    /* 0x06cc */ float DepthOfFieldVignetteSize;
    /* 0x06d0 */ float MotionBlurAmount;
    /* 0x06d4 */ float MotionBlurMax;
    /* 0x06d8 */ int32_t MotionBlurTargetFPS;
    /* 0x06dc */ float MotionBlurPerObjectSize;
    /* 0x06e0 */ float LPVIntensity;
    /* 0x06e4 */ float LPVVplInjectionBias;
    /* 0x06e8 */ float LPVSize;
    /* 0x06ec */ float LPVSecondaryOcclusionIntensity;
    /* 0x06f0 */ float LPVSecondaryBounceIntensity;
    /* 0x06f4 */ float LPVGeometryVolumeBias;
    /* 0x06f8 */ float LPVEmissiveInjectionIntensity;
    /* 0x06fc */ float LPVDirectionalOcclusionIntensity;
    /* 0x0700 */ float LPVDirectionalOcclusionRadius;
    /* 0x0704 */ float LPVDiffuseOcclusionExponent;
    /* 0x0708 */ float LPVSpecularOcclusionExponent;
    /* 0x070c */ float LPVDiffuseOcclusionIntensity;
    /* 0x0710 */ float LPVSpecularOcclusionIntensity;
    /* 0x0714 */ ETranslucencyType TranslucencyType;
    /* 0x0718 */ float RayTracingTranslucencyMaxRoughness;
    /* 0x071c */ int32_t RayTracingTranslucencyRefractionRays;
    /* 0x0720 */ int32_t RayTracingTranslucencySamplesPerPixel;
    /* 0x0724 */ int32_t RayTracingTranslucencyMaxPrimaryHitEvents;
    /* 0x0728 */ int32_t RayTracingTranslucencyMaxSecondaryHitEvents;
    /* 0x072c */ EReflectedAndRefractedRayTracedShadows RayTracingTranslucencyShadows;
    /* 0x072d */ bool RayTracingTranslucencyRefraction;
    /* 0x072d */ bool RayTracingTranslucencyUseRayTracedRefraction;
    /* 0x0730 */ int32_t PathTracingMaxBounces;
    /* 0x0734 */ int32_t PathTracingSamplesPerPixel;
    /* 0x0738 */ float PathTracingMaxPathIntensity;
    /* 0x073c */ bool PathTracingEnableEmissiveMaterials;
    /* 0x073c */ bool PathTracingEnableReferenceDOF;
    /* 0x073c */ bool PathTracingEnableReferenceAtmosphere;
    /* 0x073c */ bool PathTracingEnableDenoiser;
    /* 0x073c */ bool PathTracingIncludeEmissive;
    /* 0x073c */ bool PathTracingIncludeDiffuse;
    /* 0x073c */ bool PathTracingIncludeIndirectDiffuse;
    /* 0x073c */ bool PathTracingIncludeSpecular;
    /* 0x073d */ bool PathTracingIncludeIndirectSpecular;
    /* 0x073d */ bool PathTracingIncludeVolume;
    /* 0x073d */ bool PathTracingIncludeIndirectVolume;
    /* 0x0740 */ float LPVFadeRange;
    /* 0x0744 */ float LPVDirectionalOcclusionFadeRange;
    /* 0x0748 */ float ScreenPercentage;
    /* 0x074c */ int32_t UserFlags;
    /* 0x0750 */ FWeightedBlendables WeightedBlendables;
};

// Size: 0xa60
class APostProcessVolume : public AVolume {
    /* 0x02f0 */ FPostProcessSettings Settings;
    /* 0x0a50 */ float Priority;
    /* 0x0a54 */ float BlendRadius;
    /* 0x0a58 */ float BlendWeight;
    /* 0x0a5c */ bool bEnabled;
    /* 0x0a5c */ bool bUnbound;

    void AddOrUpdateBlendable(TScriptInterface<IBlendableInterface> InBlendableObject, float InWeight);
};

// Size: 0x150
struct FPrecomputedLightInstanceData : public FSceneComponentInstanceData {
    /* 0x00c0 */ FTransform Transform;
    /* 0x0120 */ FGuid OriginalLightGuid;
    /* 0x0130 */ FGuid LightGuid;
    /* 0x0140 */ int32_t PreviewShadowMapChannel;
};

// Size: 0x180
struct FPrecomputedSkyLightInstanceData : public FSceneComponentInstanceData {
    /* 0x00b8 */ FGuid OriginalLightGuid;
    /* 0x00c8 */ FGuid LightGuid;
    /* 0x00d8 */ float AverageBrightness;
};

// Size: 0x310
class APrecomputedVisibilityOverrideVolume : public AVolume {
    /* 0x02e0 */ TArray<AActor*> OverrideVisibleActors;
    /* 0x02f0 */ TArray<AActor*> OverrideInvisibleActors;
    /* 0x0300 */ TArray<FName> OverrideInvisibleLevels;
};

// Size: 0x2e0
class APrecomputedVisibilityVolume : public AVolume {
};

// Size: 0x78
struct FPredictProjectilePathParams {
    /* 0x0000 */ FVector StartLocation;
    /* 0x0018 */ FVector LaunchVelocity;
    /* 0x0030 */ bool bTraceWithCollision;
    /* 0x0034 */ float ProjectileRadius;
    /* 0x0038 */ float MaxSimTime;
    /* 0x003c */ bool bTraceWithChannel;
    /* 0x003d */ uint8_t TraceChannel;
    /* 0x0040 */ TArray<uint8_t> ObjectTypes;
    /* 0x0050 */ TArray<AActor*> ActorsToIgnore;
    /* 0x0060 */ float SimFrequency;
    /* 0x0064 */ float OverrideGravityZ;
    /* 0x0068 */ uint8_t DrawDebugType;
    /* 0x006c */ float DrawDebugTime;
    /* 0x0070 */ bool bTraceComplex;
};

// Size: 0x38
struct FPredictProjectilePathPointData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Velocity;
    /* 0x0030 */ float Time;
};

// Size: 0x148
struct FPredictProjectilePathResult {
    /* 0x0000 */ TArray<FPredictProjectilePathPointData> PathData;
    /* 0x0010 */ FPredictProjectilePathPointData LastTraceDestination;
    /* 0x0048 */ FHitResult HitResult;
};

// Size: 0x10
struct FPreviewAssetAttachContainer {
    /* 0x0000 */ TArray<FPreviewAttachedObjectPair> AttachedObjects;
};

// Size: 0x30
struct FPreviewAttachedObjectPair {
    /* 0x0000 */ TSoftObjectPtr<UObject> AttachedObject;
    /* 0x0028 */ FName AttachedTo;
};

// Size: 0x28
class IPreviewCollectionInterface : public UInterface {
};

// Size: 0x50
class UPreviewMeshCollection : public UDataAsset {
    /* 0x0038 */ USkeleton* Skeleton;
    /* 0x0040 */ TArray<FPreviewMeshCollectionEntry> SkeletalMeshes;
};

// Size: 0x50
struct FPreviewMeshCollectionEntry {
    /* 0x0000 */ TSoftObjectPtr<USkeletalMesh> SkeletalMesh;
    /* 0x0028 */ TSoftObjectPtr<UAnimBlueprint> AnimBlueprint;
};

// Size: 0x68
class UPrimaryAssetLabel : public UPrimaryDataAsset {
    /* 0x0030 */ FPrimaryAssetRules Rules;
    /* 0x003c */ bool bLabelAssetsInMyDirectory;
    /* 0x003c */ bool bIsRuntimeLabel;
    /* 0x003c */ bool bIncludeRedirectors;
    /* 0x0040 */ TArray<TSoftObjectPtr<UObject>> ExplicitAssets;
    /* 0x0050 */ TArray<TSoftClassPtr<UObject>> ExplicitBlueprints;
    /* 0x0060 */ FCollectionReference AssetCollection;
};

// Size: 0xc
struct FPrimaryAssetRules {
    /* 0x0000 */ int32_t Priority;
    /* 0x0004 */ int32_t ChunkId;
    /* 0x0008 */ bool bApplyRecursively;
    /* 0x0009 */ EPrimaryAssetCookRule CookRule;
};

// Size: 0x38
struct FPrimaryAssetRulesCustomOverride {
    /* 0x0000 */ FPrimaryAssetType PrimaryAssetType;
    /* 0x0008 */ FDirectoryPath FilterDirectory;
    /* 0x0018 */ FString FilterString;
    /* 0x0028 */ FPrimaryAssetRules Rules;
};

// Size: 0x1c
struct FPrimaryAssetRulesOverride {
    /* 0x0000 */ FPrimaryAssetId PrimaryAssetId;
    /* 0x0010 */ FPrimaryAssetRules Rules;
};

// Size: 0x88
struct FPrimaryAssetTypeInfo {
    /* 0x0000 */ FName PrimaryAssetType;
    /* 0x0008 */ TSoftClassPtr<UObject> AssetBaseClass;
    /* 0x0030 */ UClass* AssetBaseClassLoaded;
    /* 0x0038 */ bool bHasBlueprintClasses;
    /* 0x0039 */ bool bIsEditorOnly;
    /* 0x0040 */ TArray<FDirectoryPath> Directories;
    /* 0x0050 */ TArray<FSoftObjectPath> SpecificAssets;
    /* 0x0060 */ FPrimaryAssetRules Rules;
    /* 0x0070 */ TArray<FString> AssetScanPaths;
    /* 0x0080 */ bool bIsDynamicAsset;
    /* 0x0084 */ int32_t NumberOfAssets;
};

// Size: 0x30
class UPrimaryDataAsset : public UDataAsset {
};

// Size: 0x520
class UPrimitiveComponent : public USceneComponent {
    /* 0x0258 */ float MinDrawDistance;
    /* 0x025c */ float LDMaxDrawDistance;
    /* 0x0260 */ float CachedMaxDrawDistance;
    /* 0x0264 */ uint8_t DepthPriorityGroup;
    /* 0x0265 */ uint8_t ViewOwnerDepthPriorityGroup;
    /* 0x0266 */ uint8_t IndirectLightingCacheQuality;
    /* 0x0267 */ ELightmapType LightmapType;
    /* 0x0268 */ EHLODBatchingPolicy HLODBatchingPolicy;
    /* 0x0269 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
    /* 0x026a */ bool bEnableAutoLODGeneration;
    /* 0x026a */ bool bIsActorTextureStreamingBuiltData;
    /* 0x026a */ bool bIsValidTextureStreamingBuiltData;
    /* 0x026a */ bool bNeverDistanceCull;
    /* 0x026b */ bool bAlwaysCreatePhysicsState;
    /* 0x026b */ bool bGenerateOverlapEvents;
    /* 0x026b */ bool bMultiBodyOverlap;
    /* 0x026b */ bool bTraceComplexOnMove;
    /* 0x026b */ bool bReturnMaterialOnMove;
    /* 0x026b */ bool bUseViewOwnerDepthPriorityGroup;
    /* 0x026c */ bool bAllowCullDistanceVolume;
    /* 0x026c */ bool bVisibleInReflectionCaptures;
    /* 0x026c */ bool bVisibleInRealTimeSkyCaptures;
    /* 0x026c */ bool bVisibleInRayTracing;
    /* 0x026c */ bool bRenderInMainPass;
    /* 0x026c */ bool bRenderInDepthPass;
    /* 0x026c */ bool bReceivesDecals;
    /* 0x026c */ bool bHoldout;
    /* 0x026d */ bool bOwnerNoSee;
    /* 0x026d */ bool bOnlyOwnerSee;
    /* 0x026d */ bool bTreatAsBackgroundForOcclusion;
    /* 0x026d */ bool bUseAsOccluder;
    /* 0x026d */ bool bSelectable;
    /* 0x026d */ bool bWantsEditorEffects;
    /* 0x026d */ bool bForceMipStreaming;
    /* 0x026d */ bool bHasPerInstanceHitProxies;
    /* 0x026e */ bool CastShadow;
    /* 0x026e */ bool bEmissiveLightSource;
    /* 0x026e */ bool bAffectDynamicIndirectLighting;
    /* 0x026e */ bool bAffectIndirectLightingWhileHidden;
    /* 0x026e */ bool bAffectDistanceFieldLighting;
    /* 0x026e */ bool bCastDynamicShadow;
    /* 0x026e */ bool bCastStaticShadow;
    /* 0x026e */ bool bCastVolumetricTranslucentShadow;
    /* 0x026f */ bool bCastContactShadow;
    /* 0x026f */ bool bSelfShadowOnly;
    /* 0x026f */ bool bCastFarShadow;
    /* 0x026f */ bool bCastInsetShadow;
    /* 0x026f */ bool bCastCinematicShadow;
    /* 0x026f */ bool bCastHiddenShadow;
    /* 0x026f */ bool bCastShadowAsTwoSided;
    /* 0x026f */ bool bLightAsIfStatic;
    /* 0x0270 */ bool bLightAttachmentsAsGroup;
    /* 0x0270 */ bool bExcludeFromLightAttachmentGroup;
    /* 0x0270 */ bool bReceiveMobileCSMShadows;
    /* 0x0270 */ bool bSingleSampleShadowFromStationaryLights;
    /* 0x0270 */ bool bIgnoreRadialImpulse;
    /* 0x0270 */ bool bIgnoreRadialForce;
    /* 0x0270 */ bool bApplyImpulseOnDamage;
    /* 0x0270 */ bool bReplicatePhysicsToAutonomousProxy;
    /* 0x0271 */ bool bFillCollisionUnderneathForNavmesh;
    /* 0x0271 */ bool bRasterizeAsFilledConvexVolume;
    /* 0x0271 */ bool AlwaysLoadOnClient;
    /* 0x0271 */ bool AlwaysLoadOnServer;
    /* 0x0271 */ bool bUseEditorCompositing;
    /* 0x0271 */ bool bIsBeingMovedByEditor;
    /* 0x0271 */ bool bRenderCustomDepth;
    /* 0x0271 */ bool bVisibleInSceneCaptureOnly;
    /* 0x0272 */ bool bHiddenInSceneCapture;
    /* 0x0272 */ bool bRayTracingFarField;
    /* 0x0273 */ EFirstPersonPrimitiveType FirstPersonPrimitiveType;
    /* 0x0274 */ bool bHasNoStreamableTextures;
    /* 0x0274 */ bool bStaticWhenNotMoveable;
    /* 0x0275 */ uint8_t bHasCustomNavigableGeometry;
    /* 0x0277 */ uint8_t CanCharacterStepUpOn;
    /* 0x0278 */ FLightingChannels LightingChannels;
    /* 0x0299 */ ERayTracingGroupCullingPriority RayTracingGroupCullingPriority;
    /* 0x029a */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x029b */ uint8_t ExcludeFromHLODLevels;
    /* 0x029c */ int32_t RayTracingGroupId;
    /* 0x02a0 */ int32_t VisibilityId;
    /* 0x02a4 */ int32_t CustomDepthStencilValue;
    /* 0x02a8 */ FCustomPrimitiveData CustomPrimitiveData;
    /* 0x02b8 */ FCustomPrimitiveData CustomPrimitiveDataInternal;
    /* 0x02f0 */ int32_t TranslucencySortPriority;
    /* 0x02f4 */ float TranslucencySortDistanceOffset;
    /* 0x02f8 */ TArray<URuntimeVirtualTexture*> RuntimeVirtualTextures;
    /* 0x0308 */ int8_t VirtualTextureLodBias;
    /* 0x0309 */ int8_t VirtualTextureCullMips;
    /* 0x030a */ int8_t VirtualTextureMinCoverage;
    /* 0x030b */ ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType;
    /* 0x0314 */ float BoundsScale;
    /* 0x0348 */ TArray<AActor*> MoveIgnoreActors;
    /* 0x0358 */ TArray<UPrimitiveComponent*> MoveIgnoreComponents;
    /* 0x0378 */ FBodyInstance BodyInstance;
    /* 0x04f8 */ FMulticastSparseDelegate OnComponentHit;
    /* 0x04f9 */ FMulticastSparseDelegate OnComponentBeginOverlap;
    /* 0x04fa */ FMulticastSparseDelegate OnComponentEndOverlap;
    /* 0x04fb */ FMulticastSparseDelegate OnComponentWake;
    /* 0x04fc */ FMulticastSparseDelegate OnComponentSleep;
    /* 0x04fe */ FMulticastSparseDelegate OnComponentPhysicsStateChanged;
    /* 0x04ff */ FMulticastSparseDelegate OnBeginCursorOver;
    /* 0x0500 */ FMulticastSparseDelegate OnEndCursorOver;
    /* 0x0501 */ FMulticastSparseDelegate OnClicked;
    /* 0x0502 */ FMulticastSparseDelegate OnReleased;
    /* 0x0503 */ FMulticastSparseDelegate OnInputTouchBegin;
    /* 0x0504 */ FMulticastSparseDelegate OnInputTouchEnd;
    /* 0x0505 */ FMulticastSparseDelegate OnInputTouchEnter;
    /* 0x0506 */ FMulticastSparseDelegate OnInputTouchLeave;
    /* 0x0518 */ UPrimitiveComponent* LODParentPrimitive;

    void AddAngularImpulseInDegrees(FVector Impulse, FName BoneName, bool bVelChange);
    void AddAngularImpulseInRadians(FVector Impulse, FName BoneName, bool bVelChange);
    void AddForce(FVector Force, FName BoneName, bool bAccelChange);
    void AddForceAtLocation(FVector Force, FVector Location, FName BoneName);
    void AddForceAtLocationLocal(FVector Force, FVector Location, FName BoneName);
    void AddImpulse(FVector Impulse, FName BoneName, bool bVelChange);
    void AddImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName);
    void AddRadialForce(FVector Origin, float Radius, float Strength, uint8_t Falloff, bool bAccelChange);
    void AddRadialImpulse(FVector Origin, float Radius, float Strength, uint8_t Falloff, bool bVelChange);
    void AddTorqueInDegrees(FVector Torque, FName BoneName, bool bAccelChange);
    void AddTorqueInRadians(FVector Torque, FName BoneName, bool bAccelChange);
    void AddVelocityChangeImpulseAtLocation(FVector Impulse, FVector Location, FName BoneName);
    bool AllowHLODLevelsExclusion() const;
    bool CanCharacterStepUp(APawn* Pawn) const;
    void ClearMoveIgnoreActors();
    void ClearMoveIgnoreComponents();
    TArray<AActor*> CopyArrayOfMoveIgnoreActors();
    TArray<UPrimitiveComponent*> CopyArrayOfMoveIgnoreComponents();
    UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamic(int32_t ElementIndex);
    UMaterialInstanceDynamic* CreateAndSetMaterialInstanceDynamicFromMaterial(int32_t ElementIndex, UMaterialInterface* Parent);
    UMaterialInstanceDynamic* CreateDynamicMaterialInstance(int32_t ElementIndex, UMaterialInterface* SourceMaterial, FName OptionalName);
    float GetAngularDamping() const;
    FBodyInstanceAsyncPhysicsTickHandle GetBodyInstanceAsyncPhysicsTickHandle(FName BoneName, bool bGetWelded, int32_t Index) const;
    FVector GetCenterOfMass(FName BoneName) const;
    float GetClosestPointOnCollision(const FVector& Point, FVector& OutPointOnBody, FName BoneName) const;
    uint8_t GetCollisionEnabled() const;
    uint8_t GetCollisionObjectType() const;
    FName GetCollisionProfileName() const;
    uint8_t GetCollisionResponseToChannel(uint8_t Channel) const;
    int32_t GetCustomPrimitiveDataIndexForScalarParameter(FName ParameterName) const;
    int32_t GetCustomPrimitiveDataIndexForVectorParameter(FName ParameterName) const;
    TArray<int32_t> GetExcludeForSpecificHLODLevels() const;
    bool GetGenerateOverlapEvents() const;
    bool GetGyroscopicTorqueEnabled() const;
    bool GetIgnoreBoundsForEditorFocus() const;
    FVector GetInertiaTensor(FName BoneName) const;
    float GetLinearDamping() const;
    float GetMass() const;
    float GetMassScale(FName BoneName) const;
    UMaterialInterface* GetMaterial(int32_t ElementIndex) const;
    UMaterialInterface* GetMaterialByName(FName MaterialSlotName) const;
    UMaterialInterface* GetMaterialFromCollisionFaceIndex(int32_t FaceIndex, int32_t& SectionIndex) const;
    int32_t GetMaterialIndex(FName MaterialSlotName) const;
    TArray<FName> GetMaterialSlotNames() const;
    float GetMaxDepenetrationVelocity(FName BoneName);
    int32_t GetNumMaterials() const;
    void GetOverlappingActors(TArray<AActor*>& OverlappingActors, UClass* ClassFilter) const;
    void GetOverlappingComponents(TArray<UPrimitiveComponent*>& OutOverlappingComponents) const;
    FVector GetPhysicsAngularVelocityInDegrees(FName BoneName) const;
    FVector GetPhysicsAngularVelocityInRadians(FName BoneName) const;
    FVector GetPhysicsLinearVelocity(FName BoneName);
    FVector GetPhysicsLinearVelocityAtPoint(FVector Point, FName BoneName);
    bool GetStaticWhenNotMoveable() const;
    bool GetUpdateKinematicFromSimulation() const;
    FWalkableSlopeOverride GetWalkableSlopeOverride() const;
    void HandlePostMigrationPhysicsStateChanged(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
    void IgnoreActorWhenMoving(AActor* Actor, bool bShouldIgnore);
    void IgnoreComponentWhenMoving(UPrimitiveComponent* Component, bool bShouldIgnore);
    void InvalidateLumenSurfaceCache();
    bool IsAnyRigidBodyAwake();
    bool IsExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel) const;
    bool IsGravityEnabled() const;
    bool IsMaterialSlotNameValid(FName MaterialSlotName) const;
    bool IsOverlappingActor(const AActor* Other) const;
    bool IsOverlappingComponent(const UPrimitiveComponent* OtherComp) const;
    bool K2_BoxOverlapComponent(FVector InBoxCentre, const FBox InBox, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
    bool K2_IsCollisionEnabled() const;
    bool K2_IsPhysicsCollisionEnabled() const;
    bool K2_IsQueryCollisionEnabled() const;
    bool K2_LineTraceComponent(FVector TraceStart, FVector TraceEnd, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
    bool K2_SphereOverlapComponent(FVector InSphereCentre, float InSphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
    bool K2_SphereTraceComponent(FVector TraceStart, FVector TraceEnd, float SphereRadius, bool bTraceComplex, bool bShowTrace, bool bPersistentShowTrace, FVector& HitLocation, FVector& HitNormal, FName& BoneName, FHitResult& OutHit);
    void PutRigidBodyToSleep(FName BoneName);
    void RegisterAsFocalPointInPhysicsReplicationLOD() const;
    FVector ScaleByMomentOfInertia(FVector InputVector, FName BoneName) const;
    void SetAffectDistanceFieldLighting(bool NewAffectDistanceFieldLighting);
    void SetAffectDynamicIndirectLighting(bool bNewAffectDynamicIndirectLighting);
    void SetAffectIndirectLightingWhileHidden(bool bNewAffectIndirectLightingWhileHidden);
    void SetAllMassScale(float InMassScale);
    void SetAllPhysicsAngularVelocityInDegrees(const FVector& NewAngVel, bool bAddToCurrent);
    void SetAllPhysicsAngularVelocityInRadians(const FVector& NewAngVel, bool bAddToCurrent);
    void SetAllPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent);
    void SetAllUseCCD(bool InUseCCD);
    void SetAllUseMACD(bool InUseMACD);
    void SetAngularDamping(float InDamping);
    void SetBoundsScale(float NewBoundsScale);
    void SetCastContactShadow(bool bInCastContactShadow);
    void SetCastHiddenShadow(bool NewCastHiddenShadow);
    void SetCastInsetShadow(bool bInCastInsetShadow);
    void SetCastShadow(bool NewCastShadow);
    void SetCenterOfMass(FVector CenterOfMassOffset, FName BoneName);
    void SetCollisionEnabled(uint8_t NewType);
    void SetCollisionObjectType(uint8_t Channel);
    void SetCollisionProfileName(FName InCollisionProfileName, bool bUpdateOverlaps);
    void SetCollisionResponseToAllChannels(uint8_t NewResponse);
    void SetCollisionResponseToChannel(uint8_t Channel, uint8_t NewResponse);
    void SetConstraintMode(uint8_t ConstraintMode);
    void SetCullDistance(float NewCullDistance);
    void SetCustomDepthStencilValue(int32_t Value);
    void SetCustomDepthStencilWriteMask(ERendererStencilMask WriteMaskBit);
    void SetCustomPrimitiveDataFloat(int32_t DataIndex, float Value);
    void SetCustomPrimitiveDataFloatArray(int32_t DataIndex, const TArray<float>& Values);
    void SetCustomPrimitiveDataVector2(int32_t DataIndex, FVector2D Value);
    void SetCustomPrimitiveDataVector3(int32_t DataIndex, FVector Value);
    void SetCustomPrimitiveDataVector4(int32_t DataIndex, FVector4 Value);
    void SetDefaultCustomPrimitiveDataFloat(int32_t DataIndex, float Value);
    void SetDefaultCustomPrimitiveDataFloatArray(int32_t DataIndex, const TArray<float>& Values);
    void SetDefaultCustomPrimitiveDataVector2(int32_t DataIndex, FVector2D Value);
    void SetDefaultCustomPrimitiveDataVector3(int32_t DataIndex, FVector Value);
    void SetDefaultCustomPrimitiveDataVector4(int32_t DataIndex, FVector4 Value);
    void SetEmissiveLightSource(bool NewEmissiveLightSource);
    void SetEnableGravity(bool bGravityEnabled);
    void SetExcludeForSpecificHLODLevels(const TArray<int32_t>& InExcludeForSpecificHLODLevels);
    void SetExcludeFromLightAttachmentGroup(bool bInExcludeFromLightAttachmentGroup);
    void SetExcludedFromHLODLevel(EHLODLevelExclusion HLODLevel, bool bExcluded);
    void SetFirstPersonPrimitiveType(EFirstPersonPrimitiveType Value);
    void SetGenerateOverlapEvents(bool bInGenerateOverlapEvents);
    void SetGyroscopicTorqueEnabled(bool bInGyroscopicTorqueEnabled);
    void SetHiddenInSceneCapture(bool bValue);
    void SetHoldout(bool bNewHoldout);
    void SetIgnoreBoundsForEditorFocus(bool bIgnore);
    void SetLightAttachmentsAsGroup(bool bInLightAttachmentsAsGroup);
    void SetLightingChannels(bool bChannel0, bool bChannel1, bool bChannel2);
    void SetLinearDamping(float InDamping);
    void SetMassOverrideInKg(FName BoneName, float MassInKg, bool bOverrideMass);
    void SetMassScale(FName BoneName, float InMassScale);
    void SetMaterial(int32_t ElementIndex, UMaterialInterface* Material);
    void SetMaterialByName(FName MaterialSlotName, UMaterialInterface* Material);
    void SetMaxDepenetrationVelocity(FName BoneName, float InMaxDepenetrationVelocity);
    void SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision);
    void SetOnlyOwnerSee(bool bNewOnlyOwnerSee);
    void SetOwnerNoSee(bool bNewOwnerNoSee);
    void SetPhysMaterialOverride(UPhysicalMaterial* NewPhysMaterial);
    void SetPhysicsAngularVelocityInDegrees(FVector NewAngVel, bool bAddToCurrent, FName BoneName);
    void SetPhysicsAngularVelocityInRadians(FVector NewAngVel, bool bAddToCurrent, FName BoneName);
    void SetPhysicsLinearVelocity(FVector NewVel, bool bAddToCurrent, FName BoneName);
    void SetPhysicsMaxAngularVelocityInDegrees(float NewMaxAngVel, bool bAddToCurrent, FName BoneName);
    void SetPhysicsMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent, FName BoneName);
    void SetReceivesDecals(bool bNewReceivesDecals);
    void SetRenderCustomDepth(bool bValue);
    void SetRenderInDepthPass(bool bValue);
    void SetRenderInMainPass(bool bValue);
    void SetScalarParameterForCustomPrimitiveData(FName ParameterName, float Value);
    void SetScalarParameterForDefaultCustomPrimitiveData(FName ParameterName, float Value);
    void SetSimulatePhysics(bool bSimulate);
    void SetSingleSampleShadowFromStationaryLights(bool bNewSingleSampleShadowFromStationaryLights);
    void SetStaticWhenNotMoveable(bool bInStaticWhenNotMoveable);
    void SetTranslucencySortDistanceOffset(float NewTranslucencySortDistanceOffset);
    void SetTranslucentSortPriority(int32_t NewTranslucentSortPriority);
    void SetUpdateKinematicFromSimulation(bool bUpdateKinematicFromSimulation);
    void SetUseCCD(bool InUseCCD, FName BoneName);
    void SetUseMACD(bool InUseMACD, FName BoneName);
    void SetVectorParameterForCustomPrimitiveData(FName ParameterName, FVector4 Value);
    void SetVectorParameterForDefaultCustomPrimitiveData(FName ParameterName, FVector4 Value);
    void SetVisibleInRayTracing(bool bNewVisibleInRayTracing);
    void SetVisibleInSceneCaptureOnly(bool bValue);
    void SetWalkableSlopeOverride(const FWalkableSlopeOverride& NewOverride);
    void UnregisterAsFocalPointInPhysicsReplicationLOD() const;
    void WakeAllRigidBodies();
    void WakeRigidBody(FName BoneName);
    bool WasRecentlyRendered(float Tolerance) const;
};

// Size: 0x130
struct FPrimitiveComponentInstanceData : public FSceneComponentInstanceData {
    /* 0x00c0 */ FTransform ComponentTransform;
    /* 0x0120 */ int32_t VisibilityId;
    /* 0x0128 */ UPrimitiveComponent* LODParent;
};

// Size: 0x4
struct FPrimitiveInstanceId {
};

// Size: 0x270
class UProjectileMovementComponent : public UMovementComponent {
    /* 0x0120 */ float InitialSpeed;
    /* 0x0124 */ float MaxSpeed;
    /* 0x0128 */ bool bRotationFollowsVelocity;
    /* 0x0128 */ bool bRotationRemainsVertical;
    /* 0x0128 */ bool bShouldBounce;
    /* 0x0128 */ bool bInitialVelocityInLocalSpace;
    /* 0x0128 */ bool bForceSubStepping;
    /* 0x0128 */ bool bSimulationEnabled;
    /* 0x0128 */ bool bSweepCollision;
    /* 0x0128 */ bool bIsHomingProjectile;
    /* 0x0129 */ bool bBounceAngleAffectsFriction;
    /* 0x0129 */ bool bIsSliding;
    /* 0x0129 */ bool bInterpMovement;
    /* 0x0129 */ bool bInterpRotation;
    /* 0x0129 */ bool bThrottleInterpolation;
    /* 0x0130 */ bool bSimulationUseScopedMovement;
    /* 0x0130 */ bool bInterpolationUseScopedMovement;
    /* 0x0134 */ float PreviousHitTime;
    /* 0x0138 */ FVector PreviousHitNormal;
    /* 0x0150 */ float ProjectileGravityScale;
    /* 0x0154 */ float Buoyancy;
    /* 0x0158 */ float Bounciness;
    /* 0x015c */ float Friction;
    /* 0x0160 */ float BounceVelocityStopSimulatingThreshold;
    /* 0x0164 */ float MinFrictionFraction;
    /* 0x0168 */ FMulticastInlineDelegate OnProjectileBounce;
    /* 0x0178 */ FMulticastInlineDelegate OnProjectileStop;
    /* 0x0188 */ float HomingAccelerationMagnitude;
    /* 0x018c */ TWeakObjectPtr<USceneComponent> HomingTargetComponent;
    /* 0x0194 */ float MaxSimulationTimeStep;
    /* 0x0198 */ int32_t MaxSimulationIterations;
    /* 0x019c */ int32_t BounceAdditionalIterations;
    /* 0x01a0 */ float InterpLocationTime;
    /* 0x01a4 */ float InterpRotationTime;
    /* 0x01a8 */ float InterpLocationMaxLagDistance;
    /* 0x01ac */ float InterpLocationSnapToTargetDistance;
    /* 0x01b0 */ float ThrottleInterpolationThresholdNotRenderedShortTime;
    /* 0x01b4 */ float ThrottleInterpolationThresholdNotRenderedLongTime;
    /* 0x01b8 */ int32_t ThrottleInterpolationSkipFramesRecent;
    /* 0x01bc */ int32_t ThrottleInterpolationSkipFramesNotRecent;

    bool IsInterpolationComplete() const;
    bool IsVelocityUnderSimulationThreshold() const;
    FVector LimitVelocity(FVector NewVelocity) const;
    void MoveInterpolationTarget(const FVector& NewLocation, const FRotator& NewRotation);
    void OnProjectileBounceDelegate__DelegateSignature(const FHitResult& ImpactResult, const FVector& ImpactVelocity);
    void OnProjectileStopDelegate__DelegateSignature(const FHitResult& ImpactResult);
    void ResetInterpolation();
    void SetInterpolatedComponent(USceneComponent* Component);
    void SetVelocityInLocalSpace(FVector NewVelocity);
    void StopSimulating(const FHitResult& HitResult);
};

// Size: 0x10
struct FPropertyAccessCopy {
    /* 0x0000 */ int32_t AccessIndex;
    /* 0x0004 */ int32_t DestAccessStartIndex;
    /* 0x0008 */ int32_t DestAccessEndIndex;
    /* 0x000c */ EPropertyAccessCopyType Type;
};

// Size: 0x10
struct FPropertyAccessCopyBatch {
    /* 0x0000 */ TArray<FPropertyAccessCopy> Copies;
};

// Size: 0x40
struct FPropertyAccessIndirection {
    /* 0x0000 */ FFieldPath Property;
    /* 0x0020 */ UFunction* Function;
    /* 0x0028 */ int32_t ReturnBufferSize;
    /* 0x002c */ int32_t ReturnBufferAlignment;
    /* 0x0030 */ int32_t ArrayIndex;
    /* 0x0034 */ uint32_t Offset;
    /* 0x0038 */ EPropertyAccessObjectType ObjectType;
    /* 0x0039 */ EPropertyAccessIndirectionType Type;
};

// Size: 0x28
struct FPropertyAccessIndirectionChain {
    /* 0x0000 */ FFieldPath Property;
    /* 0x0020 */ int32_t IndirectionStartIndex;
    /* 0x0024 */ int32_t IndirectionEndIndex;
};

// Size: 0x78
struct FPropertyAccessLibrary {
    /* 0x0000 */ TArray<FPropertyAccessSegment> PathSegments;
    /* 0x0010 */ TArray<FPropertyAccessPath> SrcPaths;
    /* 0x0020 */ TArray<FPropertyAccessPath> DestPaths;
    /* 0x0030 */ TArray<FPropertyAccessCopyBatch> CopyBatchArray;
};

// Size: 0x8
struct FPropertyAccessPath {
    /* 0x0000 */ int32_t PathSegmentStartIndex;
    /* 0x0004 */ int32_t PathSegmentCount;
};

// Size: 0x40
struct FPropertyAccessSegment {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UStruct* Struct;
    /* 0x0010 */ FFieldPath Property;
    /* 0x0030 */ UFunction* Function;
    /* 0x0038 */ int32_t ArrayIndex;
    /* 0x003c */ uint16_t Flags;
};

// Size: 0x1
struct FPropertyOverrideReferenceTable {
};

// Size: 0x40
class UProxyLODMeshSimplificationSettings : public UDeveloperSettings {
    /* 0x0038 */ FName ProxyLODMeshReductionModuleName;
};

// Size: 0x40
struct FPurchaseInfo {
    /* 0x0000 */ FString Identifier;
    /* 0x0010 */ FString DisplayName;
    /* 0x0020 */ FString DisplayDescription;
    /* 0x0030 */ FString DisplayPrice;
};

// Size: 0x20
struct FQuartzClockSettings {
    /* 0x0000 */ FQuartzTimeSignature TimeSignature;
    /* 0x0018 */ bool bIgnoreLevelChange;
};

// Size: 0x8
struct FQuartzPulseOverrideStep {
    /* 0x0000 */ int32_t NumberOfPulses;
    /* 0x0004 */ EQuartzCommandQuantization PulseDuration;
};

// Size: 0x20
struct FQuartzQuantizationBoundary {
    /* 0x0000 */ EQuartzCommandQuantization Quantization;
    /* 0x0004 */ float Multiplier;
    /* 0x0008 */ EQuarztQuantizationReference CountingReferencePoint;
    /* 0x0009 */ bool bFireOnClockStart;
    /* 0x000a */ bool bCancelCommandIfClockIsNotRunning;
    /* 0x000b */ bool bResetClockOnQueued;
    /* 0x000c */ bool bResumeClockOnQueued;
};

// Size: 0x18
struct FQuartzTimeSignature {
    /* 0x0000 */ int32_t NumBeats;
    /* 0x0004 */ EQuartzTimeSignatureQuantization BeatType;
    /* 0x0008 */ TArray<FQuartzPulseOverrideStep> OptionalPulseOverride;
};

// Size: 0x10
struct FQuartzTransportTimeStamp {
    /* 0x0000 */ int32_t Bars;
    /* 0x0004 */ int32_t Beat;
    /* 0x0008 */ float BeatFraction;
    /* 0x000c */ float Seconds;
};

// Size: 0x20
struct FQuaternionAnimationAttribute {
    /* 0x0000 */ FQuat Value;
};

// Size: 0x40
struct FQuaternionSpringState {
};

// Size: 0x18
struct FRPCAnalyticsThreshold {
    /* 0x0000 */ FName RPC;
    /* 0x0008 */ int32_t CountPerSec;
    /* 0x0010 */ double TimePerSec;
};

// Size: 0x88
class URPCDoSDetectionConfig : public UObject {
    /* 0x0028 */ bool bRPCDoSDetection;
    /* 0x0029 */ bool bRPCDoSAnalytics;
    /* 0x002c */ int32_t HitchTimeQuotaMS;
    /* 0x0030 */ int32_t HitchSuspendDetectionTimeMS;
    /* 0x0038 */ TArray<FString> DetectionSeverity;
    /* 0x0048 */ int32_t InitialConnectToleranceMS;
    /* 0x0050 */ TArray<FName> RPCBlockWhitelist;
    /* 0x0060 */ TArray<FName> RPCBlockAllowlist;
    /* 0x0070 */ TArray<FRPCAnalyticsThreshold> RPCAnalyticsThresholds;
    /* 0x0080 */ double RPCAnalyticsOverrideChance;
};

// Size: 0x48
struct FRPCDoSState {
    /* 0x0008 */ bool bLogEscalate;
    /* 0x0009 */ bool bSendEscalateAnalytics;
    /* 0x000a */ bool bKickPlayer;
    /* 0x000b */ bool bTrackRecentRPCs;
    /* 0x000c */ int16_t EscalateQuotaRPCsPerFrame;
    /* 0x000e */ int16_t EscalateTimeQuotaMSPerFrame;
    /* 0x0010 */ int16_t EscalateQuotaRPCsPerPeriod;
    /* 0x0012 */ int16_t EscalateTimeQuotaMSPerPeriod;
    /* 0x0014 */ int8_t EscalateQuotaTimePeriod;
    /* 0x0015 */ int8_t EscalationCountTolerance;
    /* 0x0016 */ int16_t EscalationTimeToleranceMS;
    /* 0x0018 */ int16_t RPCRepeatLimitPerPeriod;
    /* 0x001a */ int16_t RPCRepeatLimitMSPerPeriod;
    /* 0x001c */ int8_t RPCRepeatLimitTimePeriod;
    /* 0x001e */ int16_t CooloffTime;
    /* 0x0020 */ int16_t AutoEscalateTime;
};

// Size: 0x78
struct FRPCDoSStateConfig : public FRPCDoSState {
};

// Size: 0x28
class IRVOAvoidanceInterface : public UInterface {
};

// Size: 0x50
struct FRadialDamageEvent : public FDamageEvent {
    /* 0x0010 */ FRadialDamageParams Params;
    /* 0x0028 */ FVector Origin;
    /* 0x0040 */ TArray<FHitResult> ComponentHits;
};

// Size: 0x14
struct FRadialDamageParams {
    /* 0x0000 */ float BaseDamage;
    /* 0x0004 */ float MinimumDamage;
    /* 0x0008 */ float InnerRadius;
    /* 0x000c */ float OuterRadius;
    /* 0x0010 */ float DamageFalloff;
};

// Size: 0x2b0
class ARadialForceActor : public ARigidBodyBase {
    /* 0x02a8 */ URadialForceComponent* ForceComponent;

    void DisableForce();
    void EnableForce();
    void FireImpulse();
    void ToggleForce();
};

// Size: 0x270
class URadialForceComponent : public USceneComponent {
    /* 0x0240 */ float Radius;
    /* 0x0244 */ uint8_t Falloff;
    /* 0x0248 */ float ImpulseStrength;
    /* 0x024c */ bool bImpulseVelChange;
    /* 0x024c */ bool bIgnoreOwningActor;
    /* 0x0250 */ float ForceStrength;
    /* 0x0254 */ float DestructibleDamage;
    /* 0x0258 */ TArray<uint8_t> ObjectTypesToAffect;

    void AddObjectTypeToAffect(uint8_t ObjectType);
    void FireImpulse();
    void RemoveObjectTypeToAffect(uint8_t ObjectType);
};

// Size: 0x30
struct FRawAnimSequenceTrack {
    /* 0x0000 */ TArray<FVector3f> PosKeys;
    /* 0x0010 */ TArray<FQuat4f> RotKeys;
    /* 0x0020 */ TArray<FVector3f> ScaleKeys;
};

// Size: 0x28
class URawAnimSequenceTrackExtensions : public UBlueprintFunctionLibrary {

    static TArray<FVector> GetPositionalKeys(const FRawAnimSequenceTrack& Track);
    static TArray<FQuat> GetRotationalKeys(const FRawAnimSequenceTrack& Track);
    static TArray<FVector> GetScaleKeys(const FRawAnimSequenceTrack& Track);
};

// Size: 0x10
struct FRawCurveTracks {
    /* 0x0000 */ TArray<FFloatCurve> FloatCurves;
};

// Size: 0x20
struct FRawDistribution {
    /* 0x0000 */ FDistributionLookupTable Table;
};

// Size: 0x30
struct FRawDistributionFloat : public FRawDistribution {
    /* 0x0020 */ float MinValue;
    /* 0x0024 */ float MaxValue;
    /* 0x0028 */ UDistributionFloat* Distribution;
};

// Size: 0x60
struct FRawDistributionVector : public FRawDistribution {
    /* 0x0020 */ float MinValue;
    /* 0x0024 */ float MaxValue;
    /* 0x0028 */ FVector MinValueVec;
    /* 0x0040 */ FVector MaxValueVec;
    /* 0x0058 */ UDistributionVector* Distribution;
};

// Size: 0x70
struct FRealCurve : public FIndexedCurve {
    /* 0x0068 */ float DefaultValue;
    /* 0x006c */ uint8_t PreInfinityExtrap;
    /* 0x006d */ uint8_t PostInfinityExtrap;
};

// Size: 0x2c0
class ARectLight : public ALight {
    /* 0x02b8 */ URectLightComponent* RectLightComponent;
};

// Size: 0x3f0
class URectLightComponent : public ULocalLightComponent {
    /* 0x03b8 */ float SourceWidth;
    /* 0x03bc */ float SourceHeight;
    /* 0x03c0 */ float BarnDoorAngle;
    /* 0x03c4 */ float BarnDoorLength;
    /* 0x03c8 */ float LightFunctionConeAngle;
    /* 0x03d0 */ UTexture* SourceTexture;
    /* 0x03d8 */ FVector2f SourceTextureScale;
    /* 0x03e0 */ FVector2f SourceTextureOffset;
    /* 0x03e8 */ bool bLightRequiresBrokenEVMath;

    void SetBarnDoorAngle(float NewValue);
    void SetBarnDoorLength(float NewValue);
    void SetSourceHeight(float NewValue);
    void SetSourceTexture(UTexture* NewValue);
    void SetSourceWidth(float NewValue);
};

// Size: 0x10
struct FRedirector {
    /* 0x0000 */ FName OldName;
    /* 0x0008 */ FName NewName;
};

// Size: 0x18
struct FReferencePose {
    /* 0x0000 */ FName PoseName;
    /* 0x0008 */ TArray<FTransform> ReferencePose;
};

// Size: 0x2b0
class AReflectionCapture : public AActor {
    /* 0x02a8 */ UReflectionCaptureComponent* CaptureComponent;
};

// Size: 0x2b0
class UReflectionCaptureComponent : public USceneComponent {
    /* 0x0240 */ UBillboardComponent* CaptureOffsetComponent;
    /* 0x0248 */ EReflectionSourceType ReflectionSourceType;
    /* 0x0250 */ UTextureCube* Cubemap;
    /* 0x0258 */ float SourceCubemapAngle;
    /* 0x025c */ float Brightness;
    /* 0x0260 */ FVector CaptureOffset;
    /* 0x0278 */ FGuid MapBuildDataId;
};

// Size: 0x40
class URendererOverrideSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bSupportAllShaderPermutations;
};

// Size: 0x228
class URendererSettings : public UDeveloperSettings {
    /* 0x0038 */ uint8_t MobileShadingPath;
    /* 0x003c */ bool bMobileSupportDeferredOnOpenGL;
    /* 0x003c */ bool bMobileSupportGPUScene;
    /* 0x0040 */ uint8_t MobileAntiAliasing;
    /* 0x0041 */ uint8_t MobileFloatPrecisionMode;
    /* 0x0044 */ bool bMobileAllowDitheredLODTransition;
    /* 0x0044 */ bool bMobileVirtualTextures;
    /* 0x0044 */ bool bDiscardUnusedQualityLevels;
    /* 0x0048 */ uint8_t ShaderCompressionFormat;
    /* 0x004c */ bool bOcclusionCulling;
    /* 0x0050 */ float MinScreenRadiusForLights;
    /* 0x0054 */ float MinScreenRadiusForEarlyZPass;
    /* 0x0058 */ bool bPrecomputedVisibilityWarning;
    /* 0x0058 */ bool bTextureStreaming;
    /* 0x0058 */ bool bUseDXT5NormalMaps;
    /* 0x0058 */ bool bVirtualTextures;
    /* 0x0058 */ bool bVirtualTexturedLightmaps;
    /* 0x005c */ uint32_t VirtualTextureTileSize;
    /* 0x0060 */ uint32_t VirtualTextureTileBorderSize;
    /* 0x0064 */ bool bVirtualTextureAnisotropicFiltering;
    /* 0x0064 */ bool bVirtualTextureEnableAutoImport;
    /* 0x0064 */ bool bEnableVirtualTextureOpacityMask;
    /* 0x0064 */ bool bMeshPaintVirtualTextureSupport;
    /* 0x0068 */ uint32_t MeshPaintVirtualTextureTileSize;
    /* 0x006c */ uint32_t MeshPaintVirtualTextureTileBorderSize;
    /* 0x0070 */ bool MeshPaintVirtualTextureUseCompression;
    /* 0x0071 */ bool MeshPaintDefaultOnStaticMesh;
    /* 0x0074 */ int32_t MeshPaintDefaultTexelsPerVertex;
    /* 0x0078 */ int32_t MeshPaintVirtualTextureMaxTextureSize;
    /* 0x007c */ bool bEnableRVTBaseColor;
    /* 0x007d */ bool bEnableRVTBaseColorRoughness;
    /* 0x007e */ bool bEnableRVTBaseColorSpecular;
    /* 0x007f */ bool bEnableRVTMask4;
    /* 0x0080 */ bool bEnableRVTWorldHeight;
    /* 0x0081 */ bool bEnableRVTDisplacement;
    /* 0x0082 */ bool bUseHighQualityRVTHeightSampling;
    /* 0x0083 */ uint8_t WorkingColorSpaceChoice;
    /* 0x0088 */ FVector2D RedChromaticityCoordinate;
    /* 0x0098 */ FVector2D GreenChromaticityCoordinate;
    /* 0x00a8 */ FVector2D BlueChromaticityCoordinate;
    /* 0x00b8 */ FVector2D WhiteChromaticityCoordinate;
    /* 0x00c8 */ bool bUseLegacyLuminanceFactors;
    /* 0x00c8 */ bool bClearCoatEnableSecondNormal;
    /* 0x00cc */ uint8_t DynamicGlobalIllumination;
    /* 0x00cd */ uint8_t Reflections;
    /* 0x00d0 */ int32_t ReflectionCaptureResolution;
    /* 0x00d4 */ bool ReflectionEnvironmentLightmapMixBasedOnRoughness;
    /* 0x00d4 */ bool bUseHardwareRayTracingForLumen;
    /* 0x00d8 */ ELumenRayLightingMode LumenRayLightingMode;
    /* 0x00dc */ bool LumenFrontLayerTranslucencyReflections;
    /* 0x00e0 */ uint8_t LumenSoftwareTracingMode;
    /* 0x00e1 */ ELumenScreenTracingSource LumenScreenTracingSource;
    /* 0x00e4 */ bool LumenRayTracedTranslucentRefractions;
    /* 0x00e4 */ bool bEnableMegaLights;
    /* 0x00e4 */ bool bEnableRayTracingShadows;
    /* 0x00e8 */ uint8_t ShadowMapMethod;
    /* 0x00ec */ bool bEnableRayTracing;
    /* 0x00ec */ bool bGenerateRayTracingProxies;
    /* 0x00ec */ bool bEnableRayTracingSkylight;
    /* 0x00ec */ bool bEnableRayTracingTextureLOD;
    /* 0x00ec */ bool bEnablePathTracing;
    /* 0x00ec */ bool bGenerateMeshDistanceFields;
    /* 0x00f0 */ float DistanceFieldVoxelDensity;
    /* 0x00f4 */ bool bNanite;
    /* 0x00f4 */ bool bAllowStaticLighting;
    /* 0x00f4 */ bool bUseNormalMapsForStaticLighting;
    /* 0x00f4 */ bool bForwardShading;
    /* 0x00f4 */ bool bVertexFoggingForOpaque;
    /* 0x00f4 */ bool bSeparateTranslucency;
    /* 0x00f8 */ uint8_t TranslucentSortPolicy;
    /* 0x0100 */ FVector TranslucentSortAxis;
    /* 0x0118 */ bool bLocalFogVolumeApplyOnTranslucent;
    /* 0x011c */ uint8_t FoveationLevel;
    /* 0x0120 */ bool bDynamicFoveation;
    /* 0x0124 */ uint8_t CustomDepthStencil;
    /* 0x0128 */ bool bCustomDepthTaaJitter;
    /* 0x0128 */ bool bEnableAlphaChannelInPostProcessing;
    /* 0x0128 */ bool bDeferredSupportPrimitiveAlphaHoldout;
    /* 0x0128 */ bool bDefaultFeatureBloom;
    /* 0x0128 */ bool bDefaultFeatureAmbientOcclusion;
    /* 0x0128 */ bool bDefaultFeatureAmbientOcclusionStaticFraction;
    /* 0x0128 */ bool bDefaultFeatureAutoExposure;
    /* 0x012c */ uint8_t DefaultFeatureAutoExposure;
    /* 0x0130 */ float DefaultFeatureAutoExposureBias;
    /* 0x0134 */ bool bExtendDefaultLuminanceRangeInAutoExposureSettings;
    /* 0x0138 */ float DefaultFeatureLocalExposureHighlightContrast;
    /* 0x013c */ float DefaultFeatureLocalExposureShadowContrast;
    /* 0x0140 */ bool bDefaultFeatureMotionBlur;
    /* 0x0140 */ bool bDefaultFeatureLensFlare;
    /* 0x0140 */ bool bTemporalUpsampling;
    /* 0x0144 */ uint8_t DefaultFeatureAntiAliasing;
    /* 0x0145 */ uint8_t MSAASampleCount;
    /* 0x0146 */ ELightUnits DefaultLightUnits;
    /* 0x0147 */ uint8_t DefaultBackBufferPixelFormat;
    /* 0x0148 */ float DefaultManualScreenPercentage;
    /* 0x014c */ EScreenPercentageMode DefaultScreenPercentageDesktopMode;
    /* 0x0150 */ EScreenPercentageMode DefaultScreenPercentageMobileMode;
    /* 0x0154 */ EScreenPercentageMode DefaultScreenPercentageVRMode;
    /* 0x0158 */ EScreenPercentageMode DefaultScreenPercentagePathTracerMode;
    /* 0x015c */ bool bRenderUnbuiltPreviewShadowsInGame;
    /* 0x015c */ bool bStencilForLODDither;
    /* 0x0160 */ uint8_t EarlyZPass;
    /* 0x0164 */ bool bEarlyZPassOnlyMaterialMasking;
    /* 0x0164 */ bool bEnableCSMCaching;
    /* 0x0164 */ bool bDBuffer;
    /* 0x0168 */ uint8_t ClearSceneMethod;
    /* 0x0169 */ uint8_t VelocityPass;
    /* 0x016a */ uint8_t VertexDeformationOutputsVelocity;
    /* 0x016c */ bool bSelectiveBasePassOutputs;
    /* 0x016c */ bool bDefaultParticleCutouts;
    /* 0x0170 */ int32_t GPUSimulationTextureSizeX;
    /* 0x0174 */ int32_t GPUSimulationTextureSizeY;
    /* 0x0178 */ bool bGlobalClipPlane;
    /* 0x017c */ uint8_t GBufferFormat;
    /* 0x0180 */ bool bUseGPUMorphTargets;
    /* 0x0184 */ float MorphTargetMaxBlendWeight;
    /* 0x0188 */ bool bSupportSkyAtmosphere;
    /* 0x0188 */ bool bSupportSkyAtmosphereAffectsHeightFog;
    /* 0x0188 */ bool bSupportExpFogMatchesVolumetricFog;
    /* 0x0188 */ bool bSupportLocalFogVolumes;
    /* 0x0188 */ bool bSupportCloudShadowOnForwardLitTranslucent;
    /* 0x018c */ uint8_t LightFunctionAtlasPixelFormat;
    /* 0x0190 */ bool bVolumetricFogUsesLightFunctionAtlas;
    /* 0x0190 */ bool bDeferredLightingUsesLightFunctionAtlas;
    /* 0x0190 */ bool bSingleLayerWaterUsesLightFunctionAtlas;
    /* 0x0190 */ bool bTranslucentUsesLightFunctionAtlas;
    /* 0x0190 */ bool bSupportIESProfileOnTranslucent;
    /* 0x0190 */ bool bSupportRectLightOnTranslucent;
    /* 0x0190 */ bool bSupportShadowedLocalLightOnTranslucent;
    /* 0x0190 */ bool bGpuCrashDebugging;
    /* 0x0191 */ bool bMultiView;
    /* 0x0191 */ bool bMobilePostProcessing;
    /* 0x0191 */ bool bMobileMultiView;
    /* 0x0191 */ bool bMobileUseHWsRGBEncoding;
    /* 0x0191 */ bool bRoundRobinOcclusion;
    /* 0x0191 */ bool bMeshStreaming;
    /* 0x0191 */ bool bEnableHeterogeneousVolumes;
    /* 0x0191 */ bool bShouldHeterogeneousVolumesCastShadows;
    /* 0x0192 */ bool bCompositeHeterogeneousVolumesWithTranslucency;
    /* 0x0194 */ float WireframeCullThreshold;
    /* 0x0198 */ bool bSupportStationarySkylight;
    /* 0x0198 */ bool bSupportLowQualityLightmaps;
    /* 0x0198 */ bool bSupportPointLightWholeSceneShadows;
    /* 0x0198 */ bool bSupportTranslucentPerObjectShadow;
    /* 0x0198 */ bool bSupportCloudShadowOnSingleLayerWater;
    /* 0x0198 */ bool bEnableSubstrate;
    /* 0x0198 */ bool SubstrateOpaqueMaterialRoughRefraction;
    /* 0x0198 */ bool SubstrateTranslucentMaterialRoughRefraction;
    /* 0x0199 */ bool SubstrateDebugAdvancedVisualizationShaders;
    /* 0x0199 */ bool SubstrateEnableLayerSupport;
    /* 0x0199 */ bool bMaterialRoughDiffuse;
    /* 0x0199 */ bool bMaterialEnergyConservation;
    /* 0x0199 */ bool bAutomaticallySetMaterialUsageInEditorDefault;
    /* 0x0199 */ bool bOrderedIndependentTransparencyEnable;
    /* 0x0199 */ bool bUseHairStrandsAutoLODMode;
    /* 0x0199 */ bool bSupportSkinCacheShaders;
    /* 0x019a */ bool bSupportHardwareVariableRateShading;
    /* 0x019a */ bool bSkipCompilingGPUSkinVF;
    /* 0x019c */ ESkinCacheDefaultBehavior DefaultSkinCacheBehavior;
    /* 0x01a0 */ float SkinCacheSceneMemoryLimitInMB;
    /* 0x01a4 */ bool bMobileEnableStaticAndCSMShadowReceivers;
    /* 0x01a4 */ bool bMobileEnableMovableLightCSMShaderCulling;
    /* 0x01a8 */ uint8_t MobileLocalLightSetting;
    /* 0x01ac */ bool bMobileForwardEnableClusteredReflections;
    /* 0x01ac */ bool bMobileAllowDistanceFieldShadows;
    /* 0x01ac */ bool bMobileAllowMovableSpotlightShadows;
    /* 0x01ac */ bool bSupport16BitBoneIndex;
    /* 0x01ac */ bool bGPUSkinLimit2BoneInfluences;
    /* 0x01ac */ bool bSupportDepthOnlyIndexBuffers;
    /* 0x01ac */ bool bSupportReversedIndexBuffers;
    /* 0x01ac */ bool bMobileAmbientOcclusion;
    /* 0x01ad */ bool bMobileDBuffer;
    /* 0x01ad */ bool bUseUnlimitedBoneInfluences;
    /* 0x01ad */ bool bAlwaysUseDeformerForUnlimitedBoneInfluences;
    /* 0x01b0 */ int32_t UnlimitedBonInfluencesThreshold;
    /* 0x01b4 */ FPerPlatformInt DefaultBoneInfluenceLimit;
    /* 0x01b8 */ FPerPlatformInt MaxSkinBones;
    /* 0x01bc */ uint8_t MobilePlanarReflectionMode;
    /* 0x01c0 */ bool bMobileScreenSpaceReflections;
    /* 0x01c0 */ bool bMobileSupportsGen4TAA;
    /* 0x01c4 */ FPerPlatformBool bStreamSkeletalMeshLODs;
    /* 0x01c5 */ FPerPlatformBool bDiscardSkeletalMeshOptionalLODs;
    /* 0x01c8 */ FSoftObjectPath VisualizeCalibrationColorMaterialPath;
    /* 0x01e8 */ FSoftObjectPath VisualizeCalibrationCustomMaterialPath;
    /* 0x0208 */ FSoftObjectPath VisualizeCalibrationGrayscaleMaterialPath;
};

// Size: 0x60
struct FRepAttachment {
    /* 0x0000 */ AActor* AttachParent;
    /* 0x0008 */ FVector_NetQuantize100 LocationOffset;
    /* 0x0020 */ FVector_NetQuantize100 RelativeScale3D;
    /* 0x0038 */ FRotator RotationOffset;
    /* 0x0050 */ FName AttachSocket;
    /* 0x0058 */ USceneComponent* AttachComponent;
};

// Size: 0x88
struct FRepMovement {
    /* 0x0000 */ FVector LinearVelocity;
    /* 0x0018 */ FVector AngularVelocity;
    /* 0x0030 */ FVector Location;
    /* 0x0048 */ FRotator Rotation;
    /* 0x0060 */ FVector Acceleration;
    /* 0x0078 */ bool bSimulatedPhysicSleep;
    /* 0x0078 */ bool bRepPhysics;
    /* 0x0078 */ bool bRepAcceleration;
    /* 0x007c */ int32_t ServerFrame;
    /* 0x0080 */ int32_t ServerPhysicsHandle;
    /* 0x0084 */ EVectorQuantization LocationQuantizationLevel;
    /* 0x0085 */ EVectorQuantization VelocityQuantizationLevel;
    /* 0x0086 */ ERotatorQuantization RotationQuantizationLevel;
};

// Size: 0x10
struct FRepMovementNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0xc8
struct FRepRootMotionMontage {
    /* 0x0000 */ UAnimSequenceBase* Animation;
    /* 0x0008 */ bool bIsActive;
    /* 0x0009 */ bool bRelativePosition;
    /* 0x000a */ bool bRelativeRotation;
    /* 0x000c */ float position;
    /* 0x0010 */ FVector_NetQuantize100 Location;
    /* 0x0028 */ FRotator Rotation;
    /* 0x0040 */ UPrimitiveComponent* MovementBase;
    /* 0x0048 */ FName MovementBaseBoneName;
    /* 0x0050 */ FRootMotionSourceGroup AuthoritativeRootMotion;
    /* 0x0098 */ FVector_NetQuantize10 Acceleration;
    /* 0x00b0 */ FVector_NetQuantize10 LinearVelocity;
};

// Size: 0x28a0
class UReplayNetConnection : public UNetConnection {
};

// Size: 0x40
class UReplaySubsystem : public UGameInstanceSubsystem {
    /* 0x0030 */ bool bLoadDefaultMapOnStop;

    FString GetActiveReplayName() const;
    float GetReplayCurrentTime() const;
    float GetReplayTotalTime() const;
    bool IsPlaying() const;
    bool IsRecording() const;
    void RequestCheckpoint();
};

// Size: 0x28
class IReplicatedObjectInterface : public UInterface {
};

// Size: 0x40
struct FReplicatedStaticActorDestructionInfo {
    /* 0x0038 */ UClass* ObjClass;
};

// Size: 0x28
class UReplicationConnectionDriver : public UObject {
};

// Size: 0x28
class UReplicationDriver : public UObject {
};

// Size: 0x30
class UReporterBase : public UObject {
};

// Size: 0xc8
class UReporterGraph : public UReporterBase {
};

// Size: 0xc
struct FResponseChannel {
    /* 0x0000 */ FName Channel;
    /* 0x0008 */ uint8_t Response;
};

// Size: 0x60
class UReverbEffect : public UObject {
    /* 0x0028 */ bool bBypassEarlyReflections;
    /* 0x002c */ float ReflectionsDelay;
    /* 0x0030 */ float GainHF;
    /* 0x0034 */ float ReflectionsGain;
    /* 0x0038 */ bool bBypassLateReflections;
    /* 0x003c */ float LateDelay;
    /* 0x0040 */ float DecayTime;
    /* 0x0044 */ float Density;
    /* 0x0048 */ float Diffusion;
    /* 0x004c */ float AirAbsorptionGainHF;
    /* 0x0050 */ float DecayHFRatio;
    /* 0x0054 */ float LateGain;
    /* 0x0058 */ float Gain;
    /* 0x005c */ float RoomRolloffFactor;
};

enum class ReverbPreset {
    REVERB_Default = 0,
    REVERB_Bathroom = 1,
    REVERB_StoneRoom = 2,
    REVERB_Auditorium = 3,
    REVERB_ConcertHall = 4,
    REVERB_Cave = 5,
    REVERB_Hallway = 6,
    REVERB_StoneCorridor = 7,
    REVERB_Alley = 8,
    REVERB_Forest = 9,
    REVERB_City = 10,
    REVERB_Mountains = 11,
    REVERB_Quarry = 12,
    REVERB_Plain = 13,
    REVERB_ParkingLot = 14,
    REVERB_SewerPipe = 15,
    REVERB_Underwater = 16,
    REVERB_SmallRoom = 17,
    REVERB_MediumRoom = 18,
    REVERB_LargeRoom = 19,
    REVERB_MediumHall = 20,
    REVERB_LargeHall = 21,
    REVERB_Plate = 22,
    REVERB_MAX = 23,
};

// Size: 0x20
struct FReverbSettings {
    /* 0x0000 */ bool bApplyReverb;
    /* 0x0008 */ UReverbEffect* ReverbEffect;
    /* 0x0010 */ USoundEffectSubmixPreset* ReverbPluginEffect;
    /* 0x0018 */ float Volume;
    /* 0x001c */ float FadeTime;
};

// Size: 0x80
struct FRichCurve : public FRealCurve {
    /* 0x0070 */ TArray<FRichCurveKey> Keys;
};

// Size: 0x1c
struct FRichCurveKey {
    /* 0x0000 */ uint8_t InterpMode;
    /* 0x0001 */ uint8_t TangentMode;
    /* 0x0002 */ uint8_t TangentWeightMode;
    /* 0x0004 */ float Time;
    /* 0x0008 */ float Value;
    /* 0x000c */ float ArriveTangent;
    /* 0x0010 */ float ArriveTangentWeight;
    /* 0x0014 */ float LeaveTangent;
    /* 0x0018 */ float LeaveTangentWeight;
};

// Size: 0x2a8
class ARigidBodyBase : public AActor {
};

// Size: 0x48
struct FRigidBodyContactInfo {
    /* 0x0000 */ FVector ContactPosition;
    /* 0x0018 */ FVector ContactNormal;
    /* 0x0030 */ float ContactPenetration;
    /* 0x0034 */ bool bContactProbe;
    /* 0x0038 */ UPhysicalMaterial* PhysMaterial[2];
};

// Size: 0x34
struct FRigidBodyErrorCorrection {
    /* 0x0000 */ float PingExtrapolation;
    /* 0x0004 */ float PingLimit;
    /* 0x0008 */ float ErrorPerLinearDifference;
    /* 0x000c */ float ErrorPerAngularDifference;
    /* 0x0010 */ float MaxRestoredStateError;
    /* 0x0014 */ float MaxLinearHardSnapDistance;
    /* 0x0018 */ float PositionLerp;
    /* 0x001c */ float AngleLerp;
    /* 0x0020 */ float LinearVelocityCoefficient;
    /* 0x0024 */ float AngularVelocityCoefficient;
    /* 0x0028 */ float ErrorAccumulationSeconds;
    /* 0x002c */ float ErrorAccumulationDistanceSq;
    /* 0x0030 */ float ErrorAccumulationSimilarity;
};

// Size: 0x80
struct FRigidBodyState {
    /* 0x0000 */ FVector_NetQuantize100 position;
    /* 0x0020 */ FQuat Quaternion;
    /* 0x0040 */ FVector_NetQuantize100 LinVel;
    /* 0x0058 */ FVector_NetQuantize100 AngVel;
    /* 0x0070 */ uint8_t Flags;
};

// Size: 0xd0
struct FRollbackNetStartupActorInfo {
    /* 0x0008 */ UObject* Archetype;
    /* 0x00c0 */ TArray<UObject*> ObjReferences;
};

// Size: 0x10
struct FRootMotionExtractionStep {
    /* 0x0000 */ UAnimSequence* AnimSequence;
    /* 0x0008 */ float StartPosition;
    /* 0x000c */ float EndPosition;
};

// Size: 0x20
struct FRootMotionFinishVelocitySettings {
    /* 0x0000 */ ERootMotionFinishVelocityMode Mode;
    /* 0x0004 */ float ClampVelocity;
    /* 0x0008 */ FVector SetVelocity;
};

// Size: 0x70
struct FRootMotionMovementParams {
    /* 0x0000 */ bool bHasRootMotion;
    /* 0x0004 */ float BlendWeight;
    /* 0x0010 */ FTransform RootMotionTransform;
};

// Size: 0xc0
struct FRootMotionSource {
    /* 0x0008 */ uint16_t Priority;
    /* 0x000a */ uint16_t LocalID;
    /* 0x000c */ FName InstanceName;
    /* 0x0014 */ float StartTime;
    /* 0x0018 */ float CurrentTime;
    /* 0x001c */ float PreviousTime;
    /* 0x0020 */ float Duration;
    /* 0x0024 */ FRootMotionSourceStatus Status;
    /* 0x0025 */ FRootMotionSourceSettings Settings;
    /* 0x0026 */ ERootMotionAccumulateMode AccumulateMode;
    /* 0x0027 */ bool bInLocalSpace;
    /* 0x0030 */ FRootMotionMovementParams RootMotionParams;
    /* 0x00a0 */ FRootMotionFinishVelocitySettings FinishVelocityParams;
};

// Size: 0x48
struct FRootMotionSourceGroup {
    /* 0x0028 */ bool bHasAdditiveSources;
    /* 0x0028 */ bool bHasOverrideSources;
    /* 0x0028 */ bool bHasOverrideSourcesWithIgnoreZAccumulate;
    /* 0x0028 */ bool bIsAdditiveVelocityApplied;
    /* 0x0029 */ FRootMotionSourceSettings LastAccumulatedSettings;
    /* 0x0030 */ FVector_NetQuantize10 LastPreAdditiveVelocity;
};

// Size: 0x28
struct FRootMotionSourceGroupNetSerializerConfig : public FPolymorphicArrayStructNetSerializerConfig {
};

// Size: 0x1
struct FRootMotionSourceSettings {
    /* 0x0000 */ uint8_t Flags;
};

// Size: 0x1
struct FRootMotionSourceStatus {
    /* 0x0000 */ uint8_t Flags;
};

// Size: 0xe0
struct FRootMotionSource_ConstantForce : public FRootMotionSource {
    /* 0x00c0 */ FVector Force;
    /* 0x00d8 */ UCurveFloat* StrengthOverTime;
};

// Size: 0x110
struct FRootMotionSource_JumpForce : public FRootMotionSource {
    /* 0x00c0 */ FRotator Rotation;
    /* 0x00d8 */ float Distance;
    /* 0x00dc */ float Height;
    /* 0x00e0 */ bool bDisableTimeout;
    /* 0x00e8 */ UCurveVector* PathOffsetCurve;
    /* 0x00f0 */ UCurveFloat* TimeMappingCurve;
};

// Size: 0x120
struct FRootMotionSource_MoveToDynamicForce : public FRootMotionSource {
    /* 0x00c0 */ FVector StartLocation;
    /* 0x00d8 */ FVector InitialTargetLocation;
    /* 0x00f0 */ FVector TargetLocation;
    /* 0x0108 */ bool bRestrictSpeedToExpected;
    /* 0x0110 */ UCurveVector* PathOffsetCurve;
    /* 0x0118 */ UCurveFloat* TimeMappingCurve;
};

// Size: 0x100
struct FRootMotionSource_MoveToForce : public FRootMotionSource {
    /* 0x00c0 */ FVector StartLocation;
    /* 0x00d8 */ FVector TargetLocation;
    /* 0x00f0 */ bool bRestrictSpeedToExpected;
    /* 0x00f8 */ UCurveVector* PathOffsetCurve;
};

// Size: 0x120
struct FRootMotionSource_RadialForce : public FRootMotionSource {
    /* 0x00c0 */ FVector Location;
    /* 0x00d8 */ AActor* LocationActor;
    /* 0x00e0 */ float Radius;
    /* 0x00e4 */ float Strength;
    /* 0x00e8 */ bool bIsPush;
    /* 0x00e9 */ bool bNoZForce;
    /* 0x00f0 */ UCurveFloat* StrengthDistanceFalloff;
    /* 0x00f8 */ UCurveFloat* StrengthOverTime;
    /* 0x0100 */ bool bUseFixedWorldDirection;
    /* 0x0108 */ FRotator FixedWorldDirection;
};

// Size: 0x158
class URotatingMovementComponent : public UMovementComponent {
    /* 0x0120 */ FRotator RotationRate;
    /* 0x0138 */ FVector PivotTranslation;
    /* 0x0150 */ bool bRotationInLocalSpace;
};

// Size: 0x20
struct FRotationTrack {
    /* 0x0000 */ TArray<FQuat4f> RotKeys;
    /* 0x0010 */ TArray<float> Times;
};

// Size: 0x1
struct FRuntimeCellTransformerInstance {
};

// Size: 0x208
struct FRuntimeCurveLinearColor {
    /* 0x0000 */ FRichCurve ColorCurves[4];
    /* 0x0200 */ UCurveLinearColor* ExternalCurve;
};

// Size: 0x88
struct FRuntimeFloatCurve {
    /* 0x0000 */ FRichCurve EditorCurveData;
    /* 0x0080 */ UCurveFloat* ExternalCurve;
};

// Size: 0x1c0
class URuntimeHashExternalStreamingObjectBase : public UObject {
    /* 0x0038 */ TMap<FName, FName> SubObjectsToCellRemapping;
    /* 0x0088 */ FWorldPartitionRuntimeContainerResolver ContainerResolver;
    /* 0x00f0 */ TSoftObjectPtr<UWorld> OuterWorld;
    /* 0x0118 */ TMap<FName, FWorldPartitionRuntimeCellStreamingData> CellToStreamingData;
    /* 0x0168 */ TSet<UDataLayerInstance*> DataLayerInstances;
    /* 0x01b8 */ UExternalDataLayerInstance* RootExternalDataLayerInstance;
};

// Size: 0x1d0
class URuntimeHashSetExternalStreamingObject : public URuntimeHashExternalStreamingObjectBase {
    /* 0x01c0 */ TArray<FRuntimePartitionStreamingData> RuntimeStreamingData;
};

// Size: 0x38
class URuntimeOptionsBase : public UObject {
};

// Size: 0x58
class URuntimePartition : public UObject {
    /* 0x0028 */ FName Name;
    /* 0x0030 */ bool bBlockOnSlowStreaming;
    /* 0x0031 */ bool bClientOnlyVisible;
    /* 0x0034 */ int32_t Priority;
    /* 0x0038 */ ERuntimePartitionCellBoundsMethod BoundsMethod;
    /* 0x003c */ int32_t LoadingRange;
    /* 0x0040 */ FLinearColor DebugColor;
    /* 0x0050 */ int32_t HLODIndex;
};

// Size: 0x28
struct FRuntimePartitionDesc {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UClass* Class;
    /* 0x0010 */ URuntimePartition* MainLayer;
    /* 0x0018 */ TArray<FRuntimePartitionHLODSetup> HLODSetups;
};

// Size: 0x18
struct FRuntimePartitionHLODSetup {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ bool bIsSpatiallyLoaded;
    /* 0x0010 */ URuntimePartition* PartitionLayer;
};

// Size: 0x58
class URuntimePartitionLHGrid : public URuntimePartition {
};

// Size: 0x58
class URuntimePartitionLevelStreaming : public URuntimePartition {
};

// Size: 0x58
class URuntimePartitionPersistent : public URuntimePartition {
};

// Size: 0x48
struct FRuntimePartitionStreamingData {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t LoadingRange;
    /* 0x0010 */ TArray<UWorldPartitionRuntimeCell*> SpatiallyLoadedCells;
    /* 0x0020 */ TArray<UWorldPartitionRuntimeCell*> NonSpatiallyLoadedCells;
};

// Size: 0x1d0
class URuntimeSpatialHashExternalStreamingObject : public URuntimeHashExternalStreamingObjectBase {
    /* 0x01c0 */ TArray<FSpatialHashStreamingGrid> StreamingGrids;
};

// Size: 0x188
struct FRuntimeVectorCurve {
    /* 0x0000 */ FRichCurve VectorCurves[3];
    /* 0x0180 */ UCurveVector* ExternalCurve;
};

// Size: 0x100
class URuntimeVirtualTexture : public UObject {
    /* 0x0028 */ int32_t TileCount;
    /* 0x002c */ int32_t TileSize;
    /* 0x0030 */ int32_t TileBorderSize;
    /* 0x0034 */ ERuntimeVirtualTextureMaterialType MaterialType;
    /* 0x0035 */ bool bCompressTextures;
    /* 0x0036 */ bool bUseLowQualityCompression;
    /* 0x0037 */ EVTProducerPriority CustomPriority;
    /* 0x0038 */ bool bUseCustomPriority;
    /* 0x0039 */ bool bClearTextures;
    /* 0x003a */ bool bSinglePhysicalSpace;
    /* 0x003b */ bool bPrivateSpace;
    /* 0x003c */ bool bAdaptive;
    /* 0x003d */ bool bContinuousUpdate;
    /* 0x0040 */ int32_t RemoveLowMips;
    /* 0x0050 */ FVector4f CustomMaterialData;
    /* 0x0060 */ uint8_t LODGroup;
    /* 0x0064 */ int32_t Size;
    /* 0x0068 */ URuntimeVirtualTextureStreamingProxy* StreamingTexture;

    int32_t GetPageTableSize() const;
    int32_t GetSize() const;
    int32_t GetTileBorderSize() const;
    int32_t GetTileCount() const;
    int32_t GetTileSize() const;
};

// Size: 0x2e0
class URuntimeVirtualTextureComponent : public USceneComponent {
    /* 0x0240 */ TSoftObjectPtr<AActor> BoundsAlignActor;
    /* 0x0268 */ bool bSetBoundsButton;
    /* 0x0269 */ bool bSnapBoundsToLandscape;
    /* 0x026c */ float ExpandBounds;
    /* 0x0270 */ URuntimeVirtualTexture* VirtualTexture;
    /* 0x0278 */ FPerPlatformBool EnableInGamePerPlatform;
    /* 0x0279 */ bool bEnableForNaniteOnly;
    /* 0x027a */ bool bUseMinMaterialQuality;
    /* 0x027b */ ERuntimeVirtualTextureMaterialQuality MinInGameMaterialQuality;
    /* 0x027c */ bool bEnableScalability;
    /* 0x0280 */ uint32_t ScalabilityGroup;
    /* 0x0284 */ bool bHidePrimitives;
    /* 0x0288 */ UVirtualTextureBuilder* StreamingTexture;
    /* 0x0290 */ int32_t StreamLowMips;
    /* 0x0294 */ bool bBuildStreamingMipsButton;
    /* 0x0295 */ uint8_t LossyCompressionAmount;
    /* 0x0296 */ bool bUseStreamingMipsFixedColor;
    /* 0x0298 */ FLinearColor StreamingMipsFixedColor;
    /* 0x02a8 */ bool bUseStreamingMipsOnly;
    /* 0x02a9 */ ERuntimeVirtualTextureUseStreamingMipsInEditorMode UseStreamingMipsInEditorMode;
    /* 0x02aa */ bool bUseStreamingMipsInEditor;

    void Invalidate(const FBoxSphereBounds& WorldBounds, EVTInvalidatePriority InvalidatePriority);
    void RequestPreload(const FBoxSphereBounds& WorldBounds, int32_t Level);
};

// Size: 0x28
struct FRuntimeVirtualTextureParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ URuntimeVirtualTexture* ParameterValue;
    /* 0x0018 */ FGuid ExpressionGUID;
};

// Size: 0x160
class URuntimeVirtualTextureStreamingProxy : public UTexture2D {
};

// Size: 0x2b0
class ARuntimeVirtualTextureVolume : public AActor {
    /* 0x02a8 */ URuntimeVirtualTextureComponent* VirtualTextureComponent;
};

// Size: 0xd8
class USCS_Node : public UObject {
    /* 0x0028 */ UClass* ComponentClass;
    /* 0x0030 */ UActorComponent* ComponentTemplate;
    /* 0x0038 */ FBlueprintCookedComponentInstancingData CookedComponentInstancingData;
    /* 0x0080 */ FName AttachToName;
    /* 0x0088 */ FName ParentComponentOrVariableName;
    /* 0x0090 */ FName ParentComponentOwnerClassName;
    /* 0x0098 */ bool bIsParentComponentNative;
    /* 0x00a0 */ TArray<USCS_Node*> ChildNodes;
    /* 0x00b0 */ TArray<FBPVariableMetaDataEntry> MetaDataArray;
    /* 0x00c0 */ FGuid VariableGuid;
    /* 0x00d0 */ FName InternalVariableName;
};

// Size: 0x30
class USMInstanceElementAssetDataInterface : public UObject {
};

// Size: 0x30
class USMInstanceElementHierarchyInterface : public UObject {
};

// Size: 0x28
class USMInstanceElementIdMapTransactor : public UObject {
};

// Size: 0x30
class USMInstanceElementPrimitiveCustomDataInterface : public UObject {
};

// Size: 0x30
class USMInstanceElementSelectionInterface : public UObject {
};

// Size: 0x30
class USMInstanceElementWorldInterface : public UObject {
};

// Size: 0x28
class ISMInstanceManager : public UInterface {
};

// Size: 0x28
class ISMInstanceManagerProvider : public UInterface {
};

// Size: 0x28
class USMInstanceProxyEditingObject : public UObject {
};

// Size: 0x28
class USaveGame : public UObject {
};

// Size: 0x30
struct FScalarMaterialInput : public FMaterialInput {
    /* 0x0028 */ bool UseConstant;
    /* 0x002c */ float Constant;
};

// Size: 0x58
struct FScalarParameterAtlasInstanceData {
    /* 0x0000 */ bool bIsUsedAsAtlasPosition;
    /* 0x0008 */ TSoftObjectPtr<UCurveLinearColor> Curve;
    /* 0x0030 */ TSoftObjectPtr<UCurveLinearColorAtlas> Atlas;
};

// Size: 0x24
struct FScalarParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ float ParameterValue;
    /* 0x0014 */ FGuid ExpressionGUID;
};

// Size: 0x20
struct FScaleTrack {
    /* 0x0000 */ TArray<FVector3f> ScaleKeys;
    /* 0x0010 */ TArray<float> Times;
};

// Size: 0x28
class UScene : public UObject {
};

// Size: 0x2b8
class ASceneCapture : public AActor {
    /* 0x02a8 */ UStaticMeshComponent* MeshComp;
    /* 0x02b0 */ USceneComponent* SceneComponent;
};

// Size: 0x2c0
class ASceneCapture2D : public ASceneCapture {
    /* 0x02b8 */ USceneCaptureComponent2D* CaptureComponent2D;

    void OnInterpToggle(bool bEnable);
};

// Size: 0x330
class USceneCaptureComponent : public USceneComponent {
    /* 0x0240 */ ESceneCapturePrimitiveRenderMode PrimitiveRenderMode;
    /* 0x0241 */ uint8_t CaptureSource;
    /* 0x0242 */ bool bCaptureEveryFrame;
    /* 0x0242 */ bool bCaptureOnMovement;
    /* 0x0242 */ bool bCaptureGpuNextRender;
    /* 0x0242 */ bool bDumpGpuNextRender;
    /* 0x0242 */ bool bExcludeFromSceneTextureExtents;
    /* 0x0243 */ bool bAlwaysPersistRenderingState;
    /* 0x0248 */ TArray<TWeakObjectPtr<UPrimitiveComponent>> HiddenComponents;
    /* 0x0258 */ TArray<AActor*> HiddenActors;
    /* 0x0268 */ TArray<TWeakObjectPtr<UPrimitiveComponent>> ShowOnlyComponents;
    /* 0x0278 */ TArray<AActor*> ShowOnlyActors;
    /* 0x0288 */ float LODDistanceFactor;
    /* 0x028c */ float MaxViewDistanceOverride;
    /* 0x0290 */ int32_t CaptureSortPriority;
    /* 0x0294 */ bool bUseRayTracingIfEnabled;
    /* 0x0298 */ UMaterialParameterCollection* CollectionTransform;
    /* 0x02a0 */ FName CollectionTransformWorldToLocal;
    /* 0x02a8 */ FName CollectionTransformProjection;
    /* 0x02b0 */ FViewLightingChannels ViewLightingChannels;
    /* 0x02b8 */ TArray<FEngineShowFlagsSetting> ShowFlagSettings;
    /* 0x0308 */ FString ProfilingEventName;

    void ClearHiddenComponents();
    void ClearShowOnlyComponents();
    TArray<FEngineShowFlagsSetting> GetShowFlagSettings() const;
    void HideActorComponents(AActor* InActor, const bool bIncludeFromChildActors);
    void HideComponent(UPrimitiveComponent* InComponent);
    void RemoveShowOnlyActorComponents(AActor* InActor, const bool bIncludeFromChildActors);
    void RemoveShowOnlyComponent(UPrimitiveComponent* InComponent);
    void SetCaptureSortPriority(int32_t NewCaptureSortPriority);
    void SetShowFlagSettings(const TArray<FEngineShowFlagsSetting>& InShowFlagSettings);
    void ShowOnlyActorComponents(AActor* InActor, const bool bIncludeFromChildActors);
    void ShowOnlyComponent(UPrimitiveComponent* InComponent);
};

// Size: 0xbe0
class USceneCaptureComponent2D : public USceneCaptureComponent {
    /* 0x0328 */ uint8_t ProjectionType;
    /* 0x032c */ float FOVAngle;
    /* 0x0330 */ float FirstPersonFieldOfView;
    /* 0x0334 */ float FirstPersonScale;
    /* 0x0338 */ float OrthoWidth;
    /* 0x033c */ bool bAutoCalculateOrthoPlanes;
    /* 0x0340 */ float AutoPlaneShift;
    /* 0x0344 */ bool bUpdateOrthoPlanes;
    /* 0x0345 */ bool bUseCameraHeightAsViewTarget;
    /* 0x0348 */ float Overscan;
    /* 0x0350 */ UTextureRenderTarget2D* TextureTarget;
    /* 0x0358 */ uint8_t CompositeMode;
    /* 0x0360 */ FPostProcessSettings PostProcessSettings;
    /* 0x0ac0 */ float PostProcessBlendWeight;
    /* 0x0ac4 */ bool bOverride_CustomNearClippingPlane;
    /* 0x0ac8 */ float CustomNearClippingPlane;
    /* 0x0acc */ bool bUseCustomProjectionMatrix;
    /* 0x0ad0 */ FMatrix CustomProjectionMatrix;
    /* 0x0b50 */ bool bUseFauxOrthoViewPos;
    /* 0x0b51 */ bool bEnableOrthographicTiling;
    /* 0x0b54 */ int32_t NumXTiles;
    /* 0x0b58 */ int32_t NumYTiles;
    /* 0x0b5c */ bool bEnableClipPlane;
    /* 0x0b60 */ FVector ClipPlaneBase;
    /* 0x0b78 */ FVector ClipPlaneNormal;
    /* 0x0b90 */ bool bRenderInMainRenderer;
    /* 0x0b91 */ ESceneCaptureUnlitViewmode UnlitViewmode;
    /* 0x0b94 */ bool bCameraCutThisFrame;
    /* 0x0b94 */ bool bEnableFirstPersonFieldOfView;
    /* 0x0b94 */ bool bEnableFirstPersonScale;
    /* 0x0b94 */ bool bConsiderUnrenderedOpaquePixelAsFullyTranslucent;
    /* 0x0b94 */ bool bMainViewFamily;
    /* 0x0b94 */ bool bMainViewResolution;
    /* 0x0b94 */ bool bMainViewCamera;
    /* 0x0b94 */ bool bInheritMainViewCameraPostProcessSettings;
    /* 0x0b95 */ bool bIgnoreScreenPercentage;
    /* 0x0b98 */ FIntPoint MainViewResolutionDivisor;
    /* 0x0ba0 */ FName UserSceneTextureBaseColor;
    /* 0x0ba8 */ FName UserSceneTextureNormal;
    /* 0x0bb0 */ FName UserSceneTextureSceneColor;

    void AddOrUpdateBlendable(TScriptInterface<IBlendableInterface> InBlendableObject, float InWeight);
    void CaptureScene();
    void RemoveBlendable(TScriptInterface<IBlendableInterface> InBlendableObject);
};

// Size: 0xab0
class USceneCaptureComponentCube : public USceneCaptureComponent {
    /* 0x0328 */ UTextureRenderTargetCube* TextureTarget;
    /* 0x0330 */ bool bCaptureRotation;
    /* 0x0340 */ FPostProcessSettings PostProcessSettings;
    /* 0x0aa0 */ float PostProcessBlendWeight;

    void CaptureScene();
};

// Size: 0x2c0
class ASceneCaptureCube : public ASceneCapture {
    /* 0x02b8 */ USceneCaptureComponentCube* CaptureComponentCube;

    void OnInterpToggle(bool bEnable);
};

// Size: 0x240
class USceneComponent : public UActorComponent {
    /* 0x00c0 */ TWeakObjectPtr<APhysicsVolume> PhysicsVolume;
    /* 0x00c8 */ USceneComponent* AttachParent;
    /* 0x00d0 */ FName AttachSocketName;
    /* 0x00e0 */ TArray<USceneComponent*> AttachChildren;
    /* 0x00f0 */ TArray<USceneComponent*> ClientAttachedChildren;
    /* 0x0140 */ FVector RelativeLocation;
    /* 0x0158 */ FRotator RelativeRotation;
    /* 0x0170 */ FVector RelativeScale3D;
    /* 0x0188 */ FVector ComponentVelocity;
    /* 0x01a0 */ bool bComponentToWorldUpdated;
    /* 0x01a0 */ bool bAbsoluteLocation;
    /* 0x01a0 */ bool bAbsoluteRotation;
    /* 0x01a0 */ bool bAbsoluteScale;
    /* 0x01a0 */ bool bVisible;
    /* 0x01a0 */ bool bShouldBeAttached;
    /* 0x01a0 */ bool bShouldSnapLocationWhenAttached;
    /* 0x01a1 */ bool bShouldSnapRotationWhenAttached;
    /* 0x01a1 */ bool bShouldSnapScaleWhenAttached;
    /* 0x01a1 */ bool bShouldUpdatePhysicsVolume;
    /* 0x01a1 */ bool bHiddenInGame;
    /* 0x01a1 */ bool bBoundsChangeTriggersStreamingDataRebuild;
    /* 0x01a1 */ bool bUseAttachParentBound;
    /* 0x01a1 */ bool bComputeFastLocalBounds;
    /* 0x01a1 */ bool bComputeBoundsOnceForGame;
    /* 0x01a2 */ bool bComputedBoundsOnceForGame;
    /* 0x01a2 */ bool bIsNotRenderAttachmentRoot;
    /* 0x01a3 */ uint8_t Mobility;
    /* 0x01a4 */ uint8_t DetailMode;
    /* 0x01a5 */ FMulticastSparseDelegate PhysicsVolumeChangedDelegate;

    void DetachFromParent(bool bMaintainWorldPosition, bool bCallModify);
    bool DoesSocketExist(FName InSocketName) const;
    TArray<FName> GetAllSocketNames() const;
    USceneComponent* GetAttachParent() const;
    FName GetAttachSocketName() const;
    USceneComponent* GetChildComponent(int32_t ChildIndex) const;
    void GetChildrenComponents(bool bIncludeAllDescendants, TArray<USceneComponent*>& Children) const;
    FVector GetComponentVelocity() const;
    FVector GetForwardVector() const;
    int32_t GetNumChildrenComponents() const;
    void GetParentComponents(TArray<USceneComponent*>& Parents) const;
    APhysicsVolume* GetPhysicsVolume() const;
    FTransform GetRelativeTransform() const;
    FVector GetRightVector() const;
    bool GetShouldUpdatePhysicsVolume() const;
    FVector GetSocketLocation(FName InSocketName) const;
    FQuat GetSocketQuaternion(FName InSocketName) const;
    FRotator GetSocketRotation(FName InSocketName) const;
    FTransform GetSocketTransform(FName InSocketName, uint8_t TransformSpace) const;
    FVector GetUpVector() const;
    bool IsAnySimulatingPhysics() const;
    static bool IsGroupedComponentMovementEnabled();
    bool IsSimulatingPhysics(FName BoneName) const;
    bool IsVisible() const;
    void K2_AddLocalOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddLocalRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddLocalTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddRelativeLocation(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddRelativeRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddWorldOffset(FVector DeltaLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddWorldRotation(FRotator DeltaRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddWorldTransform(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_AddWorldTransformKeepScale(const FTransform& DeltaTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    bool K2_AttachTo(USceneComponent* InParent, FName InSocketName, uint8_t AttachType, bool bWeldSimulatedBodies);
    bool K2_AttachToComponent(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies);
    void K2_DetachFromComponent(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule, bool bCallModify);
    FVector K2_GetComponentLocation() const;
    FRotator K2_GetComponentRotation() const;
    FVector K2_GetComponentScale() const;
    FTransform K2_GetComponentToWorld() const;
    void K2_SetRelativeLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetRelativeLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetRelativeRotation(FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetRelativeTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetWorldLocation(FVector NewLocation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetWorldLocationAndRotation(FVector NewLocation, FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetWorldRotation(FRotator NewRotation, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void K2_SetWorldTransform(const FTransform& NewTransform, bool bSweep, FHitResult& SweepHitResult, bool bTeleport);
    void OnRep_AttachChildren();
    void OnRep_AttachParent();
    void OnRep_AttachSocketName();
    void OnRep_Transform();
    void OnRep_Visibility(bool OldValue);
    void ResetRelativeTransform();
    void SetAbsolute(bool bNewAbsoluteLocation, bool bNewAbsoluteRotation, bool bNewAbsoluteScale);
    void SetHiddenInGame(bool NewHidden, bool bPropagateToChildren);
    void SetMobility(uint8_t NewMobility);
    void SetRelativeScale3D(FVector NewScale3D);
    void SetShouldUpdatePhysicsVolume(bool bInShouldUpdatePhysicsVolume);
    void SetVisibility(bool bNewVisibility, bool bPropagateToChildren);
    void SetWorldScale3D(FVector NewScale);
    void ToggleVisibility(bool bPropagateToChildren);
};

// Size: 0xb8
struct FSceneComponentInstanceData : public FActorComponentInstanceData {
    /* 0x0068 */ TMap<USceneComponent*, FTransform> AttachedInstanceComponents;
};

// Size: 0x40
struct FSceneViewExtensionIsActiveFunctor {
};

// Size: 0x38
struct FScreenMessageString {
    /* 0x0000 */ uint64_t Key;
    /* 0x0008 */ FString ScreenMessage;
    /* 0x0018 */ FColor DisplayColor;
    /* 0x001c */ float TimeToDisplay;
    /* 0x0020 */ float CurrentTimeDisplayed;
    /* 0x0028 */ FVector2D TextScale;
};

// Size: 0x38
class UScriptViewportClient : public UObject {
};

// Size: 0x4
struct FSectionReference {
    /* 0x0000 */ int32_t SectionIndex;
};

// Size: 0x20
struct FSelectedFragmentProperties {
    /* 0x0000 */ FName Tag;
    /* 0x0008 */ FString Fragment;
    /* 0x0018 */ bool bEnabled;
};

// Size: 0x18
struct FSequenceLengthChangedPayload : public FEmptyPayload {
    /* 0x0000 */ float PreviousLength;
    /* 0x0004 */ float T0;
    /* 0x0008 */ float T1;
    /* 0x000c */ FFrameNumber PreviousNumberOfFrames;
    /* 0x0010 */ FFrameNumber Frame0;
    /* 0x0014 */ FFrameNumber Frame1;
};

// Size: 0x370
class AServerStatReplicator : public AInfo {
    /* 0x02a8 */ bool bUpdateStatNet;
    /* 0x02a9 */ bool bOverwriteClientStats;
    /* 0x02ac */ uint32_t Channels;
    /* 0x02b0 */ uint32_t InRate;
    /* 0x02b4 */ uint32_t OutRate;
    /* 0x02bc */ uint32_t MaxPacketOverhead;
    /* 0x02c0 */ uint32_t InRateClientMax;
    /* 0x02c4 */ uint32_t InRateClientMin;
    /* 0x02c8 */ uint32_t InRateClientAvg;
    /* 0x02cc */ uint32_t InPacketsClientMax;
    /* 0x02d0 */ uint32_t InPacketsClientMin;
    /* 0x02d4 */ uint32_t InPacketsClientAvg;
    /* 0x02d8 */ uint32_t OutRateClientMax;
    /* 0x02dc */ uint32_t OutRateClientMin;
    /* 0x02e0 */ uint32_t OutRateClientAvg;
    /* 0x02e4 */ uint32_t OutPacketsClientMax;
    /* 0x02e8 */ uint32_t OutPacketsClientMin;
    /* 0x02ec */ uint32_t OutPacketsClientAvg;
    /* 0x02f0 */ uint32_t NetNumClients;
    /* 0x02f4 */ uint32_t InPackets;
    /* 0x02f8 */ uint32_t OutPackets;
    /* 0x02fc */ uint32_t InBunches;
    /* 0x0300 */ uint32_t OutBunches;
    /* 0x0304 */ uint32_t OutLoss;
    /* 0x0308 */ uint32_t InLoss;
    /* 0x030c */ uint32_t VoiceBytesSent;
    /* 0x0310 */ uint32_t VoiceBytesRecv;
    /* 0x0314 */ uint32_t VoicePacketsSent;
    /* 0x0318 */ uint32_t VoicePacketsRecv;
    /* 0x031c */ uint32_t PercentInVoice;
    /* 0x0320 */ uint32_t PercentOutVoice;
    /* 0x0324 */ uint32_t NumActorChannels;
    /* 0x0328 */ uint32_t NumConsideredActors;
    /* 0x032c */ uint32_t PrioritizedActors;
    /* 0x0330 */ uint32_t NumRelevantActors;
    /* 0x0334 */ uint32_t NumRelevantDeletedActors;
    /* 0x0338 */ uint32_t NumReplicatedActorAttempts;
    /* 0x033c */ uint32_t NumReplicatedActors;
    /* 0x0340 */ uint32_t NumActors;
    /* 0x0344 */ uint32_t NumNetActors;
    /* 0x0348 */ uint32_t NumDormantActors;
    /* 0x034c */ uint32_t NumInitiallyDormantActors;
    /* 0x0350 */ uint32_t NumNetGUIDsAckd;
    /* 0x0354 */ uint32_t NumNetGUIDsPending;
    /* 0x0358 */ uint32_t NumNetGUIDsUnAckd;
    /* 0x035c */ uint32_t ObjPathBytes;
    /* 0x0360 */ uint32_t NetGUIDOutRate;
    /* 0x0364 */ uint32_t NetGUIDInRate;
    /* 0x0368 */ uint32_t NetSaturated;
};

// Size: 0x2f8
class AServerStreamingLevelsVisibility : public AActor {
};

// Size: 0xe8
struct FShaderCompilerCounters {
    /* 0x0000 */ double AccumulatedLocalWorkerIdleTime;
    /* 0x0008 */ double TimesLocalWorkersWereIdle;
    /* 0x0010 */ int64_t JobsAssigned;
    /* 0x0018 */ int64_t JobsCompleted;
    /* 0x0020 */ double AccumulatedPendingTime;
    /* 0x0028 */ double MaxPendingTime;
    /* 0x0030 */ double AccumulatedJobExecutionTime;
    /* 0x0038 */ double MaxJobExecutionTime;
    /* 0x0040 */ double AccumulatedJobLifeTime;
    /* 0x0048 */ double MaxJobLifeTime;
    /* 0x0050 */ double AccumulatedTaskSubmitJobs;
    /* 0x0058 */ double AccumulatedTaskSubmitJobsStall;
    /* 0x0060 */ int64_t LocalJobBatchesSeen;
    /* 0x0068 */ int64_t TotalJobsReportedInLocalJobBatches;
    /* 0x0070 */ int64_t DistributedJobBatchesSeen;
    /* 0x0078 */ int64_t TotalJobsReportedInDistributedJobBatches;
    /* 0x0080 */ int32_t MinShaderCodeSize;
    /* 0x0084 */ int32_t MaxShaderCodeSize;
    /* 0x0088 */ uint64_t AccumulatedShaderCodeSize;
    /* 0x0090 */ uint64_t NumAccumulatedShaderCodes;
    /* 0x0098 */ uint32_t ShaderMapDDCMisses;
    /* 0x009c */ uint32_t ShaderMapDDCHits;
    /* 0x00a0 */ uint64_t TotalCacheSearchAttempts;
    /* 0x00a8 */ uint64_t TotalCacheHits;
    /* 0x00b0 */ uint32_t TotalCacheDuplicates;
    /* 0x00b4 */ uint32_t TotalCacheDDCQueries;
    /* 0x00b8 */ uint32_t TotalCacheDDCHits;
    /* 0x00c0 */ uint64_t UniqueCacheInputHashes;
    /* 0x00c8 */ uint64_t UniqueCacheOutputs;
    /* 0x00d0 */ uint64_t CacheMemUsed;
    /* 0x00d8 */ uint64_t CacheMemBudget;
    /* 0x00e0 */ uint32_t MaxRemoteAgents;
    /* 0x00e4 */ uint32_t MaxActiveAgentCores;
};

// Size: 0x28
struct FShaderCompilerMaterialCounters {
    /* 0x0004 */ int32_t MaterialTranslateCalls;
    /* 0x0008 */ double MaterialTranslateTotalTimeSec;
    /* 0x0010 */ double MaterialTranslateTranslationOnlyTimeSec;
    /* 0x0018 */ double MaterialTranslateSerializationOnlyTimeSec;
    /* 0x0020 */ int32_t MaterialCacheHits;
};

// Size: 0x20
struct FShaderCompilerSinglePermutationStat {
    /* 0x0000 */ uint64_t PermutationHash;
    /* 0x0008 */ uint32_t PermutationString;
    /* 0x000c */ uint32_t Compiled;
    /* 0x0010 */ uint32_t Cooked;
    /* 0x0014 */ uint32_t CompiledDouble;
    /* 0x0018 */ uint32_t CookedDouble;
};

// Size: 0x28
struct FShaderStats {
    /* 0x0000 */ TArray<FShaderCompilerSinglePermutationStat> PermutationCompilations;
    /* 0x0010 */ uint32_t Compiled;
    /* 0x0014 */ uint32_t Cooked;
    /* 0x0018 */ uint32_t CompiledDouble;
    /* 0x001c */ uint32_t CookedDouble;
    /* 0x0020 */ float CompileTime;
};

// Size: 0x18
struct FShaderTimings {
    /* 0x0000 */ float MinCompileTime;
    /* 0x0004 */ float MaxCompileTime;
    /* 0x0008 */ float TotalCompileTime;
    /* 0x000c */ float TotalPreprocessTime;
    /* 0x0010 */ int32_t NumCompiled;
    /* 0x0014 */ float AverageCompileTime;
};

// Size: 0x28
struct FShadingModelMaterialInput : public FMaterialInput {
};

// Size: 0x168
class UShadowMapTexture2D : public UTexture2D {
    /* 0x0160 */ uint8_t ShadowmapFlags;
};

// Size: 0x540
class UShapeComponent : public UPrimitiveComponent {
    /* 0x0520 */ UBodySetup* ShapeBodySetup;
    /* 0x0528 */ FColor ShapeColor;
    /* 0x052c */ bool bDrawOnlyIfSelected;
    /* 0x052c */ bool bShouldCollideWhenPlacing;
    /* 0x052c */ bool bDynamicObstacle;
    /* 0x052c */ bool bUseSystemDefaultObstacleAreaClass;
    /* 0x0530 */ UClass* AreaClassOverride;
    /* 0x0538 */ float LineThickness;

    void SetLineThickness(float Thickness);
};

// Size: 0xb0
class USimpleConstructionScript : public UObject {
    /* 0x0028 */ TArray<USCS_Node*> RootNodes;
    /* 0x0038 */ TArray<USCS_Node*> AllNodes;
    /* 0x0048 */ USCS_Node* DefaultSceneRootNode;
};

// Size: 0x88
struct FSimpleCurve : public FRealCurve {
    /* 0x0070 */ uint8_t InterpMode;
    /* 0x0078 */ TArray<FSimpleCurveKey> Keys;
};

// Size: 0x8
struct FSimpleCurveKey {
    /* 0x0000 */ float Time;
    /* 0x0004 */ float Value;
};

// Size: 0x20
struct FSimpleMemberReference {
    /* 0x0000 */ UObject* MemberParent;
    /* 0x0008 */ FName MemberName;
    /* 0x0010 */ FGuid MemberGuid;
};

// Size: 0x1e30
class USimulatedClientNetConnection : public UNetConnection {
};

// Size: 0xd0
struct FSimulatedRootMotionReplicatedMove {
    /* 0x0000 */ float Time;
    /* 0x0008 */ FRepRootMotionMontage RootMotion;
};

// Size: 0x18
struct FSingleAnimationPlayData {
    /* 0x0000 */ UAnimationAsset* AnimToPlay;
    /* 0x0008 */ bool bSavedLooping;
    /* 0x0008 */ bool bSavedPlaying;
    /* 0x000c */ float SavedPosition;
    /* 0x0010 */ float SavedPlayRate;
};

// Size: 0x28
struct FSkelMeshComponentLODInfo {
    /* 0x0000 */ TArray<bool> HiddenMaterials;
};

// Size: 0x10
struct FSkelMeshMergeMeshUVTransforms {
    /* 0x0000 */ TArray<FTransform> UVTransforms;
};

// Size: 0x10
struct FSkelMeshMergeSectionMapping {
    /* 0x0000 */ TArray<int32_t> SectionIDs;
};

// Size: 0x10
struct FSkelMeshMergeUVTransformMapping {
    /* 0x0000 */ TArray<FSkelMeshMergeMeshUVTransforms> UVTransformsPerMesh;
};

// Size: 0x3c
struct FSkelMeshSkinWeightInfo {
    /* 0x0000 */ int32_t Bones[12];
    /* 0x0030 */ uint8_t Weights[12];
};

// Size: 0x340
class USkeletalBodySetup : public UBodySetup {
    /* 0x0328 */ bool bSkipScaleFromAnimation;
    /* 0x0330 */ TArray<FPhysicalAnimationProfile> PhysicalAnimationData;
};

// Size: 0x30
struct FSkeletalMaterial {
    /* 0x0000 */ UMaterialInterface* MaterialInterface;
    /* 0x0008 */ FName MaterialSlotName;
    /* 0x0010 */ FMeshUVChannelInfo UVChannelData;
    /* 0x0028 */ UMaterialInterface* OverlayMaterialInterface;
};

// Size: 0x568
class USkeletalMesh : public USkinnedAsset {
    /* 0x00f8 */ USkeleton* Skeleton;
    /* 0x0100 */ FBoxSphereBounds ImportedBounds;
    /* 0x0138 */ FBoxSphereBounds ExtendedBounds;
    /* 0x0170 */ FVector PositiveBoundsExtension;
    /* 0x0188 */ FVector NegativeBoundsExtension;
    /* 0x01a0 */ TArray<FSkeletalMaterial> Materials;
    /* 0x01b0 */ FMeshNaniteSettings NaniteSettings;
    /* 0x0220 */ TArray<FSkeletalMeshLODInfo> LODInfo;
    /* 0x0280 */ FPerQualityLevelInt MinQualityLevelLOD;
    /* 0x02e8 */ FPerPlatformInt MinLOD;
    /* 0x02ec */ FPerPlatformBool DisableBelowMinLodStripping;
    /* 0x02ed */ bool bUseFullPrecisionUVs;
    /* 0x02ed */ bool bUseHighPrecisionTangentBasis;
    /* 0x02ed */ bool bHasVertexColors;
    /* 0x02ed */ bool bEnablePerPolyCollision;
    /* 0x02f0 */ UBodySetup* BodySetup;
    /* 0x02f8 */ UPhysicsAsset* PhysicsAsset;
    /* 0x0300 */ UPhysicsAsset* ShadowPhysicsAsset;
    /* 0x0308 */ TArray<UNodeMappingContainer*> NodeMappingData;
    /* 0x0318 */ bool bSupportRayTracing;
    /* 0x031c */ int32_t RayTracingMinLOD;
    /* 0x0320 */ EClothLODBiasMode ClothLODBiasMode;
    /* 0x0328 */ TArray<UMorphTarget*> MorphTargets;
    /* 0x04b8 */ UClass* PostProcessAnimBlueprint;
    /* 0x04c0 */ int32_t PostProcessAnimBPLODThreshold;
    /* 0x04c8 */ TArray<UClothingAssetBase*> MeshClothingAssets;
    /* 0x04d8 */ FSkeletalMeshSamplingInfo SamplingInfo;
    /* 0x0508 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0518 */ TArray<USkeletalMeshSocket*> Sockets;
    /* 0x0538 */ TArray<FSkinWeightProfileInfo> SkinWeightProfiles;
    /* 0x0548 */ UMeshDeformer* DefaultMeshDeformer;
    /* 0x0550 */ UMeshDeformerCollection* TargetMeshDeformers;
    /* 0x0558 */ UMaterialInterface* OverlayMaterial;
    /* 0x0560 */ float OverlayMaterialMaxDrawDistance;
    /* 0x0564 */ uint8_t ForwardAxis;

    USkeletalMeshSocket* FindSocketAndIndex(FName InSocketName, int32_t& OutIndex) const;
    FBoxSphereBounds GetBounds() const;
    TSoftObjectPtr<UObject> GetDefaultAnimatingRig() const;
    UMeshDeformer* GetDefaultMeshDeformer() const;
    uint8_t GetForwardAxis() const;
    bool GetHasVertexColors() const;
    FBoxSphereBounds GetImportedBounds() const;
    USkeletalMeshLODSettings* GetLODSettings() const;
    TArray<FSkeletalMaterial> GetMaterials() const;
    TArray<UClothingAssetBase*> GetMeshClothingAssets() const;
    void GetMinLODForQualityLevels(TMap<EPerQualityLevels, int32_t>& QualityLevelMinimumLODs, int32_t& Default) const;
    TArray<UMorphTarget*> GetMorphTargetsPtrConv() const;
    UNodeMappingContainer* GetNodeMappingContainer(UBlueprint* SourceAsset) const;
    TArray<UNodeMappingContainer*> GetNodeMappingData() const;
    UMaterialInterface* GetOverlayMaterial() const;
    float GetOverlayMaterialMaxDrawDistance() const;
    UPhysicsAsset* GetPhysicsAsset() const;
    UPhysicsAsset* GetShadowPhysicsAsset() const;
    USkeleton* GetSkeleton() const;
    USkeletalMeshSocket* GetSocketByIndex(int32_t Index) const;
    UMeshDeformerCollection* GetTargetMeshDeformers() const;
    bool IsSectionUsingCloth(int32_t InSectionIndex, bool bCheckCorrespondingSections) const;
    TArray<FString> K2_GetAllMorphTargetNames() const;
    int32_t NumSockets() const;
    void SetDefaultAnimatingRig(TSoftObjectPtr<UObject> InAnimatingRig);
    void SetLODSettings(USkeletalMeshLODSettings* InLODSettings);
    void SetMaterials(const TArray<FSkeletalMaterial>& InMaterials);
    void SetMeshClothingAssets(const TArray<UClothingAssetBase*>& InMeshClothingAssets);
    void SetMinLODForQualityLevels(const TMap<EPerQualityLevels, int32_t>& QualityLevelMinimumLODs, int32_t Default);
    void SetMorphTargets(const TArray<UMorphTarget*>& InMorphTargets);
    void SetOverlayMaterial(UMaterialInterface* NewOverlayMaterial);
    void SetOverlayMaterialMaxDrawDistance(float InMaxDrawDistance);
    void SetSkeleton(USkeleton* InSkeleton);
};

// Size: 0x328
class ASkeletalMeshActor : public AActor {
    /* 0x02a8 */ bool bShouldDoAnimNotifies;
    /* 0x02b0 */ USkeletalMeshComponent* SkeletalMeshComponent;
    /* 0x02b8 */ USkeletalMesh* ReplicatedMesh;
    /* 0x02c0 */ UPhysicsAsset* ReplicatedPhysAsset;
    /* 0x02c8 */ UMaterialInterface* ReplicatedMaterial0;
    /* 0x02d0 */ UMaterialInterface* ReplicatedMaterial1;

    void OnRep_ReplicatedMaterial0();
    void OnRep_ReplicatedMaterial1();
    void OnRep_ReplicatedMesh();
    void OnRep_ReplicatedPhysAsset();
};

// Size: 0x18
struct FSkeletalMeshBuildSettings {
    /* 0x0000 */ bool bRecomputeNormals;
    /* 0x0000 */ bool bRecomputeTangents;
    /* 0x0000 */ bool bUseMikkTSpace;
    /* 0x0000 */ bool bComputeWeightedNormals;
    /* 0x0000 */ bool bRemoveDegenerates;
    /* 0x0000 */ bool bUseHighPrecisionTangentBasis;
    /* 0x0000 */ bool bUseHighPrecisionSkinWeights;
    /* 0x0000 */ bool bUseFullPrecisionUVs;
    /* 0x0001 */ bool bUseBackwardsCompatibleF16TruncUVs;
    /* 0x0004 */ float ThresholdPosition;
    /* 0x0008 */ float ThresholdTangentNormal;
    /* 0x000c */ float ThresholdUV;
    /* 0x0010 */ float MorphThresholdPosition;
    /* 0x0014 */ int32_t BoneInfluenceLimit;
};

// Size: 0x58
struct FSkeletalMeshClothBuildParams {
    /* 0x0000 */ TWeakObjectPtr<UClothingAssetBase> TargetAsset;
    /* 0x0008 */ int32_t TargetLod;
    /* 0x000c */ bool bRemapParameters;
    /* 0x0010 */ FString AssetName;
    /* 0x0020 */ int32_t LODIndex;
    /* 0x0024 */ int32_t SourceSection;
    /* 0x0028 */ bool bRemoveFromMesh;
    /* 0x0030 */ TSoftObjectPtr<UPhysicsAsset> PhysicsAsset;
};

// Size: 0xfe0
class USkeletalMeshComponent : public USkinnedMeshComponent {
    /* 0x08f0 */ UClass* AnimClass;
    /* 0x08f8 */ UAnimInstance* AnimScriptInstance;
    /* 0x0900 */ UClass* OverridePostProcessAnimBP;
    /* 0x0908 */ UAnimInstance* PostProcessAnimInstance;
    /* 0x0910 */ FSingleAnimationPlayData AnimationData;
    /* 0x0938 */ FVector RootBoneTranslation;
    /* 0x0950 */ FVector LineCheckBoundsScale;
    /* 0x0988 */ TArray<UAnimInstance*> LinkedInstances;
    /* 0x09a8 */ TArray<FTransform> CachedBoneSpaceTransforms;
    /* 0x09b8 */ TArray<FTransform> CachedComponentSpaceTransforms;
    /* 0x0a68 */ float GlobalAnimRateScale;
    /* 0x0a6c */ uint8_t KinematicBonesUpdateType;
    /* 0x0a6d */ uint8_t PhysicsTransformUpdateMode;
    /* 0x0a6e */ EClothingTeleportMode ClothTeleportMode;
    /* 0x0a6f */ uint8_t AnimationMode;
    /* 0x0a71 */ bool bDisablePostProcessBlueprint;
    /* 0x0a71 */ bool bUpdateOverlapsOnAnimationFinalize;
    /* 0x0a71 */ bool bHasValidBodies;
    /* 0x0a71 */ bool bBlendPhysics;
    /* 0x0a71 */ bool bEnablePhysicsOnDedicatedServer;
    /* 0x0a71 */ bool bUpdateMeshWhenKinematic;
    /* 0x0a72 */ bool bUpdateJointsFromAnimation;
    /* 0x0a72 */ bool bAllowClothActors;
    /* 0x0a72 */ bool bDisableClothSimulation;
    /* 0x0a78 */ bool bDisableRigidBodyAnimNode;
    /* 0x0a78 */ bool bAllowAnimCurveEvaluation;
    /* 0x0a78 */ bool bCollideWithEnvironment;
    /* 0x0a78 */ bool bCollideWithAttachedChildren;
    /* 0x0a78 */ bool bForceCollisionUpdate;
    /* 0x0a7c */ float ClothVelocityScale;
    /* 0x0a80 */ bool bResetAfterTeleport;
    /* 0x0a80 */ bool bDeferKinematicBoneUpdate;
    /* 0x0a80 */ bool bNoSkeletonUpdate;
    /* 0x0a80 */ bool bPauseAnims;
    /* 0x0a80 */ bool bEnableAnimation;
    /* 0x0a80 */ bool bUseRefPoseOnInitAnim;
    /* 0x0a80 */ bool bEnablePerPolyCollision;
    /* 0x0a81 */ bool bForceRefpose;
    /* 0x0a81 */ bool bOnlyAllowAutonomousTickPose;
    /* 0x0a81 */ bool bIsAutonomousTickPose;
    /* 0x0a81 */ bool bOldForceRefPose;
    /* 0x0a81 */ bool bShowPrePhysBones;
    /* 0x0a81 */ bool bRequiredBonesUpToDate;
    /* 0x0a81 */ bool bAnimTreeInitialised;
    /* 0x0a81 */ bool bEnableLineCheckWithBounds;
    /* 0x0a82 */ bool bPropagateCurvesToFollowers;
    /* 0x0a82 */ bool bSkipKinematicUpdateWhenInterpolating;
    /* 0x0a82 */ bool bSkipBoundsUpdateWhenInterpolating;
    /* 0x0a82 */ bool bNeedsQueuedAnimEventsDispatched;
    /* 0x0a84 */ uint16_t CachedAnimCurveUidVersion;
    /* 0x0a88 */ float ClothBlendWeight;
    /* 0x0a8c */ bool bWaitForParallelClothTask;
    /* 0x0a8d */ bool bFilteredAnimCurvesIsAllowList;
    /* 0x0a8e */ uint16_t CachedMeshCurveMetaDataVersion;
    /* 0x0a90 */ TArray<FName> FilteredAnimCurves;
    /* 0x0aa0 */ UBodySetup* BodySetup;
    /* 0x0aac */ float ClothMaxDistanceScale;
    /* 0x0ab0 */ float ClothGeometryScale;
    /* 0x0ab4 */ int32_t PostProcessAnimBPLODThreshold;
    /* 0x0ab8 */ FMulticastInlineDelegate OnConstraintBroken;
    /* 0x0ac8 */ FMulticastInlineDelegate OnPlasticDeformation;
    /* 0x0ad8 */ UClass* ClothingSimulationFactory;
    /* 0x0bd0 */ float TeleportDistanceThreshold;
    /* 0x0bd4 */ float TeleportRotationThreshold;
    /* 0x0c80 */ UClothingSimulationInteractor* ClothingInteractor;
    /* 0x0cf0 */ TMap<FName, float> MorphTargetCurves;
    /* 0x0d40 */ FMulticastInlineDelegate OnAnimInitialized;
    /* 0x0fd0 */ uint32_t LastPoseTickFrame;

    void AccumulateAllBodiesBelowPhysicsBlendWeight(const FName& InBoneName, float AddPhysicsBlendWeight, bool bSkipCustomPhysicsType);
    void AddClothCollisionSource(USkeletalMeshComponent* InSourceComponent, UPhysicsAsset* InSourcePhysicsAsset);
    void AddForceToAllBodiesBelow(FVector Force, FName BoneName, bool bAccelChange, bool bIncludeSelf);
    void AddImpulseToAllBodiesBelow(FVector Impulse, FName BoneName, bool bVelChange, bool bIncludeSelf);
    void AllowAnimCurveEvaluation(FName NameOfCurve, bool bAllow);
    void BindClothToLeaderPoseComponent();
    void BreakConstraint(FVector Impulse, FVector HitLocation, FName InBoneName);
    void ClearMorphTargets();
    FName FindConstraintBoneName(int32_t ConstraintIndex);
    void ForceClothNextUpdateTeleport();
    void ForceClothNextUpdateTeleportAndReset();
    bool GetAllowClothActors() const;
    bool GetAllowRigidBodyAnimNode() const;
    bool GetAllowedAnimCurveEvaluate() const;
    UClass* GetAnimClass();
    UAnimInstance* GetAnimInstance() const;
    uint8_t GetAnimationMode() const;
    FVector GetBoneLinearVelocity(const FName& InBoneName);
    float GetBoneMass(FName BoneName, bool bScaleMass) const;
    float GetClothMaxDistanceScale() const;
    UClothingSimulationInteractor* GetClothingSimulationInteractor() const;
    FConstraintInstanceAccessor GetConstraintByName(FName ConstraintName, bool bIncludesTerminated);
    void GetConstraints(bool bIncludesTerminated, TArray<FConstraintInstanceAccessor>& OutConstraints);
    void GetConstraintsFromBody(FName BodyName, bool bParentConstraints, bool bChildConstraints, bool bIncludesTerminated, TArray<FConstraintInstanceAccessor>& OutConstraints);
    void GetCurrentJointAngles(FName InBoneName, float& Swing1Angle, float& TwistAngle, float& Swing2Angle);
    bool GetCurveValue(FName CurveName, float DefaultValue, float& Value) const;
    bool GetDisableAnimCurves() const;
    bool GetDisablePostProcessBlueprint() const;
    bool GetFloatAttribute(const FName& BoneName, const FName& AttributeName, float DefaultValue, float& OutValue, ECustomBoneAttributeLookup LookupType);
    bool GetFloatAttribute_Ref(const FName& BoneName, const FName& AttributeName, float& OutValue, ECustomBoneAttributeLookup LookupType);
    bool GetIntegerAttribute(const FName& BoneName, const FName& AttributeName, int32_t DefaultValue, int32_t& OutValue, ECustomBoneAttributeLookup LookupType);
    bool GetIntegerAttribute_Ref(const FName& BoneName, const FName& AttributeName, int32_t& OutValue, ECustomBoneAttributeLookup LookupType);
    UAnimInstance* GetLinkedAnimGraphInstanceByTag(FName InTag) const;
    void GetLinkedAnimGraphInstancesByTag(FName InTag, TArray<UAnimInstance*>& OutLinkedInstances) const;
    UAnimInstance* GetLinkedAnimLayerInstanceByClass(UClass* InClass) const;
    UAnimInstance* GetLinkedAnimLayerInstanceByGroup(FName InGroup) const;
    float GetMorphTarget(FName MorphTargetName) const;
    float GetPlayRate() const;
    float GetPosition() const;
    UAnimInstance* GetPostProcessInstance() const;
    FVector GetSkeletalCenterOfMass() const;
    USkeletalMesh* GetSkeletalMeshAsset() const;
    bool GetStringAttribute(const FName& BoneName, const FName& AttributeName, FString DefaultValue, FString& OutValue, ECustomBoneAttributeLookup LookupType);
    bool GetStringAttribute_Ref(const FName& BoneName, const FName& AttributeName, FString& OutValue, ECustomBoneAttributeLookup LookupType);
    float GetTeleportDistanceThreshold() const;
    float GetTeleportRotationThreshold() const;
    bool GetTransformAttribute(const FName& BoneName, const FName& AttributeName, FTransform DefaultValue, FTransform& OutValue, ECustomBoneAttributeLookup LookupType);
    bool GetTransformAttribute_Ref(const FName& BoneName, const FName& AttributeName, FTransform& OutValue, ECustomBoneAttributeLookup LookupType);
    bool HasValidAnimationInstance() const;
    bool IsBodyGravityEnabled(FName BoneName);
    bool IsClothingSimulationSuspended() const;
    bool IsPlaying() const;
    bool K2_GetClosestPointOnPhysicsAsset(const FVector& WorldPosition, FVector& ClosestWorldPosition, FVector& Normal, FName& BoneName, float& Distance) const;
    void LinkAnimClassLayers(UClass* InClass);
    void LinkAnimGraphByTag(FName InTag, UClass* InClass);
    void OverrideAnimationData(UAnimationAsset* InAnimToPlay, bool bIsLooping, bool bIsPlaying, float position, float PlayRate);
    void Play(bool bLooping);
    void PlayAnimation(UAnimationAsset* NewAnimToPlay, bool bLooping);
    void RecreateClothingActors();
    void RemoveClothCollisionSource(USkeletalMeshComponent* InSourceComponent, UPhysicsAsset* InSourcePhysicsAsset);
    void RemoveClothCollisionSources(USkeletalMeshComponent* InSourceComponent);
    void ResetAllBodiesSimulatePhysics();
    void ResetAllowedAnimCurveEvaluation();
    void ResetAnimInstanceDynamics(ETeleportType InTeleportType);
    void ResetClothCollisionSources();
    void ResetClothTeleportMode();
    void ResumeClothingSimulation();
    void SetAllBodiesBelowLinearVelocity(const FName& InBoneName, const FVector& LinearVelocity, bool bIncludeSelf);
    void SetAllBodiesBelowPhysicsBlendWeight(const FName& InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType, bool bIncludeSelf);
    void SetAllBodiesBelowPhysicsDisabled(const FName& InBoneName, bool bDisabled, bool bIncludeSelf);
    void SetAllBodiesBelowSimulatePhysics(const FName& InBoneName, bool bNewSimulate, bool bIncludeSelf);
    void SetAllBodiesPhysicsBlendWeight(float PhysicsBlendWeight, bool bSkipCustomPhysicsType);
    void SetAllBodiesSimulatePhysics(bool bNewSimulate);
    void SetAllMotorsAngularDriveParams(float InSpring, float InDamping, float InForceLimit, bool bSkipCustomPhysicsType);
    void SetAllMotorsAngularPositionDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType);
    void SetAllMotorsAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType);
    void SetAllowAnimCurveEvaluation(bool bInAllow);
    void SetAllowClothActors(bool bInAllow);
    void SetAllowRigidBodyAnimNode(bool bInAllow, bool bReinitAnim);
    void SetAllowedAnimCurvesEvaluation(const TArray<FName>& List, bool bAllow);
    void SetAngularLimits(FName InBoneName, float Swing1LimitAngle, float TwistLimitAngle, float Swing2LimitAngle);
    void SetAnimInstanceClass(UClass* NewClass);
    void SetAnimation(UAnimationAsset* NewAnimToPlay);
    void SetAnimationMode(uint8_t InAnimationMode, bool bForceInitAnimScriptInstance);
    void SetBodyNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision, FName BoneName);
    void SetBodySimulatePhysics(const FName& InBoneName, bool bSimulate);
    void SetClothMaxDistanceScale(float Scale);
    void SetConstraintProfile(FName JointName, FName ProfileName, bool bDefaultIfNotFound);
    void SetConstraintProfileForAll(FName ProfileName, bool bDefaultIfNotFound);
    void SetDisableAnimCurves(bool bInDisableAnimCurves);
    void SetDisablePostProcessBlueprint(bool bInDisablePostProcess);
    void SetEnableAnimation(bool bNewEnableAnimation);
    void SetEnableBodyGravity(bool bEnableGravity, FName BoneName);
    void SetEnableGravityOnAllBodiesBelow(bool bEnableGravity, FName BoneName, bool bIncludeSelf);
    void SetEnablePhysicsBlending(bool bNewBlendPhysics);
    void SetMorphTarget(FName MorphTargetName, float Value, bool bRemoveZeroWeight);
    void SetNotifyRigidBodyCollisionBelow(bool bNewNotifyRigidBodyCollision, FName BoneName, bool bIncludeSelf);
    void SetOverridePostProcessAnimBP(UClass* InPostProcessAnimBlueprint, bool ReinitAnimInstances);
    void SetPhysicsBlendWeight(float PhysicsBlendWeight);
    void SetPlayRate(float Rate);
    void SetPosition(float InPos, bool bFireNotifies);
    void SetSkeletalMeshAsset(USkeletalMesh* NewMesh);
    void SetTeleportDistanceThreshold(float Threshold);
    void SetTeleportRotationThreshold(float Threshold);
    void SetUpdateAnimationInEditor(const bool NewUpdateState);
    void SetUpdateClothInEditor(const bool NewUpdateState);
    void SnapshotPose(FPoseSnapshot& Snapshot);
    void Stop();
    void SuspendClothingSimulation();
    void TermBodiesBelow(FName ParentBoneName);
    void ToggleDisablePostProcessBlueprint();
    void UnbindClothFromLeaderPoseComponent(bool bRestoreSimulationSpace);
    void UnlinkAnimClassLayers(UClass* InClass);
};

// Size: 0x30
struct FSkeletalMeshComponentClothTickFunction : public FTickFunction {
};

// Size: 0x30
struct FSkeletalMeshComponentEndPhysicsTickFunction : public FTickFunction {
};

// Size: 0xc0
struct FSkeletalMeshComponentInstanceData : public FSceneComponentInstanceData {
};

// Size: 0x28
class USkeletalMeshDescriptionBulkData : public UMeshDescriptionBaseBulkData {
};

// Size: 0x28
class USkeletalMeshEditorData : public UObject {
};

// Size: 0x28
class ISkeletalMeshHalfEdgeBufferAccessor : public UInterface {
};

// Size: 0x90
struct FSkeletalMeshLODGroupSettings {
    /* 0x0000 */ FPerPlatformFloat ScreenSize;
    /* 0x0004 */ float LODHysteresis;
    /* 0x0008 */ EBoneFilterActionOption BoneFilterActionOption;
    /* 0x0010 */ TArray<FBoneFilter> BoneList;
    /* 0x0020 */ TArray<FName> BonesToPrioritize;
    /* 0x0030 */ TArray<int32_t> SectionsToPrioritize;
    /* 0x0040 */ float WeightOfPrioritization;
    /* 0x0048 */ UAnimSequence* BakePose;
    /* 0x0050 */ FSkeletalMeshOptimizationSettings ReductionSettings;
    /* 0x008c */ bool bAllowMeshDeformer;
};

// Size: 0xe0
struct FSkeletalMeshLODInfo {
    /* 0x0000 */ FPerPlatformFloat ScreenSize;
    /* 0x0004 */ float LODHysteresis;
    /* 0x0008 */ TArray<int32_t> LODMaterialMap;
    /* 0x0018 */ FSkeletalMeshBuildSettings BuildSettings;
    /* 0x0030 */ FSkeletalMeshOptimizationSettings ReductionSettings;
    /* 0x0070 */ TArray<FBoneReference> BonesToRemove;
    /* 0x0080 */ TArray<FBoneReference> BonesToPrioritize;
    /* 0x0090 */ TArray<FSectionReference> SectionsToPrioritize;
    /* 0x00a0 */ float WeightOfPrioritization;
    /* 0x00a8 */ UAnimSequence* BakePose;
    /* 0x00b0 */ UAnimSequence* BakePoseOverride;
    /* 0x00b8 */ ESkinCacheUsage SkinCacheUsage;
    /* 0x00bc */ float MorphTargetPositionErrorTolerance;
    /* 0x00c0 */ bool bHasBeenSimplified;
    /* 0x00c0 */ bool bHasPerLODVertexColors;
    /* 0x00c0 */ bool bAllowCPUAccess;
    /* 0x00c0 */ bool bBuildHalfEdgeBuffers;
    /* 0x00c0 */ bool bAllowMeshDeformer;
    /* 0x00c8 */ TArray<FSkeletalMeshVertexAttributeInfo> VertexAttributes;
    /* 0x00d8 */ bool bSupportUniformlyDistributedSampling;
};

// Size: 0xb8
class USkeletalMeshLODSettings : public UDataAsset {
    /* 0x0030 */ FPerQualityLevelInt MinQualityLevelLOD;
    /* 0x0098 */ FPerPlatformInt MinLOD;
    /* 0x009c */ FPerPlatformBool DisableBelowMinLodStripping;
    /* 0x009d */ bool bOverrideLODStreamingSettings;
    /* 0x009e */ FPerPlatformBool bSupportLODStreaming;
    /* 0x00a0 */ FPerPlatformInt MaxNumStreamedLODs;
    /* 0x00a4 */ FPerPlatformInt MaxNumOptionalLODs;
    /* 0x00a8 */ TArray<FSkeletalMeshLODGroupSettings> LODGroups;
};

enum class SkeletalMeshOptimizationImportance {
    SMOI_Off = 0,
    SMOI_Lowest = 1,
    SMOI_Low = 2,
    SMOI_Normal = 3,
    SMOI_High = 4,
    SMOI_Highest = 5,
    SMOI_MAX = 6,
};

// Size: 0x3c
struct FSkeletalMeshOptimizationSettings {
    /* 0x0000 */ uint8_t TerminationCriterion;
    /* 0x0004 */ float NumOfTrianglesPercentage;
    /* 0x0008 */ float NumOfVertPercentage;
    /* 0x000c */ uint32_t MaxNumOfTriangles;
    /* 0x0010 */ uint32_t MaxNumOfVerts;
    /* 0x0014 */ float MaxDeviationPercentage;
    /* 0x0018 */ uint8_t ReductionMethod;
    /* 0x0019 */ uint8_t SilhouetteImportance;
    /* 0x001a */ uint8_t TextureImportance;
    /* 0x001b */ uint8_t ShadingImportance;
    /* 0x001c */ uint8_t SkinningImportance;
    /* 0x001d */ bool bRemapMorphTargets;
    /* 0x001d */ bool bRecalcNormals;
    /* 0x0020 */ float WeldingThreshold;
    /* 0x0024 */ float NormalsThreshold;
    /* 0x0028 */ int32_t MaxBonesPerVertex;
    /* 0x002c */ bool bEnforceBoneBoundaries;
    /* 0x002c */ bool bMergeCoincidentVertBones;
    /* 0x0030 */ float VolumeImportance;
    /* 0x0034 */ bool bLockEdges;
    /* 0x0034 */ bool bLockColorBounaries;
    /* 0x0034 */ bool bImproveTrianglesForCloth;
    /* 0x0038 */ int32_t BaseLOD;
};

enum class SkeletalMeshOptimizationType {
    SMOT_NumOfTriangles = 0,
    SMOT_MaxDeviation = 1,
    SMOT_TriangleOrDeviation = 2,
    SMOT_MAX = 3,
};

// Size: 0x20
struct FSkeletalMeshSamplingBuiltData {
    /* 0x0000 */ TArray<FSkeletalMeshSamplingLODBuiltData> WholeMeshBuiltData;
    /* 0x0010 */ TArray<FSkeletalMeshSamplingRegionBuiltData> RegionBuiltData;
};

// Size: 0x30
struct FSkeletalMeshSamplingInfo {
    /* 0x0000 */ TArray<FSkeletalMeshSamplingRegion> Regions;
    /* 0x0010 */ FSkeletalMeshSamplingBuiltData BuiltData;
};

// Size: 0x48
struct FSkeletalMeshSamplingLODBuiltData {
};

// Size: 0x30
struct FSkeletalMeshSamplingRegion {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t LODIndex;
    /* 0x000c */ bool bSupportUniformlyDistributedSampling;
    /* 0x0010 */ TArray<FSkeletalMeshSamplingRegionMaterialFilter> MaterialFilters;
    /* 0x0020 */ TArray<FSkeletalMeshSamplingRegionBoneFilter> BoneFilters;
};

// Size: 0xc
struct FSkeletalMeshSamplingRegionBoneFilter {
    /* 0x0000 */ FName BoneName;
    /* 0x0008 */ bool bIncludeOrExclude;
    /* 0x0008 */ bool bApplyToChildren;
};

// Size: 0x78
struct FSkeletalMeshSamplingRegionBuiltData {
};

// Size: 0x8
struct FSkeletalMeshSamplingRegionMaterialFilter {
    /* 0x0000 */ FName MaterialName;
};

// Size: 0x40
class USkeletalMeshSimplificationSettings : public UDeveloperSettings {
    /* 0x0038 */ FName SkeletalMeshReductionModuleName;
};

// Size: 0x88
class USkeletalMeshSocket : public UObject {
    /* 0x0028 */ FName SocketName;
    /* 0x0030 */ FName BoneName;
    /* 0x0038 */ FVector RelativeLocation;
    /* 0x0050 */ FRotator RelativeRotation;
    /* 0x0068 */ FVector RelativeScale;
    /* 0x0080 */ bool bForceAlwaysAnimated;

    FTransform GetSocketLocalTransform() const;
    FVector GetSocketLocation(const USkeletalMeshComponent* SkelComp) const;
    void InitializeSocketFromLocation(const USkeletalMeshComponent* SkelComp, FVector WorldLocation, FVector WorldNormal);
};

// Size: 0x78
struct FSkeletalMeshSourceModel {
    /* 0x0000 */ int32_t TriangleCount;
    /* 0x0004 */ int32_t VertexCount;
    /* 0x0008 */ FBoxSphereBounds Bounds;
    /* 0x0040 */ TArray<FName> CachedSkinWeightProfileNames;
    /* 0x0050 */ TArray<FName> CachedMorphTargetNames;
    /* 0x0060 */ TOptional<bool> CachedHasVertexColors;
    /* 0x0064 */ FGuid CachedVertexColorGuid;
};

enum class SkeletalMeshTerminationCriterion {
    SMTC_NumOfTriangles = 0,
    SMTC_NumOfVerts = 1,
    SMTC_TriangleOrVert = 2,
    SMTC_AbsNumOfTriangles = 3,
    SMTC_AbsNumOfVerts = 4,
    SMTC_AbsTriangleOrVert = 5,
    SMTC_MAX = 6,
};

// Size: 0x10
struct FSkeletalMeshVertexAttributeInfo {
    /* 0x0000 */ FPerPlatformBool EnabledForRender;
    /* 0x0004 */ FName Name;
    /* 0x000c */ ESkeletalMeshVertexAttributeDataType DataType;
};

// Size: 0x470
class USkeleton : public UObject {
    /* 0x0038 */ TArray<FBoneNode> BoneTree;
    /* 0x0170 */ FGuid VirtualBoneGuid;
    /* 0x0180 */ TArray<FVirtualBone> VirtualBones;
    /* 0x0190 */ TArray<TSoftObjectPtr<USkeleton>> CompatibleSkeletons;
    /* 0x01a0 */ bool bUseRetargetModesFromCompatibleSkeleton;
    /* 0x01a8 */ TArray<USkeletalMeshSocket*> Sockets;
    /* 0x0208 */ FSmartNameContainer SmartNames;
    /* 0x0268 */ TArray<UBlendProfile*> BlendProfiles;
    /* 0x0278 */ TArray<FAnimSlotGroup> SlotGroups;
    /* 0x0460 */ TArray<UAssetUserData*> AssetUserData;

    void AddCompatibleSkeleton(const USkeleton* SourceSkeleton);
    void AddCompatibleSkeletonSoft(const TSoftObjectPtr<USkeleton>& SourceSkeleton);
    UBlendProfile* GetBlendProfile(const FName& InProfileName);
};

// Size: 0x20
struct FSkeletonToMeshLinkup {
    /* 0x0000 */ TArray<int32_t> SkeletonToMeshTable;
    /* 0x0010 */ TArray<int32_t> MeshToSkeletonTable;
};

// Size: 0x10
struct FSkinWeightProfileInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FPerPlatformBool DefaultProfile;
    /* 0x000c */ FPerPlatformInt DefaultProfileFromLODIndex;
};

// Size: 0x30
struct FSkinWeightProfileManagerTickFunction : public FTickFunction {
};

// Size: 0xd8
class USkinnedAsset : public UStreamableRenderAsset {

    USkeletalMeshSocket* FindSocket(FName InSocketName) const;
    USkeletalMeshSocket* FindSocketInfo(FName InSocketName, FTransform& OutTransform, int32_t& OutBoneIndex, int32_t& OutIndex) const;
};

// Size: 0x8f0
class USkinnedMeshComponent : public UMeshComponent {
    /* 0x0578 */ USkeletalMesh* SkeletalMesh;
    /* 0x0580 */ USkinnedAsset* SkinnedAsset;
    /* 0x0588 */ TWeakObjectPtr<USkinnedMeshComponent> LeaderPoseComponent;
    /* 0x0590 */ TArray<ESkinCacheUsage> SkinCacheUsage;
    /* 0x05a0 */ bool bSetMeshDeformer;
    /* 0x05a8 */ UMeshDeformer* MeshDeformer;
    /* 0x05b0 */ bool bAlwaysUseMeshDeformer;
    /* 0x05b8 */ UMeshDeformerInstanceSettings* MeshDeformerInstanceSettings;
    /* 0x05c0 */ FMeshDeformerInstanceSet MeshDeformerInstances;
    /* 0x0760 */ UPhysicsAsset* PhysicsAssetOverride;
    /* 0x0768 */ int32_t ForcedLodModel;
    /* 0x0770 */ int32_t MinLodModel;
    /* 0x077c */ float StreamingDistanceMultiplier;
    /* 0x0788 */ TArray<FSkelMeshComponentLODInfo> LODInfo;
    /* 0x07bc */ EVisibilityBasedAnimTickOption VisibilityBasedAnimTickOption;
    /* 0x07bf */ bool bOverrideMinLOD;
    /* 0x07bf */ bool bUseBoundsFromLeaderPoseComponent;
    /* 0x07bf */ bool bIncludeComponentLocationIntoBounds;
    /* 0x07bf */ bool bForceWireframe;
    /* 0x07bf */ bool bDisableMorphTarget;
    /* 0x07c0 */ bool bHideSkin;
    /* 0x07c0 */ bool bPerBoneMotionBlur;
    /* 0x07c0 */ bool bComponentUseFixedSkelBounds;
    /* 0x07c0 */ bool bConsiderAllBodiesForBounds;
    /* 0x07c0 */ bool bSyncAttachParentLOD;
    /* 0x07c0 */ bool bCanHighlightSelectedSections;
    /* 0x07c0 */ bool bRecentlyRendered;
    /* 0x07c0 */ bool bCastCapsuleDirectShadow;
    /* 0x07c1 */ bool bCastCapsuleIndirectShadow;
    /* 0x07c1 */ bool bCPUSkinning;
    /* 0x07c1 */ bool bUseScreenRenderStateForUpdate;
    /* 0x07c1 */ bool bEnableUpdateRateOptimizations;
    /* 0x07c1 */ bool bDisplayDebugUpdateRateOptimizations;
    /* 0x07c1 */ bool bRenderStatic;
    /* 0x07c1 */ bool bIgnoreLeaderPoseComponentLOD;
    /* 0x07c1 */ bool bSortTriangles;
    /* 0x07c2 */ bool bCachedLocalBoundsUpToDate;
    /* 0x07c2 */ bool bCachedWorldSpaceBoundsUpToDate;
    /* 0x07c2 */ bool bForceMeshObjectUpdate;
    /* 0x07c3 */ bool bFollowerShouldTickPose;
    /* 0x07c4 */ float CapsuleIndirectShadowMinVisibility;
    /* 0x0818 */ FBoxSphereBounds CachedWorldOrLocalSpaceBounds;
    /* 0x0850 */ FMatrix CachedWorldToLocalTransform;

    bool BoneIsChildOf(FName BoneName, FName ParentBoneName) const;
    void ClearAllSkinWeightProfiles();
    void ClearSkinWeightOverride(int32_t LODIndex);
    void ClearSkinWeightProfile(ESkinWeightProfileLayer InLayer);
    void ClearVertexColorOverride(int32_t LODIndex);
    FName FindClosestBone_K2(FVector TestLocation, FVector& BoneLocation, float IgnoreScale, bool bRequirePhysicsAsset) const;
    bool GetAlwaysUseMeshDeformer() const;
    int32_t GetBoneIndex(FName BoneName) const;
    FName GetBoneName(int32_t BoneIndex) const;
    FTransform GetBoneTransform(FName InBoneName, uint8_t TransformSpace) const;
    TArray<FName> GetCurrentSkinWeightProfileLayerNames() const;
    FName GetCurrentSkinWeightProfileName(ESkinWeightProfileLayer InLayer) const;
    FTransform GetDeltaTransformFromRefPose(FName BoneName, FName BaseName) const;
    int32_t GetForcedLOD() const;
    UMeshDeformerInstance* GetMeshDeformerInstance() const;
    int32_t GetNumBones() const;
    int32_t GetNumLODs() const;
    FName GetParentBone(FName BoneName) const;
    int32_t GetPredictedLODLevel() const;
    FVector GetRefPosePosition(int32_t BoneIndex) const;
    FTransform GetRefPoseTransform(int32_t BoneIndex) const;
    USkeletalMesh* GetSkeletalMesh_DEPRECATED() const;
    USkinnedAsset* GetSkinnedAsset() const;
    FName GetSocketBoneName(FName InSocketName) const;
    bool GetTwistAndSwingAngleOfDeltaRotationFromRefPose(FName BoneName, float& OutTwistAngle, float& OutSwingAngle) const;
    void HideBoneByName(FName BoneName, uint8_t PhysBodyOption);
    bool IsBoneHiddenByName(FName BoneName);
    bool IsMaterialSectionShown(int32_t MaterialID, int32_t LODIndex);
    bool IsUsingSkinWeightProfile() const;
    void OverrideMinLOD(int32_t InNewMinLOD);
    void SetAlwaysUseMeshDeformer(bool bShouldAlwaysUseMeshDeformer);
    void SetCapsuleIndirectShadowMinVisibility(float NewValue);
    void SetCastCapsuleDirectShadow(bool bNewValue);
    void SetCastCapsuleIndirectShadow(bool bNewValue);
    void SetForcedLOD(int32_t InNewForcedLOD);
    void SetLeaderPoseComponent(USkinnedMeshComponent* NewLeaderBoneComponent, bool bForceUpdate, bool bInFollowerShouldTickPose);
    void SetMeshDeformer(UMeshDeformer* InMeshDeformer);
    void SetMinLOD(int32_t InNewMinLOD);
    void SetPhysicsAsset(UPhysicsAsset* NewPhysicsAsset, bool bForceReInit);
    void SetRenderStatic(bool bNewValue);
    void SetSkinWeightOverride(int32_t LODIndex, const TArray<FSkelMeshSkinWeightInfo>& SkinWeights);
    bool SetSkinWeightProfile(FName InProfileName, ESkinWeightProfileLayer InLayer);
    void SetSkinnedAssetAndUpdate(USkinnedAsset* NewMesh, bool bReinitPose);
    void SetVertexColorOverride_LinearColor(int32_t LODIndex, const TArray<FLinearColor>& VertexColors);
    void ShowAllMaterialSections(int32_t LODIndex);
    void ShowMaterialSection(int32_t MaterialID, int32_t SectionIndex, bool bShow, int32_t LODIndex);
    void TransformFromBoneSpace(FName BoneName, FVector InPosition, FRotator InRotation, FVector& OutPosition, FRotator& OutRotation);
    void TransformToBoneSpace(FName BoneName, FVector InPosition, FRotator InRotation, FVector& OutPosition, FRotator& OutRotation) const;
    void UnHideBoneByName(FName BoneName);
    void UnloadSkinWeightProfile(FName InProfileName);
    void UnsetMeshDeformer();
};

// Size: 0x90
struct FSkinnedMeshComponentDescriptor : public FSkinnedMeshComponentDescriptorBase {
    /* 0x0078 */ USkinnedAsset* SkinnedAsset;
    /* 0x0080 */ TArray<FAnimBankItem> BankItems;
};

// Size: 0x78
struct FSkinnedMeshComponentDescriptorBase {
    /* 0x0008 */ uint32_t Hash;
    /* 0x000c */ uint8_t Mobility;
    /* 0x0010 */ UClass* ComponentClass;
    /* 0x0018 */ int32_t InstanceMinDrawDistance;
    /* 0x001c */ int32_t InstanceStartCullDistance;
    /* 0x0020 */ int32_t InstanceEndCullDistance;
    /* 0x0024 */ bool bCastShadow;
    /* 0x0024 */ bool bCastDynamicShadow;
    /* 0x0024 */ bool bCastStaticShadow;
    /* 0x0024 */ bool bCastVolumetricTranslucentShadow;
    /* 0x0024 */ bool bCastContactShadow;
    /* 0x0024 */ bool bSelfShadowOnly;
    /* 0x0024 */ bool bCastFarShadow;
    /* 0x0024 */ bool bCastInsetShadow;
    /* 0x0025 */ bool bCastCinematicShadow;
    /* 0x0025 */ bool bCastShadowAsTwoSided;
    /* 0x0026 */ bool bVisibleInRayTracing;
    /* 0x0027 */ bool bAffectDynamicIndirectLighting;
    /* 0x0028 */ bool bAffectDistanceFieldLighting;
    /* 0x0030 */ FBox PrimitiveBoundsOverride;
    /* 0x0068 */ bool bIsInstanceDataGPUOnly;
    /* 0x006c */ int32_t NumInstancesGPUOnly;
    /* 0x0070 */ int32_t NumCustomDataFloatsGPUOnly;
};

// Size: 0x30
struct FSkinnedMeshDynamicState {
    /* 0x0008 */ FTransformHandle Transform;
    /* 0x0018 */ USkinnedAsset* SkinnedAsset;
    /* 0x0020 */ TArray<UMaterialInterface*> OverrideMaterials;
};

// Size: 0x10
struct FSkinnedMeshHandle : public FStateStreamHandle {
};

// Size: 0x40
struct FSkinnedMeshInstanceData {
    /* 0x0000 */ FTransform3f Transform;
    /* 0x0030 */ uint32_t BankIndex;
};

// Size: 0x10
struct FSkinnedMeshStaticState {
    /* 0x0008 */ uint64_t MaterialRelevance;
};

// Size: 0x2b0
class ASkyAtmosphere : public AInfo {
    /* 0x02a8 */ USkyAtmosphereComponent* SkyAtmosphereComponent;
};

// Size: 0x350
class USkyAtmosphereComponent : public USceneComponent {
    /* 0x0240 */ ESkyAtmosphereTransformMode TransformMode;
    /* 0x0244 */ float BottomRadius;
    /* 0x0248 */ FColor GroundAlbedo;
    /* 0x024c */ float AtmosphereHeight;
    /* 0x0250 */ float MultiScatteringFactor;
    /* 0x0254 */ float TraceSampleCountScale;
    /* 0x0258 */ float RayleighScatteringScale;
    /* 0x025c */ FLinearColor RayleighScattering;
    /* 0x026c */ float RayleighExponentialDistribution;
    /* 0x0270 */ float MieScatteringScale;
    /* 0x0274 */ FLinearColor MieScattering;
    /* 0x0284 */ float MieAbsorptionScale;
    /* 0x0288 */ FLinearColor MieAbsorption;
    /* 0x0298 */ float MieAnisotropy;
    /* 0x029c */ float MieExponentialDistribution;
    /* 0x02a0 */ float OtherAbsorptionScale;
    /* 0x02a4 */ FLinearColor OtherAbsorption;
    /* 0x02b4 */ FTentDistribution OtherTentDistribution;
    /* 0x02c0 */ FLinearColor SkyLuminanceFactor;
    /* 0x02d0 */ FLinearColor SkyAndAerialPerspectiveLuminanceFactor;
    /* 0x02e0 */ float AerialPespectiveViewDistanceScale;
    /* 0x02e4 */ float HeightFogContribution;
    /* 0x02e8 */ float TransmittanceMinLightElevationAngle;
    /* 0x02ec */ float AerialPerspectiveStartDepth;
    /* 0x02f0 */ bool bHoldout;
    /* 0x02f0 */ bool bRenderInMainPass;
    /* 0x0338 */ FGuid bStaticLightingBuiltGUID;

    FLinearColor GetAtmosphereTransmitanceOnGroundAtPlanetTop(UDirectionalLightComponent* DirectionalLight);
    float GetAtmosphericLightToMatchIlluminanceOnGround(FVector LightDirection, float IlluminanceOnGround);
    FVector GetOverridenAtmosphereLightDirection(int32_t AtmosphereLightIndex);
    bool IsAtmosphereLightDirectionOverriden(int32_t AtmosphereLightIndex);
    void OverrideAtmosphereLightDirection(int32_t AtmosphereLightIndex, const FVector& LightDirection);
    void ResetAtmosphereLightDirectionOverride(int32_t AtmosphereLightIndex);
    void SetAerialPerspectiveStartDepth(float NewValue);
    void SetAerialPespectiveViewDistanceScale(float NewValue);
    void SetAtmosphereHeight(float NewValue);
    void SetBottomRadius(float NewValue);
    void SetGroundAlbedo(const FColor& NewValue);
    void SetHeightFogContribution(float NewValue);
    void SetHoldout(bool bNewHoldout);
    void SetMieAbsorption(FLinearColor NewValue);
    void SetMieAbsorptionScale(float NewValue);
    void SetMieAnisotropy(float NewValue);
    void SetMieExponentialDistribution(float NewValue);
    void SetMieScattering(FLinearColor NewValue);
    void SetMieScatteringScale(float NewValue);
    void SetMultiScatteringFactor(float NewValue);
    void SetOtherAbsorption(FLinearColor NewValue);
    void SetOtherAbsorptionScale(float NewValue);
    void SetRayleighExponentialDistribution(float NewValue);
    void SetRayleighScattering(FLinearColor NewValue);
    void SetRayleighScatteringScale(float NewValue);
    void SetRenderInMainPass(bool bValue);
    void SetSkyAndAerialPerspectiveLuminanceFactor(FLinearColor NewValue);
    void SetSkyLuminanceFactor(FLinearColor NewValue);
    void SetTransmittanceMinLightElevationAngle(float NewValue);
};

// Size: 0x160
struct FSkyAtmosphereDynamicState {
    /* 0x0004 */ ESkyAtmosphereTransformMode TransformMode;
    /* 0x0008 */ float BottomRadius;
    /* 0x000c */ FColor GroundAlbedo;
    /* 0x0010 */ float AtmosphereHeight;
    /* 0x0014 */ float MultiScatteringFactor;
    /* 0x0018 */ float TraceSampleCountScale;
    /* 0x001c */ float RayleighScatteringScale;
    /* 0x0020 */ FLinearColor RayleighScattering;
    /* 0x0030 */ float RayleighExponentialDistribution;
    /* 0x0034 */ float MieScatteringScale;
    /* 0x0038 */ FLinearColor MieScattering;
    /* 0x0048 */ float MieAbsorptionScale;
    /* 0x004c */ FLinearColor MieAbsorption;
    /* 0x005c */ float MieAnisotropy;
    /* 0x0060 */ float MieExponentialDistribution;
    /* 0x0064 */ float OtherAbsorptionScale;
    /* 0x0068 */ FLinearColor OtherAbsorption;
    /* 0x0078 */ float OtherTentDistributionTipAltitude;
    /* 0x007c */ float OtherTentDistributionTipValue;
    /* 0x0080 */ float OtherTentDistributionWidth;
    /* 0x0084 */ FLinearColor SkyLuminanceFactor;
    /* 0x0094 */ FLinearColor SkyAndAerialPerspectiveLuminanceFactor;
    /* 0x00a4 */ float AerialPespectiveViewDistanceScale;
    /* 0x00a8 */ float HeightFogContribution;
    /* 0x00ac */ float TransmittanceMinLightElevationAngle;
    /* 0x00b0 */ float AerialPerspectiveStartDepth;
    /* 0x00b4 */ bool bHoldout;
    /* 0x00b4 */ bool bRenderInMainPass;
    /* 0x00b4 */ bool bBuilt;
    /* 0x00c0 */ FTransform ComponentTransform;
    /* 0x0120 */ FOverrideAtmosphericLight OverrideAtmosphericLight;
};

// Size: 0x10
struct FSkyAtmosphereHandle : public FStateStreamHandle {
};

// Size: 0x4
struct FSkyAtmosphereStaticState {
};

// Size: 0x2b8
class ASkyLight : public AInfo {
    /* 0x02a8 */ USkyLightComponent* LightComponent;
    /* 0x02b0 */ bool bEnabled;

    void OnRep_bEnabled();
};

// Size: 0x460
class USkyLightComponent : public ULightComponentBase {
    /* 0x0288 */ bool bRealTimeCapture;
    /* 0x0289 */ uint8_t SourceType;
    /* 0x0290 */ UTextureCube* Cubemap;
    /* 0x0298 */ float SourceCubemapAngle;
    /* 0x029c */ int32_t CubemapResolution;
    /* 0x02a0 */ float SkyDistanceThreshold;
    /* 0x02a4 */ bool bCaptureEmissiveOnly;
    /* 0x02a5 */ bool bLowerHemisphereIsBlack;
    /* 0x02a8 */ FLinearColor LowerHemisphereColor;
    /* 0x02b8 */ float OcclusionMaxDistance;
    /* 0x02bc */ float Contrast;
    /* 0x02c0 */ float OcclusionExponent;
    /* 0x02c4 */ float MinOcclusion;
    /* 0x02c8 */ FColor OcclusionTint;
    /* 0x02cc */ bool bCloudAmbientOcclusion;
    /* 0x02d0 */ float CloudAmbientOcclusionStrength;
    /* 0x02d4 */ float CloudAmbientOcclusionExtent;
    /* 0x02d8 */ float CloudAmbientOcclusionMapResolutionScale;
    /* 0x02dc */ float CloudAmbientOcclusionApertureScale;
    /* 0x02e0 */ uint8_t OcclusionCombineMode;
    /* 0x0388 */ UTextureCube* BlendDestinationCubemap;

    void RecaptureSky();
    void SetCubemap(UTextureCube* NewCubemap);
    void SetCubemapBlend(UTextureCube* SourceCubemap, UTextureCube* DestinationCubemap, float InBlendFraction);
    void SetIndirectLightingIntensity(float NewIntensity);
    void SetIntensity(float NewIntensity);
    void SetLightColor(FLinearColor NewLightColor);
    void SetLowerHemisphereColor(const FLinearColor& InLowerHemisphereColor);
    void SetMinOcclusion(float InMinOcclusion);
    void SetOcclusionContrast(float InOcclusionContrast);
    void SetOcclusionExponent(float InOcclusionExponent);
    void SetOcclusionTint(const FColor& InTint);
    void SetRealTimeCapture(bool bInRealTimeCapture);
    void SetSourceCubemapAngle(float NewValue);
    void SetVolumetricScatteringIntensity(float NewIntensity);
};

// Size: 0xe0
class USlateBrushAsset : public UObject {
    /* 0x0030 */ FSlateBrush Brush;
};

// Size: 0x1
struct FSlateModifierKeysState {
    /* 0x0000 */ uint8_t ModifierKeysStateMask;
};

// Size: 0x28
class ISlateTextureAtlasInterface : public UInterface {
};

// Size: 0x18
struct FSlotAnimationTrack {
    /* 0x0000 */ FName SlotName;
    /* 0x0008 */ FAnimTrack AnimTrack;
};

// Size: 0x80
struct FSlotEvaluationPose {
    /* 0x0000 */ uint8_t AdditiveType;
    /* 0x0004 */ float Weight;
};

// Size: 0xc
struct FSmartName {
    /* 0x0000 */ FName DisplayName;
};

// Size: 0x50
struct FSmartNameContainer {
};

// Size: 0x70
struct FSmartNameMapping {
};

// Size: 0x80
class USmokeTestCommandlet : public UCommandlet {
};

// Size: 0x70
struct FSocketReference {
    /* 0x0060 */ FName SocketName;
};

// Size: 0x30
struct FSoftAnimBankItem {
    /* 0x0000 */ TSoftObjectPtr<UAnimBank> BankAsset;
    /* 0x0028 */ int32_t SequenceIndex;
};

// Size: 0x48
struct FSoftComponentReference : public FBaseComponentReference {
    /* 0x0020 */ TSoftObjectPtr<AActor> OtherActor;
};

// Size: 0x248
struct FSoftISMComponentDescriptor : public FISMComponentDescriptorBase {
    /* 0x01d8 */ TSoftObjectPtr<UStaticMesh> StaticMesh;
    /* 0x0200 */ TArray<TSoftObjectPtr<UMaterialInterface>> OverrideMaterials;
    /* 0x0210 */ TSoftObjectPtr<UMaterialInterface> OverlayMaterial;
    /* 0x0238 */ TArray<TSoftObjectPtr<URuntimeVirtualTexture>> RuntimeVirtualTextures;
};

// Size: 0xb0
struct FSoftSkinnedMeshComponentDescriptor : public FSkinnedMeshComponentDescriptorBase {
    /* 0x0078 */ TSoftObjectPtr<USkinnedAsset> SkinnedAsset;
    /* 0x00a0 */ TArray<FSoftAnimBankItem> BankItems;
};

// Size: 0x238
struct FSoftSplineMeshComponentDescriptor : public FSplineMeshComponentDescriptorBase {
    /* 0x01c8 */ TSoftObjectPtr<UStaticMesh> StaticMesh;
    /* 0x01f0 */ TArray<TSoftObjectPtr<UMaterialInterface>> OverrideMaterials;
    /* 0x0200 */ TSoftObjectPtr<UMaterialInterface> OverlayMaterial;
    /* 0x0228 */ TArray<TSoftObjectPtr<URuntimeVirtualTexture>> RuntimeVirtualTextures;
};

// Size: 0x28
struct FSoftWorldReference {
    /* 0x0000 */ TSoftObjectPtr<UWorld> WorldAsset;
};

// Size: 0x18
struct FSolverIterations {
    /* 0x0000 */ int32_t SolverIterations;
    /* 0x0004 */ int32_t JointIterations;
    /* 0x0008 */ int32_t CollisionIterations;
    /* 0x000c */ int32_t SolverPushOutIterations;
    /* 0x0010 */ int32_t JointPushOutIterations;
    /* 0x0014 */ int32_t CollisionPushOutIterations;
};

// Size: 0x3f8
class USoundAttenuation : public UObject {
    /* 0x0028 */ FSoundAttenuationSettings Attenuation;
};

// Size: 0x30
class USoundAttenuationEditorSettings : public UObject {
    /* 0x0028 */ bool bEnableReverbSend;
    /* 0x0029 */ bool bEnableSendToAudioLink;
};

// Size: 0x40
struct FSoundAttenuationPluginSettings {
    /* 0x0000 */ TArray<USpatializationPluginSourceSettingsBase*> SpatializationPluginSettingsArray;
    /* 0x0010 */ TArray<UOcclusionPluginSourceSettingsBase*> OcclusionPluginSettingsArray;
    /* 0x0020 */ TArray<UReverbPluginSourceSettingsBase*> ReverbPluginSettingsArray;
    /* 0x0030 */ TArray<USourceDataOverridePluginSourceSettingsBase*> SourceDataOverridePluginSettingsArray;
};

// Size: 0x3d0
struct FSoundAttenuationSettings : public FBaseAttenuationSettings {
    /* 0x00c0 */ bool bAttenuate;
    /* 0x00c0 */ bool bSpatialize;
    /* 0x00c0 */ bool bAttenuateWithLPF;
    /* 0x00c0 */ bool bEnableListenerFocus;
    /* 0x00c0 */ bool bEnableFocusInterpolation;
    /* 0x00c0 */ bool bEnableOcclusion;
    /* 0x00c0 */ bool bUseComplexCollisionForOcclusion;
    /* 0x00c0 */ bool bEnableReverbSend;
    /* 0x00c1 */ bool bEnablePriorityAttenuation;
    /* 0x00c1 */ bool bApplyNormalizationToStereoSounds;
    /* 0x00c1 */ bool bEnableLogFrequencyScaling;
    /* 0x00c1 */ bool bEnableSubmixSends;
    /* 0x00c1 */ bool bEnableSourceDataOverride;
    /* 0x00c1 */ bool bEnableSendToAudioLink;
    /* 0x00c2 */ uint8_t SpatializationAlgorithm;
    /* 0x00c8 */ UAudioLinkSettingsAbstract* AudioLinkSettingsOverride;
    /* 0x00d0 */ float BinauralRadius;
    /* 0x00d8 */ FRuntimeFloatCurve CustomLowpassAirAbsorptionCurve;
    /* 0x0160 */ FRuntimeFloatCurve CustomHighpassAirAbsorptionCurve;
    /* 0x01e8 */ EAirAbsorptionMethod AbsorptionMethod;
    /* 0x01e9 */ uint8_t OcclusionTraceChannel;
    /* 0x01ea */ EReverbSendMethod ReverbSendMethod;
    /* 0x01eb */ EPriorityAttenuationMethod PriorityAttenuationMethod;
    /* 0x01ec */ float NonSpatializedRadiusStart;
    /* 0x01f0 */ float NonSpatializedRadiusEnd;
    /* 0x01f4 */ ENonSpatializedRadiusSpeakerMapMode NonSpatializedRadiusMode;
    /* 0x01f8 */ float StereoSpread;
    /* 0x01fc */ float LPFRadiusMin;
    /* 0x0200 */ float LPFRadiusMax;
    /* 0x0204 */ float LPFFrequencyAtMin;
    /* 0x0208 */ float LPFFrequencyAtMax;
    /* 0x020c */ float HPFFrequencyAtMin;
    /* 0x0210 */ float HPFFrequencyAtMax;
    /* 0x0214 */ float FocusAzimuth;
    /* 0x0218 */ float NonFocusAzimuth;
    /* 0x021c */ float FocusDistanceScale;
    /* 0x0220 */ float NonFocusDistanceScale;
    /* 0x0224 */ float FocusPriorityScale;
    /* 0x0228 */ float NonFocusPriorityScale;
    /* 0x022c */ float FocusVolumeAttenuation;
    /* 0x0230 */ float NonFocusVolumeAttenuation;
    /* 0x0234 */ float FocusAttackInterpSpeed;
    /* 0x0238 */ float FocusReleaseInterpSpeed;
    /* 0x023c */ float OcclusionLowPassFilterFrequency;
    /* 0x0240 */ float OcclusionVolumeAttenuation;
    /* 0x0244 */ float OcclusionInterpolationTime;
    /* 0x0248 */ float ReverbWetLevelMin;
    /* 0x024c */ float ReverbWetLevelMax;
    /* 0x0250 */ float ReverbDistanceMin;
    /* 0x0254 */ float ReverbDistanceMax;
    /* 0x0258 */ float ManualReverbSendLevel;
    /* 0x025c */ float PriorityAttenuationMin;
    /* 0x0260 */ float PriorityAttenuationMax;
    /* 0x0264 */ float PriorityAttenuationDistanceMin;
    /* 0x0268 */ float PriorityAttenuationDistanceMax;
    /* 0x026c */ float ManualPriorityAttenuation;
    /* 0x0270 */ FRuntimeFloatCurve CustomReverbSendCurve;
    /* 0x02f8 */ TArray<FAttenuationSubmixSendSettings> SubmixSendSettings;
    /* 0x0308 */ FRuntimeFloatCurve CustomPriorityAttenuationCurve;
    /* 0x0390 */ FSoundAttenuationPluginSettings PluginSettings;
};

// Size: 0x178
class USoundBase : public UObject {
    /* 0x0038 */ USoundClass* SoundClassObject;
    /* 0x0040 */ bool bDebug;
    /* 0x0040 */ bool bOverrideConcurrency;
    /* 0x0040 */ bool bEnableBusSends;
    /* 0x0040 */ bool bEnableBaseSubmix;
    /* 0x0040 */ bool bEnableSubmixSends;
    /* 0x0040 */ bool bHasDelayNode;
    /* 0x0040 */ bool bHasConcatenatorNode;
    /* 0x0040 */ bool bBypassVolumeScaleForPriority;
    /* 0x0041 */ EVirtualizationMode VirtualizationMode;
    /* 0x0098 */ TSet<USoundConcurrency*> ConcurrencySet;
    /* 0x00e8 */ FSoundConcurrencySettings ConcurrencyOverrides;
    /* 0x0108 */ float Duration;
    /* 0x010c */ float MaxDistance;
    /* 0x0110 */ float TotalSamples;
    /* 0x0114 */ float Priority;
    /* 0x0118 */ USoundAttenuation* AttenuationSettings;
    /* 0x0120 */ USoundSubmixBase* SoundSubmixObject;
    /* 0x0128 */ TArray<FSoundSubmixSendInfo> SoundSubmixSends;
    /* 0x0138 */ USoundEffectSourcePresetChain* SourceEffectChain;
    /* 0x0140 */ TArray<FSoundSourceBusSendInfo> BusSends;
    /* 0x0150 */ TArray<FSoundSourceBusSendInfo> PreEffectBusSends;
    /* 0x0160 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0170 */ FSoundTimecodeOffset TimecodeOffset;

    bool IsAttenuationSettingsEditable() const;
};

// Size: 0x200
class USoundClass : public UObject {
    /* 0x0030 */ FSoundClassProperties Properties;
    /* 0x01c8 */ TArray<USoundClass*> ChildClasses;
    /* 0x01d8 */ TArray<FPassiveSoundMixModifier> PassiveSoundMixModifiers;
    /* 0x01e8 */ USoundClass* ParentClass;
    /* 0x01f0 */ TArray<UAssetUserData*> AssetUserData;
};

// Size: 0x20
struct FSoundClassAdjuster {
    /* 0x0000 */ USoundClass* SoundClassObject;
    /* 0x0008 */ float VolumeAdjuster;
    /* 0x000c */ float PitchAdjuster;
    /* 0x0010 */ float LowPassFilterFrequency;
    /* 0x0014 */ bool bApplyToChildren;
    /* 0x0018 */ float VoiceCenterChannelVolumeAdjuster;
};

// Size: 0x8
struct FSoundClassEditorData {
};

// Size: 0x198
struct FSoundClassProperties {
    /* 0x0000 */ float Volume;
    /* 0x0004 */ float Pitch;
    /* 0x0008 */ float LowPassFilterFrequency;
    /* 0x000c */ float AttenuationDistanceScale;
    /* 0x0010 */ float LFEBleed;
    /* 0x0014 */ float VoiceCenterChannelVolume;
    /* 0x0018 */ float RadioFilterVolume;
    /* 0x001c */ float RadioFilterVolumeThreshold;
    /* 0x0020 */ bool bApplyEffects;
    /* 0x0020 */ bool bAlwaysPlay;
    /* 0x0020 */ bool bIsUISound;
    /* 0x0020 */ bool bIsMusic;
    /* 0x0020 */ bool bCenterChannelOnly;
    /* 0x0020 */ bool bApplyAmbientVolumes;
    /* 0x0020 */ bool bReverb;
    /* 0x0024 */ float Default2DReverbSendAmount;
    /* 0x0028 */ FSoundModulationDefaultSettings ModulationSettings;
    /* 0x0188 */ uint8_t OutputTarget;
    /* 0x0189 */ ESoundWaveLoadingBehavior LoadingBehavior;
    /* 0x0190 */ USoundSubmix* DefaultSubmix;
};

// Size: 0x48
class USoundConcurrency : public UObject {
    /* 0x0028 */ FSoundConcurrencySettings Concurrency;
};

// Size: 0x20
struct FSoundConcurrencySettings {
    /* 0x0000 */ int32_t MaxCount;
    /* 0x0004 */ bool bLimitToOwner;
    /* 0x0004 */ bool bVolumeScaleCanRelease;
    /* 0x0005 */ uint8_t ResolutionRule;
    /* 0x0008 */ float RetriggerTime;
    /* 0x000c */ float VolumeScale;
    /* 0x0010 */ EConcurrencyVolumeScaleMode VolumeScaleMode;
    /* 0x0014 */ float VolumeScaleAttackTime;
    /* 0x0018 */ float VolumeScaleReleaseTime;
    /* 0x001c */ float VoiceStealReleaseTime;
};

// Size: 0x570
class USoundCue : public USoundBase {
    /* 0x0178 */ USoundNode* FirstNode;
    /* 0x0180 */ float VolumeMultiplier;
    /* 0x0184 */ float PitchMultiplier;
    /* 0x0188 */ FSoundAttenuationSettings AttenuationOverrides;
    /* 0x0558 */ float SubtitlePriority;
    /* 0x0560 */ bool bPrimeOnLoad;
    /* 0x0560 */ bool bOverrideAttenuation;
    /* 0x0560 */ bool bExcludeFromRandomNodeBranchCulling;
    /* 0x0560 */ bool bHasPlayWhenSilent;
    /* 0x0564 */ int32_t CookedQualityIndex;
};

// Size: 0x28
struct FSoundDebugEntry {
    /* 0x0000 */ FName DebugName;
    /* 0x0008 */ FSoftObjectPath Sound;
};

// Size: 0x68
class USoundEffectPreset : public UObject {
};

// Size: 0x28
class USoundEffectPresetWidgetInterface : public IAudioPanelWidgetInterface {

    UClass* GetClass();
    void OnConstructed(USoundEffectPreset* Preset);
    void OnPropertyChanged(USoundEffectPreset* Preset, FName PropertyName);
};

// Size: 0x68
class USoundEffectSourcePreset : public USoundEffectPreset {
};

// Size: 0x40
class USoundEffectSourcePresetChain : public UObject {
    /* 0x0028 */ TArray<FSourceEffectChainEntry> Chain;
    /* 0x0038 */ bool bPlayEffectChainTails;
};

// Size: 0x68
class USoundEffectSubmixPreset : public USoundEffectPreset {
};

// Size: 0x20
struct FSoundGroup {
    /* 0x0000 */ uint8_t SoundGroup;
    /* 0x0008 */ FString DisplayName;
    /* 0x0018 */ bool bAlwaysDecompressOnLoad;
    /* 0x001c */ float DecompressedDuration;
};

// Size: 0x88
class USoundGroups : public UObject {
    /* 0x0028 */ TArray<FSoundGroup> SoundGroupProfiles;
};

// Size: 0x90
class USoundMix : public UObject {
    /* 0x0028 */ bool bApplyEQ;
    /* 0x002c */ float EQPriority;
    /* 0x0030 */ FAudioEQEffect EQSettings;
    /* 0x0070 */ TArray<FSoundClassAdjuster> SoundClassEffects;
    /* 0x0080 */ float InitialDelay;
    /* 0x0084 */ float fadeInTime;
    /* 0x0088 */ float Duration;
    /* 0x008c */ float fadeOutTime;
};

// Size: 0x168
struct FSoundModulationDefaultRoutingSettings : public FSoundModulationDefaultSettings {
    /* 0x0160 */ EModulationRouting VolumeRouting;
    /* 0x0161 */ EModulationRouting PitchRouting;
    /* 0x0162 */ EModulationRouting HighpassRouting;
    /* 0x0163 */ EModulationRouting LowpassRouting;
};

// Size: 0x160
struct FSoundModulationDefaultSettings {
    /* 0x0000 */ FSoundModulationDestinationSettings VolumeModulationDestination;
    /* 0x0058 */ FSoundModulationDestinationSettings PitchModulationDestination;
    /* 0x00b0 */ FSoundModulationDestinationSettings HighpassModulationDestination;
    /* 0x0108 */ FSoundModulationDestinationSettings LowpassModulationDestination;
};

// Size: 0x58
struct FSoundModulationDestinationSettings {
    /* 0x0000 */ float Value;
    /* 0x0008 */ TSet<USoundModulatorBase*> Modulators;
};

// Size: 0x48
class USoundNode : public UObject {
    /* 0x0028 */ TArray<USoundNode*> ChildNodes;
};

// Size: 0x48
class USoundNodeAssetReferencer : public USoundNode {
};

// Size: 0x428
class USoundNodeAttenuation : public USoundNode {
    /* 0x0048 */ USoundAttenuation* AttenuationSettings;
    /* 0x0050 */ FSoundAttenuationSettings AttenuationOverrides;
    /* 0x0420 */ bool bOverrideAttenuation;
};

// Size: 0x50
class USoundNodeBranch : public USoundNode {
    /* 0x0048 */ FName BoolParameterName;
};

// Size: 0x58
class USoundNodeConcatenator : public USoundNode {
    /* 0x0048 */ TArray<float> InputVolume;
};

// Size: 0x50
class USoundNodeDelay : public USoundNode {
    /* 0x0048 */ float DelayMin;
    /* 0x004c */ float DelayMax;
};

// Size: 0x70
class USoundNodeDialoguePlayer : public USoundNode {
    /* 0x0048 */ FDialogueWaveParameter DialogueWaveParameter;
    /* 0x0068 */ bool bLooping;
};

// Size: 0x58
class USoundNodeDistanceCrossFade : public USoundNode {
    /* 0x0048 */ TArray<FDistanceDatum> CrossFadeInput;
};

// Size: 0x58
class USoundNodeDoppler : public USoundNode {
    /* 0x0048 */ float DopplerIntensity;
    /* 0x004c */ bool bUseSmoothing;
    /* 0x0050 */ float SmoothingInterpSpeed;
};

// Size: 0x8
struct FSoundNodeEditorData {
};

// Size: 0x190
class USoundNodeEnveloper : public USoundNode {
    /* 0x0048 */ float LoopStart;
    /* 0x004c */ float LoopEnd;
    /* 0x0050 */ float DurationAfterLoop;
    /* 0x0054 */ int32_t LoopCount;
    /* 0x0058 */ bool bLoopIndefinitely;
    /* 0x0058 */ bool bLoop;
    /* 0x0060 */ UDistributionFloatConstantCurve* VolumeInterpCurve;
    /* 0x0068 */ UDistributionFloatConstantCurve* PitchInterpCurve;
    /* 0x0070 */ FRuntimeFloatCurve VolumeCurve;
    /* 0x00f8 */ FRuntimeFloatCurve PitchCurve;
    /* 0x0180 */ float PitchMin;
    /* 0x0184 */ float PitchMax;
    /* 0x0188 */ float VolumeMin;
    /* 0x018c */ float VolumeMax;
};

// Size: 0x58
class USoundNodeGroupControl : public USoundNode {
    /* 0x0048 */ TArray<int32_t> GroupSizes;
};

// Size: 0x50
class USoundNodeLooping : public USoundNode {
    /* 0x0048 */ int32_t LoopCount;
    /* 0x004c */ bool bLoopIndefinitely;
};

// Size: 0x48
class USoundNodeMature : public USoundNode {
};

// Size: 0x58
class USoundNodeMixer : public USoundNode {
    /* 0x0048 */ TArray<float> InputVolume;
};

// Size: 0x58
class USoundNodeModulator : public USoundNode {
    /* 0x0048 */ float PitchMin;
    /* 0x004c */ float PitchMax;
    /* 0x0050 */ float VolumeMin;
    /* 0x0054 */ float VolumeMax;
};

// Size: 0x88
class USoundNodeModulatorContinuous : public USoundNode {
    /* 0x0048 */ FModulatorContinuousParams PitchModulationParams;
    /* 0x0068 */ FModulatorContinuousParams VolumeModulationParams;
};

// Size: 0x70
class USoundNodeOscillator : public USoundNode {
    /* 0x0048 */ bool bModulateVolume;
    /* 0x0048 */ bool bModulatePitch;
    /* 0x004c */ float AmplitudeMin;
    /* 0x0050 */ float AmplitudeMax;
    /* 0x0054 */ float FrequencyMin;
    /* 0x0058 */ float FrequencyMax;
    /* 0x005c */ float OffsetMin;
    /* 0x0060 */ float OffsetMax;
    /* 0x0064 */ float CenterMin;
    /* 0x0068 */ float CenterMax;
};

// Size: 0x60
class USoundNodeParamCrossFade : public USoundNodeDistanceCrossFade {
    /* 0x0058 */ FName paramName;
};

// Size: 0x50
class USoundNodeQualityLevel : public USoundNode {
    /* 0x0048 */ int32_t CookedQualityLevelIndex;
};

// Size: 0x78
class USoundNodeRandom : public USoundNode {
    /* 0x0048 */ TArray<float> Weights;
    /* 0x0058 */ TArray<bool> HasBeenUsed;
    /* 0x0068 */ int32_t NumRandomUsed;
    /* 0x006c */ int32_t PreselectAtLevelLoad;
    /* 0x0070 */ bool bShouldExcludeFromBranchCulling;
    /* 0x0070 */ bool bSoundCueExcludedFromBranchCulling;
    /* 0x0070 */ bool bRandomizeWithoutReplacement;
};

// Size: 0x58
class USoundNodeSoundClass : public USoundNode {
    /* 0x0048 */ USoundClass* SoundClassOverride;
};

// Size: 0x50
class USoundNodeSwitch : public USoundNode {
    /* 0x0048 */ FName IntParameterName;
};

// Size: 0x50
class USoundNodeWaveParam : public USoundNode {
    /* 0x0048 */ FName WaveParameterName;
};

// Size: 0x80
class USoundNodeWavePlayer : public USoundNodeAssetReferencer {
    /* 0x0048 */ TSoftObjectPtr<USoundWave> SoundWaveAssetPtr;
    /* 0x0070 */ USoundWave* SoundWave;
    /* 0x0078 */ bool bLooping;
};

// Size: 0x28
class USoundParameterControllerInterface : public IAudioParameterControllerInterface {
};

// Size: 0x418
class USoundSourceBus : public USoundWave {
    /* 0x0400 */ ESourceBusChannels SourceBusChannels;
    /* 0x0404 */ float SourceBusDuration;
    /* 0x0408 */ UAudioBus* AudioBus;
    /* 0x0410 */ bool bAutoDeactivateWhenSilent;
};

// Size: 0xb8
struct FSoundSourceBusSendInfo {
    /* 0x0000 */ ESourceBusSendLevelControlMethod SourceBusSendLevelControlMethod;
    /* 0x0008 */ USoundSourceBus* SoundSourceBus;
    /* 0x0010 */ UAudioBus* AudioBus;
    /* 0x0018 */ float SendLevel;
    /* 0x001c */ float MinSendLevel;
    /* 0x0020 */ float MaxSendLevel;
    /* 0x0024 */ float MinSendDistance;
    /* 0x0028 */ float MaxSendDistance;
    /* 0x0030 */ FRuntimeFloatCurve CustomSendLevelCurve;
};

// Size: 0x248
class USoundSubmix : public USoundSubmixWithParentBase {
    /* 0x00f0 */ bool bMuteWhenBackgrounded;
    /* 0x00f8 */ TArray<USoundEffectSubmixPreset*> SubmixEffectChain;
    /* 0x0108 */ USoundfieldEncodingSettingsBase* AmbisonicsPluginSettings;
    /* 0x0110 */ int32_t EnvelopeFollowerAttackTime;
    /* 0x0114 */ int32_t EnvelopeFollowerReleaseTime;
    /* 0x0118 */ FSoundModulationDestinationSettings OutputVolumeModulation;
    /* 0x0170 */ FSoundModulationDestinationSettings WetLevelModulation;
    /* 0x01c8 */ FSoundModulationDestinationSettings DryLevelModulation;
    /* 0x0220 */ bool bSendToAudioLink;
    /* 0x0228 */ UAudioLinkSettingsAbstract* AudioLinkSettings;
    /* 0x0230 */ FMulticastInlineDelegate OnSubmixRecordedFileDone;

    void AddEnvelopeFollowerDelegate(const UObject* WorldContextObject, const FDelegate& OnSubmixEnvelopeBP);
    void AddSpectralAnalysisDelegate(const UObject* WorldContextObject, const TArray<FSoundSubmixSpectralAnalysisBandSettings>& InBandSettings, const FDelegate& OnSubmixSpectralAnalysisBP, float UpdateRate, float DecibelNoiseFloor, bool bDoNormalize, bool bDoAutoRange, float AutoRangeAttackTime, float AutoRangeReleaseTime);
    void RemoveEnvelopeFollowerDelegate(const UObject* WorldContextObject, const FDelegate& OnSubmixEnvelopeBP);
    void RemoveSpectralAnalysisDelegate(const UObject* WorldContextObject, const FDelegate& OnSubmixSpectralAnalysisBP);
    void SetDryVolumeModulation(const FSoundModulationDestinationSettings& InVolMod);
    void SetOutputVolumeModulation(const FSoundModulationDestinationSettings& InVolMod);
    void SetSubmixDryLevel(const UObject* WorldContextObject, float InDryLevel);
    void SetSubmixOutputVolume(const UObject* WorldContextObject, float InOutputVolume);
    void SetSubmixWetLevel(const UObject* WorldContextObject, float InWetLevel);
    void SetWetVolumeModulation(const FSoundModulationDestinationSettings& InVolMod);
    void StartEnvelopeFollowing(const UObject* WorldContextObject);
    void StartRecordingOutput(const UObject* WorldContextObject, float ExpectedDuration);
    void StartSpectralAnalysis(const UObject* WorldContextObject, EFFTSize FFTSize, EFFTPeakInterpolationMethod InterpolationMethod, EFFTWindowType WindowType, float HopSize, EAudioSpectrumType SpectrumType);
    void StopEnvelopeFollowing(const UObject* WorldContextObject);
    void StopRecordingOutput(const UObject* WorldContextObject, EAudioRecordingExportType ExportType, FString Name, FString Path, USoundWave* ExistingSoundWaveToOverwrite);
    void StopSpectralAnalysis(const UObject* WorldContextObject);
};

// Size: 0x90
class USoundSubmixBase : public UObject {
    /* 0x0028 */ bool bAutoDisable;
    /* 0x002c */ float AutoDisableTime;
    /* 0x0030 */ TArray<USoundSubmixBase*> ChildSubmixes;
    /* 0x0040 */ TMap<uint32_t, FDynamicChildSubmix> DynamicChildSubmixes;

    bool DynamicConnect(const UObject* WorldContextObject, USoundSubmixBase* InParent);
    bool DynamicDisconnect(const UObject* WorldContextObject);
    USoundSubmixBase* FindDynamicAncestor();
};

// Size: 0xb8
struct FSoundSubmixSendInfo : public FSoundSubmixSendInfoBase {
    /* 0x00b0 */ ESubmixSendStage SendStage;
};

// Size: 0xb0
struct FSoundSubmixSendInfoBase {
    /* 0x0000 */ ESendLevelControlMethod SendLevelControlMethod;
    /* 0x0008 */ USoundSubmixBase* SoundSubmix;
    /* 0x0010 */ float SendLevel;
    /* 0x0014 */ bool DisableManualSendClamp;
    /* 0x0018 */ float MinSendLevel;
    /* 0x001c */ float MaxSendLevel;
    /* 0x0020 */ float MinSendDistance;
    /* 0x0024 */ float MaxSendDistance;
    /* 0x0028 */ FRuntimeFloatCurve CustomSendLevelCurve;
};

// Size: 0x10
struct FSoundSubmixSpectralAnalysisBandSettings {
    /* 0x0000 */ float BandFrequency;
    /* 0x0004 */ int32_t AttackTimeMsec;
    /* 0x0008 */ int32_t ReleaseTimeMsec;
    /* 0x000c */ float QFactor;
};

// Size: 0x28
class ISoundSubmixWidgetInterface : public UInterface {

    void OnConstructed(USoundSubmixBase* SoundSubmix);
};

// Size: 0xf0
class USoundSubmixWithParentBase : public USoundSubmixBase {
    /* 0x0090 */ USoundSubmixBase* ParentSubmix;
    /* 0x0098 */ TMap<uint32_t, USoundSubmixBase*> DynamicParentSubmix;
    /* 0x00e8 */ bool bIsDynamic;
};

// Size: 0x8
struct FSoundTimecodeOffset {
    /* 0x0000 */ double NumOfSecondsSinceMidnight;
};

// Size: 0x400
class USoundWave : public USoundBase {
    /* 0x0188 */ int32_t CompressionQuality;
    /* 0x018c */ int32_t StreamingPriority;
    /* 0x0190 */ ESoundwaveSampleRateSettings SampleRateQuality;
    /* 0x0192 */ uint8_t SoundGroup;
    /* 0x0193 */ bool bLooping;
    /* 0x0193 */ bool bStreaming;
    /* 0x0193 */ bool bSeekableStreaming;
    /* 0x0193 */ bool bUseBinkAudio;
    /* 0x0194 */ ESoundAssetCompressionType SoundAssetCompressionType;
    /* 0x01a8 */ FSoundModulationDefaultRoutingSettings ModulationSettings;
    /* 0x0310 */ TArray<float> FrequenciesToAnalyze;
    /* 0x0320 */ TArray<FSoundWaveSpectralTimeData> CookedSpectralTimeData;
    /* 0x0330 */ TArray<FSoundWaveEnvelopeTimeData> CookedEnvelopeTimeData;
    /* 0x035c */ bool bMature;
    /* 0x035c */ bool bManualWordWrap;
    /* 0x035c */ bool bSingleLine;
    /* 0x035d */ bool bIsAmbisonics;
    /* 0x035e */ ESoundWaveLoadingBehavior LoadingBehavior;
    /* 0x0360 */ FString SpokenText;
    /* 0x0370 */ float SubtitlePriority;
    /* 0x0374 */ float Volume;
    /* 0x0378 */ float Pitch;
    /* 0x037c */ int32_t NumChannels;
    /* 0x0380 */ int32_t SampleRate;
    /* 0x0390 */ TArray<FSubtitleCue> Subtitles;
    /* 0x03a0 */ UCurveTable* Curves;
    /* 0x03a8 */ UCurveTable* InternalCurves;

    TArray<FSoundWaveCuePoint> GetCuePoints() const;
    TArray<FSoundWaveCuePoint> GetLoopRegions() const;
    ESoundAssetCompressionType GetSoundAssetCompressionType() const;
    void SetSoundAssetCompressionType(ESoundAssetCompressionType InSoundAssetCompressionType, bool bMarkDirty);
};

// Size: 0x10
struct FSoundWaveEnvelopeDataPerSound {
    /* 0x0000 */ float Envelope;
    /* 0x0004 */ float PlaybackTime;
    /* 0x0008 */ USoundWave* SoundWave;
};

// Size: 0x8
struct FSoundWaveEnvelopeTimeData {
    /* 0x0000 */ float Amplitude;
    /* 0x0004 */ float TimeSec;
};

// Size: 0x450
class USoundWaveProcedural : public USoundWave {
};

// Size: 0xc
struct FSoundWaveSpectralData {
    /* 0x0000 */ float FrequencyHz;
    /* 0x0004 */ float Magnitude;
    /* 0x0008 */ float NormalizedMagnitude;
};

// Size: 0x8
struct FSoundWaveSpectralDataEntry {
    /* 0x0000 */ float Magnitude;
    /* 0x0004 */ float NormalizedMagnitude;
};

// Size: 0x20
struct FSoundWaveSpectralDataPerSound {
    /* 0x0000 */ TArray<FSoundWaveSpectralData> SpectralData;
    /* 0x0010 */ float PlaybackTime;
    /* 0x0018 */ USoundWave* SoundWave;
};

// Size: 0x18
struct FSoundWaveSpectralTimeData {
    /* 0x0000 */ TArray<FSoundWaveSpectralDataEntry> Data;
    /* 0x0010 */ float TimeSec;
};

// Size: 0x70
struct FSoundWaveTimecodeInfo {
    /* 0x0000 */ uint64_t NumSamplesSinceMidnight;
    /* 0x0008 */ uint32_t NumSamplesPerSecond;
    /* 0x0010 */ FString Description;
    /* 0x0020 */ FString OriginatorTime;
    /* 0x0030 */ FString OriginatorDate;
    /* 0x0040 */ FString OriginatorDescription;
    /* 0x0050 */ FString OriginatorReference;
    /* 0x0060 */ FFrameRate TimecodeRate;
    /* 0x0068 */ bool bTimecodeIsDropFrame;
};

// Size: 0xc8
class USoundfieldEndpointSubmix : public USoundSubmixBase {
    /* 0x0090 */ FName SoundfieldEndpointType;
    /* 0x0098 */ UClass* EndpointSettingsClass;
    /* 0x00a0 */ USoundfieldEndpointSettingsBase* EndpointSettings;
    /* 0x00a8 */ UClass* EncodingSettingsClass;
    /* 0x00b0 */ USoundfieldEncodingSettingsBase* EncodingSettings;
    /* 0x00b8 */ TArray<USoundfieldEffectBase*> SoundfieldEffectChain;
};

// Size: 0x118
class USoundfieldSubmix : public USoundSubmixWithParentBase {
    /* 0x00f0 */ FName SoundfieldEncodingFormat;
    /* 0x00f8 */ USoundfieldEncodingSettingsBase* EncodingSettings;
    /* 0x0100 */ TArray<USoundfieldEffectBase*> SoundfieldEffectChain;
    /* 0x0110 */ UClass* EncodingSettingsClass;
};

// Size: 0x10
struct FSourceEffectChainEntry {
    /* 0x0000 */ USoundEffectSourcePreset* Preset;
    /* 0x0008 */ bool bBypass;
};

// Size: 0x28
class USparseVolumeTexture : public UObject {

    FTransform GetFrameTransform() const;
    int32_t GetNumFrames() const;
    int32_t GetNumMipLevels() const;
    int32_t GetSizeX() const;
    int32_t GetSizeY() const;
    int32_t GetSizeZ() const;
};

// Size: 0x1d0
class USparseVolumeTextureFrame : public USparseVolumeTexture {
    /* 0x0028 */ USparseVolumeTexture* Owner;
    /* 0x0030 */ int32_t FrameIndex;
    /* 0x0040 */ FTransform Transform;
};

// Size: 0x28
struct FSparseVolumeTextureParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ USparseVolumeTexture* ParameterValue;
    /* 0x0018 */ FGuid ExpressionGUID;
};

// Size: 0x1
struct FSpatialHashRuntimeGrid {
};

// Size: 0x2b0
class ASpatialHashRuntimeGridInfo : public AInfo {
    /* 0x02a8 */ FSpatialHashRuntimeGrid GridSettings;
};

// Size: 0x2
struct FSpatialHashSettings {
    /* 0x0000 */ bool bUseAlignedGridLevels;
    /* 0x0001 */ bool bSnapNonAlignedGridLevelsToLowerLevels;
};

// Size: 0xb0
struct FSpatialHashStreamingGrid {
    /* 0x0000 */ FName GridName;
    /* 0x0008 */ FVector Origin;
    /* 0x0020 */ int32_t CellSize;
    /* 0x0024 */ float LoadingRange;
    /* 0x0028 */ bool bBlockOnSlowStreaming;
    /* 0x002c */ FLinearColor DebugColor;
    /* 0x0040 */ TArray<FSpatialHashStreamingGridLevel> GridLevels;
    /* 0x0050 */ FBox WorldBounds;
    /* 0x0088 */ bool bClientOnlyVisible;
    /* 0x008c */ int32_t GridIndex;
    /* 0x0090 */ FSpatialHashSettings Settings;
    /* 0x00a0 */ TArray<FSpatialHashStreamingGridLevel> InjectedGridLevels;
};

// Size: 0x10
struct FSpatialHashStreamingGridLayerCell {
    /* 0x0000 */ TArray<UWorldPartitionRuntimeCell*> GridCells;
};

// Size: 0x60
struct FSpatialHashStreamingGridLevel {
    /* 0x0000 */ TArray<FSpatialHashStreamingGridLayerCell> LayerCells;
    /* 0x0010 */ TMap<int64_t, int32_t> LayerCellsMapping;
};

// Size: 0x350
class ASpectatorPawn : public ADefaultPawn {
};

// Size: 0x1a8
class USpectatorPawnMovement : public UFloatingPawnMovement {
    /* 0x01a0 */ bool bIgnoreTimeDilation;
};

// Size: 0x458
class USpecularProfile : public UObject {
    /* 0x0028 */ FSpecularProfileStruct Settings;
    /* 0x0448 */ FGuid Guid;
};

// Size: 0x420
struct FSpecularProfileStruct {
    /* 0x0000 */ ESpecularProfileFormat Format;
    /* 0x0008 */ FRuntimeCurveLinearColor ViewColor;
    /* 0x0210 */ FRuntimeCurveLinearColor LightColor;
    /* 0x0418 */ UTexture2D* Texture;
};

// Size: 0x550
class USphereComponent : public UShapeComponent {
    /* 0x0540 */ float SphereRadius;

    float GetScaledSphereRadius() const;
    float GetShapeScale() const;
    float GetUnscaledSphereRadius() const;
    void SetSphereRadius(float InSphereRadius, bool bUpdateOverlaps);
};

// Size: 0x2b8
class ASphereReflectionCapture : public AReflectionCapture {
    /* 0x02b0 */ UDrawSphereComponent* DrawCaptureRadius;
};

// Size: 0x2c0
class USphereReflectionCaptureComponent : public UReflectionCaptureComponent {
    /* 0x02a8 */ float InfluenceRadius;
    /* 0x02ac */ float CaptureDistanceScale;
    /* 0x02b0 */ UDrawSphereComponent* PreviewInfluenceRadius;
};

// Size: 0x18
struct FSpline {
};

// Size: 0x5d0
class USplineComponent : public UPrimitiveComponent {
    /* 0x0520 */ FSpline Spline;
    /* 0x0538 */ FSplineCurves SplineCurves;
    /* 0x05a0 */ int32_t ReparamStepsPerSegment;
    /* 0x05a4 */ float Duration;
    /* 0x05a8 */ bool bStationaryEndpoints;
    /* 0x05a9 */ bool bSplineHasBeenEdited;
    /* 0x05aa */ bool bModifiedByConstructionScript;
    /* 0x05ab */ bool bInputSplinePointsToConstructionScript;
    /* 0x05ac */ bool bDrawDebug;
    /* 0x05ad */ bool bClosedLoop;
    /* 0x05ae */ bool bLoopPositionOverride;
    /* 0x05b0 */ float LoopPosition;
    /* 0x05b8 */ FVector DefaultUpVector;

    void AddPoint(const FSplinePoint& Point, bool bUpdateSpline);
    void AddPoints(const TArray<FSplinePoint>& points, bool bUpdateSpline);
    void AddSplineLocalPoint(const FVector& position);
    void AddSplinePoint(const FVector& position, uint8_t CoordinateSpace, bool bUpdateSpline);
    void AddSplinePointAtIndex(const FVector& position, int32_t Index, uint8_t CoordinateSpace, bool bUpdateSpline);
    void AddSplineWorldPoint(const FVector& position);
    void ClearSplinePoints(bool bUpdateSpline);
    bool ConvertSplineSegmentToPolyLine(int32_t SplinePointStartIndex, uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
    bool ConvertSplineToPolyLine(uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
    bool ConvertSplineToPolyLineWithDistances(uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline) const;
    bool ConvertSplineToPolyline_InDistanceRange(uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, float StartDistAlongSpline, float EndDistAlongSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline, bool bAllowWrappingIfClosed) const;
    bool ConvertSplineToPolyline_InTimeRange(uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, float StartTimeAlongSpline, float EndTimeAlongSpline, bool bUseConstantVelocity, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline, bool bAllowWrappingIfClosed) const;
    bool DivideSplineIntoPolylineRecursive(float StartDistanceAlongSpline, float EndDistanceAlongSpline, uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints) const;
    bool DivideSplineIntoPolylineRecursiveWithDistances(float StartDistanceAlongSpline, float EndDistanceAlongSpline, uint8_t CoordinateSpace, const float MaxSquareDistanceFromSpline, TArray<FVector>& OutPoints, TArray<double>& OutDistancesAlongSpline) const;
    FVector FindDirectionClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    float FindInputKeyClosestToWorldLocation(const FVector& WorldLocation) const;
    float FindInputKeyOnSegmentClosestToWorldLocation(const FVector& WorldLocation, int32_t Index) const;
    FVector FindLocationClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    FVector FindRightVectorClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    float FindRollClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    FRotator FindRotationClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    FVector FindScaleClosestToWorldLocation(const FVector& WorldLocation) const;
    FVector FindTangentClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    FTransform FindTransformClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace, bool bUseScale) const;
    FVector FindUpVectorClosestToWorldLocation(const FVector& WorldLocation, uint8_t CoordinateSpace) const;
    FVector GetArriveTangentAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetDefaultUpVector(uint8_t CoordinateSpace) const;
    FVector GetDirectionAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FVector GetDirectionAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FVector GetDirectionAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetDirectionAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    float GetDistanceAlongSplineAtLocation(const FVector& InLocation, uint8_t CoordinateSpace) const;
    float GetDistanceAlongSplineAtSplineInputKey(float InKey) const;
    float GetDistanceAlongSplineAtSplinePoint(int32_t PointIndex) const;
    float GetFloatPropertyAtSplineInputKey(float InKey, FName PropertyName) const;
    float GetFloatPropertyAtSplinePoint(int32_t Index, FName PropertyName) const;
    float GetInputKeyAtDistanceAlongSpline(float Distance) const;
    float GetInputKeyValueAtDistanceAlongSpline(float Distance) const;
    float GetInputKeyValueAtSplinePoint(int32_t PointIndex) const;
    FVector GetLeaveTangentAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    void GetLocalLocationAndTangentAtSplinePoint(int32_t PointIndex, FVector& LocalLocation, FVector& LocalTangent) const;
    void GetLocationAndTangentAtSplinePoint(int32_t PointIndex, FVector& Location, FVector& Tangent, uint8_t CoordinateSpace) const;
    FVector GetLocationAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FVector GetLocationAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FVector GetLocationAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetLocationAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    int32_t GetNumberOfSplinePoints() const;
    int32_t GetNumberOfSplineSegments() const;
    FVector GetRightVectorAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FVector GetRightVectorAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FVector GetRightVectorAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetRightVectorAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    float GetRollAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    float GetRollAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    float GetRollAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    float GetRollAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    FRotator GetRotationAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FRotator GetRotationAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FRotator GetRotationAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FRotator GetRotationAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    FVector GetScaleAtDistanceAlongSpline(float Distance) const;
    FVector GetScaleAtSplineInputKey(float InKey) const;
    FVector GetScaleAtSplinePoint(int32_t PointIndex) const;
    FVector GetScaleAtTime(float Time, bool bUseConstantVelocity) const;
    float GetSplineLength() const;
    FSplinePoint GetSplinePointAt(int32_t PointIndex, uint8_t CoordinateSpace) const;
    uint8_t GetSplinePointType(int32_t PointIndex) const;
    FVector GetTangentAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FVector GetTangentAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FVector GetTangentAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetTangentAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    float GetTimeAtDistanceAlongSpline(float Distance) const;
    FTransform GetTransformAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace, bool bUseScale) const;
    FTransform GetTransformAtSplineInputKey(float InKey, uint8_t CoordinateSpace, bool bUseScale) const;
    FTransform GetTransformAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace, bool bUseScale) const;
    FTransform GetTransformAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity, bool bUseScale) const;
    FVector GetUpVectorAtDistanceAlongSpline(float Distance, uint8_t CoordinateSpace) const;
    FVector GetUpVectorAtSplineInputKey(float InKey, uint8_t CoordinateSpace) const;
    FVector GetUpVectorAtSplinePoint(int32_t PointIndex, uint8_t CoordinateSpace) const;
    FVector GetUpVectorAtTime(float Time, uint8_t CoordinateSpace, bool bUseConstantVelocity) const;
    FVector GetVectorPropertyAtSplineInputKey(float InKey, FName PropertyName) const;
    FVector GetVectorPropertyAtSplinePoint(int32_t Index, FName PropertyName) const;
    FVector GetWorldDirectionAtDistanceAlongSpline(float Distance) const;
    FVector GetWorldDirectionAtTime(float Time, bool bUseConstantVelocity) const;
    FVector GetWorldLocationAtDistanceAlongSpline(float Distance) const;
    FVector GetWorldLocationAtSplinePoint(int32_t PointIndex) const;
    FVector GetWorldLocationAtTime(float Time, bool bUseConstantVelocity) const;
    FRotator GetWorldRotationAtDistanceAlongSpline(float Distance) const;
    FRotator GetWorldRotationAtTime(float Time, bool bUseConstantVelocity) const;
    FVector GetWorldTangentAtDistanceAlongSpline(float Distance) const;
    bool IsClosedLoop() const;
    void RemoveSplinePoint(int32_t Index, bool bUpdateSpline);
    void SetClosedLoop(bool bInClosedLoop, bool bUpdateSpline);
    void SetClosedLoopAtPosition(bool bInClosedLoop, float Key, bool bUpdateSpline);
    void SetDefaultUpVector(const FVector& UpVector, uint8_t CoordinateSpace);
    void SetDrawDebug(bool bShow);
    void SetLocationAtSplinePoint(int32_t PointIndex, const FVector& InLocation, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetOverrideConstructionScript(bool InOverride);
    void SetRotationAtSplinePoint(int32_t PointIndex, const FRotator& InRotation, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetScaleAtSplinePoint(int32_t PointIndex, const FVector& InScaleVector, bool bUpdateSpline);
    void SetSelectedSplineSegmentColor(const FLinearColor& SegmentColor);
    void SetSplineLocalPoints(const TArray<FVector>& points);
    void SetSplinePointType(int32_t PointIndex, uint8_t Type, bool bUpdateSpline);
    void SetSplinePoints(const TArray<FVector>& points, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetSplineWorldPoints(const TArray<FVector>& points);
    void SetTangentAtSplinePoint(int32_t PointIndex, const FVector& InTangent, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetTangentColor(const FLinearColor& TangentColor);
    void SetTangentsAtSplinePoint(int32_t PointIndex, const FVector& InArriveTangent, const FVector& InLeaveTangent, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetUnselectedSplineSegmentColor(const FLinearColor& SegmentColor);
    void SetUpVectorAtSplinePoint(int32_t PointIndex, const FVector& InUpVector, uint8_t CoordinateSpace, bool bUpdateSpline);
    void SetWorldLocationAtSplinePoint(int32_t PointIndex, const FVector& InLocation);
    void UpdateSpline();
};

// Size: 0x68
struct FSplineCurves {
    /* 0x0000 */ FInterpCurveVector position;
    /* 0x0018 */ FInterpCurveQuat Rotation;
    /* 0x0030 */ FInterpCurveVector Scale;
    /* 0x0048 */ FInterpCurveFloat ReparamTable;
    /* 0x0060 */ uint32_t Version;
};

// Size: 0x198
struct FSplineInstanceData : public FSceneComponentInstanceData {
    /* 0x00b8 */ bool bSplineHasBeenEdited;
    /* 0x00c0 */ FSplineCurves SplineCurves;
    /* 0x0128 */ bool bClosedLoop;
    /* 0x0130 */ FSplineCurves SplineCurvesPreUCS;
};

// Size: 0x2b0
class ASplineMeshActor : public AActor {
    /* 0x02a8 */ USplineMeshComponent* SplineMeshComponent;
};

// Size: 0x740
class USplineMeshComponent : public UStaticMeshComponent {
    /* 0x0618 */ FSplineMeshParams SplineParams;
    /* 0x06c8 */ FVector SplineUpDir;
    /* 0x06e0 */ float SplineBoundaryMin;
    /* 0x06e4 */ FGuid CachedMeshBodySetupGuid;
    /* 0x06f4 */ float VirtualTextureMainPassMaxDrawDistance;
    /* 0x0730 */ UBodySetup* BodySetup;
    /* 0x0738 */ float SplineBoundaryMax;
    /* 0x073c */ uint8_t ForwardAxis;
    /* 0x073d */ bool bAllowSplineEditingPerInstance;
    /* 0x073d */ bool bSmoothInterpRollScale;
    /* 0x073d */ bool bMeshDirty;
    /* 0x073d */ bool bNeverNeedsCookedCollisionData;

    float GetBoundaryMax() const;
    float GetBoundaryMin() const;
    FVector2D GetEndOffset() const;
    FVector GetEndPosition() const;
    float GetEndRoll() const;
    FVector2D GetEndScale() const;
    FVector GetEndTangent() const;
    uint8_t GetForwardAxis() const;
    FVector GetSplineUpDir() const;
    FVector2D GetStartOffset() const;
    FVector GetStartPosition() const;
    float GetStartRoll() const;
    FVector2D GetStartScale() const;
    FVector GetStartTangent() const;
    void SetBoundaryMax(float InBoundaryMax, bool bUpdateMesh);
    void SetBoundaryMin(float InBoundaryMin, bool bUpdateMesh);
    void SetEndOffset(FVector2D EndOffset, bool bUpdateMesh);
    void SetEndPosition(FVector EndPos, bool bUpdateMesh);
    void SetEndRoll(float EndRoll, bool bUpdateMesh);
    void SetEndRollDegrees(float EndRollDegrees, bool bUpdateMesh);
    void SetEndScale(FVector2D EndScale, bool bUpdateMesh);
    void SetEndTangent(FVector EndTangent, bool bUpdateMesh);
    void SetForwardAxis(uint8_t InForwardAxis, bool bUpdateMesh);
    void SetSplineUpDir(const FVector& InSplineUpDir, bool bUpdateMesh);
    void SetStartAndEnd(FVector StartPos, FVector StartTangent, FVector EndPos, FVector EndTangent, bool bUpdateMesh);
    void SetStartOffset(FVector2D StartOffset, bool bUpdateMesh);
    void SetStartPosition(FVector StartPos, bool bUpdateMesh);
    void SetStartRoll(float StartRoll, bool bUpdateMesh);
    void SetStartRollDegrees(float StartRollDegrees, bool bUpdateMesh);
    void SetStartScale(FVector2D StartScale, bool bUpdateMesh);
    void SetStartTangent(FVector StartTangent, bool bUpdateMesh);
    void UpdateMesh();
};

// Size: 0x1f8
struct FSplineMeshComponentDescriptor : public FSplineMeshComponentDescriptorBase {
    /* 0x01c8 */ UStaticMesh* StaticMesh;
    /* 0x01d0 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x01e0 */ UMaterialInterface* OverlayMaterial;
    /* 0x01e8 */ TArray<URuntimeVirtualTexture*> RuntimeVirtualTextures;
};

// Size: 0x1c8
struct FSplineMeshComponentDescriptorBase {
    /* 0x0008 */ uint32_t Hash;
    /* 0x0010 */ UClass* ComponentClass;
    /* 0x0018 */ uint8_t Mobility;
    /* 0x0019 */ ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType;
    /* 0x001a */ ELightmapType LightmapType;
    /* 0x001b */ FLightingChannels LightingChannels;
    /* 0x001c */ int32_t RayTracingGroupId;
    /* 0x0020 */ ERayTracingGroupCullingPriority RayTracingGroupCullingPriority;
    /* 0x0021 */ uint8_t bHasCustomNavigableGeometry;
    /* 0x0022 */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x0028 */ FBodyInstance BodyInstance;
    /* 0x01a8 */ int32_t VirtualTextureCullMips;
    /* 0x01ac */ int32_t TranslucencySortPriority;
    /* 0x01b0 */ int32_t OverriddenLightMapRes;
    /* 0x01b4 */ int32_t CustomDepthStencilValue;
    /* 0x01b8 */ bool bCastShadow;
    /* 0x01b8 */ bool bEmissiveLightSource;
    /* 0x01b8 */ bool bCastDynamicShadow;
    /* 0x01b8 */ bool bCastStaticShadow;
    /* 0x01b8 */ bool bCastContactShadow;
    /* 0x01b8 */ bool bCastShadowAsTwoSided;
    /* 0x01b8 */ bool bCastHiddenShadow;
    /* 0x01b8 */ bool bAffectDynamicIndirectLighting;
    /* 0x01b9 */ bool bAffectDynamicIndirectLightingWhileHidden;
    /* 0x01b9 */ bool bAffectDistanceFieldLighting;
    /* 0x01b9 */ bool bReceivesDecals;
    /* 0x01b9 */ bool bOverrideLightMapRes;
    /* 0x01b9 */ bool bUseAsOccluder;
    /* 0x01b9 */ bool bEnableDiscardOnLoad;
    /* 0x01b9 */ bool bRenderCustomDepth;
    /* 0x01b9 */ bool bVisibleInRayTracing;
    /* 0x01ba */ bool bHiddenInGame;
    /* 0x01ba */ bool bIsEditorOnly;
    /* 0x01ba */ bool bVisible;
    /* 0x01ba */ bool bEvaluateWorldPositionOffset;
    /* 0x01ba */ bool bReverseCulling;
    /* 0x01ba */ bool bUseDefaultCollision;
    /* 0x01ba */ bool bGenerateOverlapEvents;
    /* 0x01ba */ bool bOverrideNavigationExport;
    /* 0x01bb */ bool bForceNavigationObstacle;
    /* 0x01bb */ bool bFillCollisionUnderneathForNavmesh;
    /* 0x01bc */ int32_t WorldPositionOffsetDisableDistance;
    /* 0x01c0 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
    /* 0x01c1 */ uint8_t DetailMode;
};

// Size: 0x1d0
struct FSplineMeshInstanceData : public FStaticMeshComponentInstanceData {
    /* 0x0168 */ FVector StartPos;
    /* 0x0180 */ FVector EndPos;
    /* 0x0198 */ FVector StartTangent;
    /* 0x01b0 */ FVector EndTangent;
};

// Size: 0xb0
struct FSplineMeshParams {
    /* 0x0000 */ FVector StartPos;
    /* 0x0018 */ FVector StartTangent;
    /* 0x0030 */ FVector2D StartScale;
    /* 0x0040 */ float StartRoll;
    /* 0x0044 */ float EndRoll;
    /* 0x0048 */ FVector2D StartOffset;
    /* 0x0058 */ FVector EndPos;
    /* 0x0070 */ FVector2D EndScale;
    /* 0x0080 */ FVector EndTangent;
    /* 0x0098 */ FVector2D EndOffset;
    /* 0x00a8 */ float NaniteClusterBoundsScale;
};

// Size: 0x28
class USplineMetadata : public UObject {
};

// Size: 0x88
struct FSplinePoint {
    /* 0x0000 */ float InputKey;
    /* 0x0008 */ FVector position;
    /* 0x0020 */ FVector ArriveTangent;
    /* 0x0038 */ FVector LeaveTangent;
    /* 0x0050 */ FRotator Rotation;
    /* 0x0068 */ FVector Scale;
    /* 0x0080 */ uint8_t Type;
};

// Size: 0x2c0
class ASpotLight : public ALight {
    /* 0x02b8 */ USpotLightComponent* SpotLightComponent;

    void SetInnerConeAngle(float NewInnerConeAngle);
    void SetOuterConeAngle(float NewOuterConeAngle);
};

// Size: 0x3e0
class USpotLightComponent : public UPointLightComponent {
    /* 0x03d0 */ float InnerConeAngle;
    /* 0x03d4 */ float OuterConeAngle;

    void SetInnerConeAngle(float NewInnerConeAngle);
    void SetOuterConeAngle(float NewOuterConeAngle);
};

// Size: 0x340
class USpringArmComponent : public USceneComponent {
    /* 0x0240 */ float TargetArmLength;
    /* 0x0248 */ FVector SocketOffset;
    /* 0x0260 */ FVector TargetOffset;
    /* 0x0278 */ float ProbeSize;
    /* 0x027c */ uint8_t ProbeChannel;
    /* 0x0280 */ bool bDoCollisionTest;
    /* 0x0280 */ bool bUsePawnControlRotation;
    /* 0x0280 */ bool bInheritPitch;
    /* 0x0280 */ bool bInheritYaw;
    /* 0x0280 */ bool bInheritRoll;
    /* 0x0280 */ bool bEnableCameraLag;
    /* 0x0280 */ bool bEnableCameraRotationLag;
    /* 0x0280 */ bool bUseCameraLagSubstepping;
    /* 0x0281 */ bool bDrawDebugLagMarkers;
    /* 0x0284 */ float CameraLagSpeed;
    /* 0x0288 */ float CameraRotationLagSpeed;
    /* 0x028c */ float CameraLagMaxTimeStep;
    /* 0x0290 */ float CameraLagMaxDistance;
    /* 0x0294 */ bool bClampToMaxPhysicsDeltaTime;

    FRotator GetTargetRotation() const;
    FVector GetUnfixedCameraPosition() const;
    bool IsCollisionFixApplied() const;
};

// Size: 0x28
struct FSpriteCategoryInfo {
    /* 0x0000 */ FName Category;
    /* 0x0008 */ FText DisplayName;
    /* 0x0018 */ FText Description;
};

// Size: 0x30
struct FStartPhysicsTickFunction : public FTickFunction {
};

// Size: 0x8
struct FStatColorMapEntry {
    /* 0x0000 */ float In;
    /* 0x0004 */ FColor Out;
};

// Size: 0x28
struct FStatColorMapping {
    /* 0x0000 */ FString StatName;
    /* 0x0010 */ TArray<FStatColorMapEntry> ColorMap;
    /* 0x0020 */ bool DisableBlend;
};

// Size: 0x150
struct FStateMachineDebugData {
};

// Size: 0x10
struct FStateMachineStateDebugData {
};

// Size: 0x28
struct FStaticComponentMaskParameter : public FStaticParameterBase {
    /* 0x0024 */ bool R;
    /* 0x0025 */ bool G;
    /* 0x0026 */ bool B;
    /* 0x0027 */ bool A;
};

// Size: 0x4
struct FStaticComponentMaskValue {
    /* 0x0000 */ bool R;
    /* 0x0001 */ bool G;
    /* 0x0002 */ bool B;
    /* 0x0003 */ bool A;
};

// Size: 0x38
struct FStaticMaterial {
    /* 0x0000 */ UMaterialInterface* MaterialInterface;
    /* 0x0008 */ FName MaterialSlotName;
    /* 0x0010 */ FName ImportedMaterialSlotName;
    /* 0x0018 */ FMeshUVChannelInfo UVChannelData;
    /* 0x0030 */ UMaterialInterface* OverlayMaterialInterface;
};

// Size: 0x160
struct FStaticMaterialLayersParameter : public FStaticParameterBase {
    /* 0x0028 */ FMaterialLayersFunctions Value;
};

// Size: 0x18
struct FStaticMaterialMinimalInfo {
};

// Size: 0x290
class UStaticMesh : public UStreamableRenderAsset {
    /* 0x00f0 */ FPerQualityLevelInt MinQualityLevelLOD;
    /* 0x0158 */ FPerPlatformInt MinLOD;
    /* 0x015c */ int32_t ElementToIgnoreForTexFactor;
    /* 0x0160 */ TArray<FStaticMaterial> StaticMaterials;
    /* 0x01a8 */ float LightmapUVDensity;
    /* 0x01ac */ int32_t LightMapResolution;
    /* 0x01b0 */ int32_t LightMapCoordinateIndex;
    /* 0x01b4 */ EStaticMeshPaintSupport StaticMeshPaintSupport;
    /* 0x01b8 */ int32_t MeshPaintTextureCoordinateIndex;
    /* 0x01bc */ int32_t MeshPaintTextureResolution;
    /* 0x01c0 */ float DistanceFieldSelfShadowBias;
    /* 0x01c8 */ UBodySetup* BodySetup;
    /* 0x01d0 */ int32_t LODForCollision;
    /* 0x01d4 */ bool bGenerateMeshDistanceField;
    /* 0x01d4 */ bool bStripComplexCollisionForConsole;
    /* 0x01d4 */ bool bHasNavigationData;
    /* 0x01d4 */ bool bSupportUniformlyDistributedSampling;
    /* 0x01d4 */ bool bSupportPhysicalMaterialMasks;
    /* 0x01d4 */ bool bSupportRayTracing;
    /* 0x01d4 */ bool bDoFastBuild;
    /* 0x01d4 */ bool bIsBuiltAtRuntime;
    /* 0x01d5 */ bool bAllowCPUAccess;
    /* 0x01d5 */ bool bSupportGpuUniformlyDistributedSampling;
    /* 0x01f0 */ TArray<UStaticMeshSocket*> Sockets;
    /* 0x0210 */ FVector PositiveBoundsExtension;
    /* 0x0228 */ FVector NegativeBoundsExtension;
    /* 0x0240 */ FBoxSphereBounds ExtendedBounds;
    /* 0x0278 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0288 */ UNavCollisionBase* NavCollision;

    FName AddMaterial(UMaterialInterface* Material);
    void AddSocket(UStaticMeshSocket* Socket);
    void BuildFromStaticMeshDescriptions(const TArray<UStaticMeshDescription*>& StaticMeshDescriptions, bool bBuildSimpleCollision, bool bFastBuild);
    static UStaticMeshDescription* CreateStaticMeshDescription(UObject* Outer);
    UStaticMeshSocket* FindSocket(FName InSocketName) const;
    FBox GetBoundingBox() const;
    FBoxSphereBounds GetBounds() const;
    UMaterialInterface* GetMaterial(int32_t MaterialIndex) const;
    int32_t GetMaterialIndex(FName MaterialSlotName) const;
    void GetMinLODForQualityLevels(TMap<EPerQualityLevels, int32_t>& QualityLevelMinimumLODs, int32_t& Default) const;
    int32_t GetMinimumLODForPlatform(const FName& PlatformName) const;
    void GetMinimumLODForPlatforms(TMap<FName, int32_t>& PlatformMinimumLODs) const;
    int32_t GetMinimumLODForQualityLevel(const FName& QualityLevel) const;
    void GetMinimumLODForQualityLevels(TMap<FName, int32_t>& QualityLevelMinimumLODs) const;
    int32_t GetNumLODs() const;
    int32_t GetNumSections(int32_t InLOD) const;
    int32_t GetNumTriangles(int32_t LODIndex) const;
    int32_t GetNumVertices(int32_t LODIndex) const;
    TArray<UStaticMeshSocket*> GetSocketsByTag(FString InSocketTag) const;
    TArray<FStaticMaterial> GetStaticMaterials() const;
    UStaticMeshDescription* GetStaticMeshDescription(int32_t LODIndex);
    void RemoveSocket(UStaticMeshSocket* Socket);
    void SetMinLODForQualityLevels(const TMap<EPerQualityLevels, int32_t>& QualityLevelMinimumLODs, int32_t Default);
    void SetMinimumLODForPlatform(const FName& PlatformName, int32_t InMinLOD);
    void SetMinimumLODForPlatforms(const TMap<FName, int32_t>& PlatformMinimumLODs);
    void SetStaticMaterials(const TArray<FStaticMaterial>& InStaticMaterials);
};

// Size: 0x2b8
class AStaticMeshActor : public AActor {
    /* 0x02a8 */ UStaticMeshComponent* StaticMeshComponent;
    /* 0x02b0 */ bool bStaticMeshReplicateMovement;
    /* 0x02b1 */ EPhysicsReplicationMode StaticMeshPhysicsReplicationMode;
    /* 0x02b2 */ ENavDataGatheringMode NavigationGeometryGatheringMode;

    void SetMobility(uint8_t InMobility);
};

// Size: 0x10
struct FStaticMeshBudgetInfo {
    /* 0x0000 */ FName LodGroupName;
    /* 0x0008 */ double MinimumExtent;
};

// Size: 0x610
class UStaticMeshComponent : public UMeshComponent {
    /* 0x0568 */ int32_t ForcedLodModel;
    /* 0x056c */ int32_t MinLOD;
    /* 0x0570 */ int32_t SubDivisionStepSize;
    /* 0x0574 */ FColor WireframeColorOverride;
    /* 0x0578 */ UStaticMesh* StaticMesh;
    /* 0x0580 */ int32_t WorldPositionOffsetDisableDistance;
    /* 0x0584 */ bool bForceNaniteForMasked;
    /* 0x0584 */ bool bDisallowNanite;
    /* 0x0584 */ bool bForceDisableNanite;
    /* 0x0584 */ bool bEvaluateWorldPositionOffset;
    /* 0x0584 */ bool bWorldPositionOffsetWritesVelocity;
    /* 0x0584 */ bool bEvaluateWorldPositionOffsetInRayTracing;
    /* 0x0585 */ bool bOverrideWireframeColor;
    /* 0x0585 */ bool bOverrideMinLOD;
    /* 0x0585 */ bool bOverrideNavigationExport;
    /* 0x0585 */ bool bForceNavigationObstacle;
    /* 0x0585 */ bool bDisallowMeshPaintPerInstance;
    /* 0x0585 */ bool bIgnoreInstanceForTextureStreaming;
    /* 0x0586 */ bool bOverrideLightMapRes;
    /* 0x0586 */ bool bCastDistanceFieldIndirectShadow;
    /* 0x0586 */ bool bOverrideDistanceFieldSelfShadowBias;
    /* 0x0586 */ bool bUseSubDivisions;
    /* 0x0586 */ bool bUseDefaultCollision;
    /* 0x0586 */ bool bSortTriangles;
    /* 0x0586 */ bool bReverseCulling;
    /* 0x0586 */ bool bEnableVertexColorMeshPainting;
    /* 0x0587 */ bool bEnableTextureColorMeshPainting;
    /* 0x0587 */ bool bOverrideMeshPaintTextureCoordinateIndex;
    /* 0x0587 */ bool bOverrideMeshPaintTextureResolution;
    /* 0x0588 */ int32_t OverriddenMeshPaintTextureCoordinateIndex;
    /* 0x058c */ int32_t OverriddenMeshPaintTextureResolution;
    /* 0x0590 */ int32_t OverriddenLightMapRes;
    /* 0x0598 */ UTexture* MeshPaintTextureCooked;
    /* 0x05a0 */ UTexture* MeshPaintTextureOverride;
    /* 0x05a8 */ UTexture* MaterialCacheTexture;
    /* 0x05b0 */ float DistanceFieldIndirectShadowMinVisibility;
    /* 0x05b4 */ float DistanceFieldSelfShadowBias;
    /* 0x05b8 */ float StreamingDistanceMultiplier;
    /* 0x05bc */ float NanitePixelProgrammableDistance;
    /* 0x05c0 */ TArray<FStaticMeshComponentLODInfo> LODData;
    /* 0x05d0 */ TArray<FStreamingTextureBuildInfo> StreamingTextureData;
    /* 0x05e0 */ FLightmassPrimitiveSettings LightmassSettings;

    bool GetInitialEvaluateWorldPositionOffset();
    void GetLocalBounds(FVector& min, FVector& max) const;
    void OnRep_StaticMesh(UStaticMesh* OldStaticMesh);
    void SetDistanceFieldSelfShadowBias(float NewValue);
    void SetEvaluateWorldPositionOffset(bool NewValue);
    void SetEvaluateWorldPositionOffsetInRayTracing(bool NewValue);
    void SetForceDisableNanite(bool bInForceDisableNanite);
    void SetForcedLodModel(int32_t NewForcedLodModel);
    void SetReverseCulling(bool ReverseCulling);
    bool SetStaticMesh(UStaticMesh* NewMesh);
    void SetWorldPositionOffsetDisableDistance(int32_t NewValue);
    void UpdateInitialEvaluateWorldPositionOffset();
};

// Size: 0x170
struct FStaticMeshComponentInstanceData : public FPrimitiveComponentInstanceData {
    /* 0x0130 */ UStaticMesh* StaticMesh;
    /* 0x0138 */ TArray<FStaticMeshVertexColorLODData> VertexColorLODs;
    /* 0x0148 */ TArray<FGuid> CachedStaticLighting;
    /* 0x0158 */ TArray<FStreamingTextureBuildInfo> StreamingTextureData;
};

// Size: 0x50
struct FStaticMeshComponentLODInfo {
};

// Size: 0x28
class UStaticMeshDescriptionBulkData : public UMeshDescriptionBaseBulkData {
};

// Size: 0x48
struct FStaticMeshDynamicState {
    /* 0x0008 */ FTransformHandle Transform;
    /* 0x0018 */ UStaticMesh* Mesh;
    /* 0x0020 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x0030 */ TArray<uint32_t> Owners;
    /* 0x0040 */ bool bOnlyOwnerSee;
    /* 0x0040 */ bool bOwnerNoSee;
};

// Size: 0x10
struct FStaticMeshHandle : public FStateStreamHandle {
};

// Size: 0x1c
struct FStaticMeshOptimizationSettings {
    /* 0x0000 */ uint8_t ReductionMethod;
    /* 0x0004 */ float NumOfTrianglesPercentage;
    /* 0x0008 */ float MaxDeviationPercentage;
    /* 0x000c */ float WeldingThreshold;
    /* 0x0010 */ bool bRecalcNormals;
    /* 0x0014 */ float NormalsThreshold;
    /* 0x0018 */ uint8_t SilhouetteImportance;
    /* 0x0019 */ uint8_t TextureImportance;
    /* 0x001a */ uint8_t ShadingImportance;
};

// Size: 0x88
class UStaticMeshSocket : public UObject {
    /* 0x0028 */ FName SocketName;
    /* 0x0030 */ FVector RelativeLocation;
    /* 0x0048 */ FRotator RelativeRotation;
    /* 0x0060 */ FVector RelativeScale;
    /* 0x0078 */ FString Tag;
};

// Size: 0x98
struct FStaticMeshSourceModel {
    /* 0x0000 */ FMeshBuildSettings BuildSettings;
    /* 0x0048 */ FMeshReductionSettings ReductionSettings;
    /* 0x0074 */ uint32_t CacheMeshDescriptionTrianglesCount;
    /* 0x0078 */ uint32_t CacheMeshDescriptionVerticesCount;
    /* 0x007c */ float LODDistance;
    /* 0x0080 */ FPerPlatformFloat ScreenSize;
    /* 0x0088 */ FString SourceImportFilename;
};

// Size: 0x4
struct FStaticMeshStaticState {
};

// Size: 0x28
struct FStaticMeshVertexColorLODData {
    /* 0x0000 */ TArray<FPaintedVertex> PaintedVertices;
    /* 0x0010 */ TArray<FColor> VertexBufferColors;
    /* 0x0020 */ uint32_t LODIndex;
};

// Size: 0x24
struct FStaticParameterBase {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ bool bOverride;
    /* 0x0014 */ FGuid ExpressionGUID;
};

// Size: 0x70
struct FStaticParameterSet : public FStaticParameterSetRuntimeData {
};

// Size: 0xa0
struct FStaticParameterSetEditorOnlyData {
    /* 0x0000 */ TArray<FStaticSwitchParameter> StaticSwitchParameters;
    /* 0x0010 */ TArray<FStaticComponentMaskParameter> StaticComponentMaskParameters;
    /* 0x0020 */ TArray<FStaticTerrainLayerWeightParameter> TerrainLayerWeightParameters;
    /* 0x0030 */ FMaterialLayersFunctionsEditorOnlyData MaterialLayers;
};

// Size: 0x70
struct FStaticParameterSetRuntimeData {
    /* 0x0000 */ TArray<FStaticSwitchParameter> StaticSwitchParameters;
    /* 0x0010 */ FMaterialLayersFunctionsRuntimeData MaterialLayers;
    /* 0x0068 */ bool bHasMaterialLayers;
};

// Size: 0xb0
class UStaticSparseVolumeTexture : public UStreamableSparseVolumeTexture {
};

// Size: 0x28
struct FStaticSwitchParameter : public FStaticParameterBase {
    /* 0x0024 */ bool Value;
};

// Size: 0x34
struct FStaticTerrainLayerWeightParameter {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ FGuid ExpressionGUID;
    /* 0x0020 */ bool bOverride;
    /* 0x0024 */ FName LayerName;
    /* 0x002c */ int32_t WeightmapIndex;
    /* 0x0030 */ bool bIsRepeatedLayer;
    /* 0x0031 */ bool bWeightBasedBlend;
};

// Size: 0x340
class UStereoLayerComponent : public USceneComponent {
    /* 0x0240 */ bool bLiveTexture;
    /* 0x0240 */ bool bSupportsDepth;
    /* 0x0240 */ bool bNoAlphaChannel;
    /* 0x0248 */ UTexture* Texture;
    /* 0x0250 */ UTexture* LeftTexture;
    /* 0x0258 */ bool bQuadPreserveTextureRatio;
    /* 0x0260 */ TArray<FName> AdditionalFlags;
    /* 0x0270 */ FVector2D QuadSize;
    /* 0x0280 */ FBox2D UVRect;
    /* 0x02a8 */ uint8_t StereoLayerType;
    /* 0x02b0 */ UStereoLayerShape* Shape;
    /* 0x02b8 */ int32_t Priority;

    UTexture* GetLeftTexture() const;
    int32_t GetPriority() const;
    FVector2D GetQuadSize() const;
    UTexture* GetTexture() const;
    FBox2D GetUVRect() const;
    void MarkTextureForUpdate();
    void SetEquirectProps(FEquirectProps InEquirectProps);
    void SetLeftTexture(UTexture* InTexture);
    void SetPriority(int32_t InPriority);
    void SetQuadSize(FVector2D InQuadSize);
    void SetTexture(UTexture* InTexture);
    void SetUVRect(FBox2D InUVRect);
};

// Size: 0x28
class UStereoLayerShape : public UObject {
};

// Size: 0x28
class UStereoLayerShapeCubemap : public UStereoLayerShape {
};

// Size: 0x38
class UStereoLayerShapeCylinder : public UStereoLayerShape {
    /* 0x0028 */ float Radius;
    /* 0x002c */ float OverlayArc;
    /* 0x0030 */ int32_t Height;

    void SetHeight(int32_t InHeight);
    void SetOverlayArc(float InOverlayArc);
    void SetRadius(float InRadius);
};

// Size: 0xc0
class UStereoLayerShapeEquirect : public UStereoLayerShape {
    /* 0x0028 */ FBox2D LeftUVRect;
    /* 0x0050 */ FBox2D RightUVRect;
    /* 0x0078 */ FVector2D LeftScale;
    /* 0x0088 */ FVector2D RightScale;
    /* 0x0098 */ FVector2D LeftBias;
    /* 0x00a8 */ FVector2D RightBias;
    /* 0x00b8 */ float Radius;

    void SetEquirectProps(FEquirectProps InScaleBiases);
};

// Size: 0x28
class UStereoLayerShapeQuad : public UStereoLayerShape {
};

// Size: 0xd0
class UStreamableRenderAsset : public UObject {
    /* 0x0040 */ double ForceMipLevelsToBeResidentTimestamp;
    /* 0x0048 */ int32_t NumCinematicMipLevels;
    /* 0x0050 */ FPerQualityLevelInt NoRefStreamingLODBias;
    /* 0x00b8 */ int32_t StreamingIndex;
    /* 0x00c0 */ bool NeverStream;
    /* 0x00c0 */ bool bGlobalForceMipLevelsToBeResident;
    /* 0x00c0 */ bool bHasStreamingUpdatePending;
    /* 0x00c0 */ bool bForceMiplevelsToBeResident;
    /* 0x00c0 */ bool bIgnoreStreamingMipBias;
    /* 0x00c0 */ bool bMarkAsEditorStreamingPool;
    /* 0x00c0 */ bool bUseCinematicMipLevels;

    void SetForceMipLevelsToBeResident(float Seconds, int32_t CinematicLODGroupMask);
};

// Size: 0xb0
class UStreamableSparseVolumeTexture : public USparseVolumeTexture {
    /* 0x0030 */ FIntVector VolumeResolution;
    /* 0x003c */ int32_t NumMipLevels;
    /* 0x0040 */ int32_t NumFrames;
    /* 0x0044 */ uint8_t FormatA;
    /* 0x0045 */ uint8_t FormatB;
    /* 0x0050 */ FVector4f FallbackValueA;
    /* 0x0060 */ FVector4f FallbackValueB;
    /* 0x0070 */ uint8_t AddressX;
    /* 0x0071 */ uint8_t AddressY;
    /* 0x0072 */ uint8_t AddressZ;
    /* 0x0073 */ bool bLocalDDCOnly;
    /* 0x0074 */ float StreamingPoolSizeFactor;
    /* 0x0078 */ int32_t NumberOfPrefetchFrames;
    /* 0x007c */ float PrefetchPercentageStepSize;
    /* 0x0080 */ float PrefetchPercentageBias;
    /* 0x0088 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0098 */ TArray<USparseVolumeTextureFrame*> Frames;
};

// Size: 0x1
struct FStreamableTexture {
};

// Size: 0x48
struct FStreamableTextureInstance {
};

// Size: 0x18
struct FStreamedAudioPlatformData {
};

// Size: 0x28
struct FStreamingLevelsToConsider {
    /* 0x0000 */ TArray<ULevelStreaming*> StreamingLevels;
};

// Size: 0x50
struct FStreamingRenderAssetPrimitiveInfo {
    /* 0x0000 */ UStreamableRenderAsset* RenderAsset;
    /* 0x0008 */ FBoxSphereBounds Bounds;
    /* 0x0040 */ float TexelFactor;
    /* 0x0044 */ uint32_t PackedRelativeBox;
    /* 0x0048 */ bool bAllowInvalidTexelFactorWhenUnregistered;
    /* 0x0048 */ bool bAffectedByComponentScale;
};

// Size: 0x70
class UStreamingSettings : public UDeveloperSettings {
    /* 0x0038 */ bool AsyncLoadingThreadEnabled;
    /* 0x0038 */ bool WarnIfTimeLimitExceeded;
    /* 0x003c */ float TimeLimitExceededMultiplier;
    /* 0x0040 */ float TimeLimitExceededMinTime;
    /* 0x0044 */ int32_t MinBulkDataSizeForAsyncLoading;
    /* 0x0048 */ bool UseBackgroundLevelStreaming;
    /* 0x0048 */ bool AsyncLoadingUseFullTimeLimit;
    /* 0x004c */ float AsyncLoadingTimeLimit;
    /* 0x0050 */ float PriorityAsyncLoadingExtraTime;
    /* 0x0054 */ float LevelStreamingActorsUpdateTimeLimit;
    /* 0x0058 */ float PriorityLevelStreamingActorsUpdateExtraTime;
    /* 0x005c */ int32_t LevelStreamingComponentsRegistrationGranularity;
    /* 0x0060 */ int32_t LevelStreamingAddPrimitiveGranularity;
    /* 0x0064 */ float LevelStreamingUnregisterComponentsTimeLimit;
    /* 0x0068 */ int32_t LevelStreamingComponentsUnregistrationGranularity;
    /* 0x006c */ bool FlushStreamingOnExit;
    /* 0x006c */ bool EventDrivenLoaderEnabled;
};

// Size: 0x48
struct FStreamingSourceShape {
    /* 0x0000 */ bool bUseGridLoadingRange;
    /* 0x0004 */ float LoadingRangeScale;
    /* 0x0008 */ float Radius;
    /* 0x000c */ bool bIsSector;
    /* 0x0010 */ float SectorAngle;
    /* 0x0018 */ FVector Location;
    /* 0x0030 */ FRotator Rotation;
};

// Size: 0xc
struct FStreamingTextureBuildInfo {
    /* 0x0000 */ uint32_t PackedRelativeBox;
    /* 0x0004 */ int32_t TextureLevelIndex;
    /* 0x0008 */ float TexelFactor;
};

// Size: 0x28
class IStreamingWorldSubsystemInterface : public UInterface {
};

// Size: 0x10
struct FStringAnimationAttribute {
    /* 0x0000 */ FString Value;
};

// Size: 0x88
struct FStringCurve : public FIndexedCurve {
    /* 0x0068 */ FString DefaultValue;
    /* 0x0078 */ TArray<FStringCurveKey> Keys;
};

// Size: 0x18
struct FStringCurveKey {
    /* 0x0000 */ float Time;
    /* 0x0008 */ FString Value;
};

// Size: 0x40
class UStringTable : public UObject {
};

// Size: 0x10
struct FStructRedirect {
    /* 0x0000 */ FName OldStructName;
    /* 0x0008 */ FName NewStructName;
};

// Size: 0x1
struct FSubObjectPropertyOverride {
};

// Size: 0x60
class USubUVAnimation : public UObject {
    /* 0x0028 */ UTexture2D* SubUVTexture;
    /* 0x0030 */ int32_t SubImages_Horizontal;
    /* 0x0034 */ int32_t SubImages_Vertical;
    /* 0x0038 */ uint8_t BoundingMode;
    /* 0x0039 */ uint8_t OpacitySourceMode;
    /* 0x003c */ float AlphaThreshold;
};

// Size: 0x28
struct FSubstrateMaterialInput : public FMaterialInput {
};

// Size: 0xd8
class USubsurfaceProfile : public UObject {
    /* 0x0028 */ FSubsurfaceProfileStruct Settings;
    /* 0x00c8 */ FGuid Guid;
};

// Size: 0xa0
struct FSubsurfaceProfileStruct {
    /* 0x0000 */ FLinearColor SurfaceAlbedo;
    /* 0x0010 */ FLinearColor MeanFreePathColor;
    /* 0x0020 */ float MeanFreePathDistance;
    /* 0x0024 */ float WorldUnitScale;
    /* 0x0028 */ bool bEnableBurley;
    /* 0x0029 */ bool bEnableMeanFreePath;
    /* 0x002c */ FLinearColor Tint;
    /* 0x003c */ float ScatterRadius;
    /* 0x0040 */ FLinearColor SubsurfaceColor;
    /* 0x0050 */ FLinearColor FalloffColor;
    /* 0x0060 */ FLinearColor BoundaryColorBleed;
    /* 0x0070 */ ESubsurfaceImplementationTechniqueHint Implementation;
    /* 0x0074 */ float ExtinctionScale;
    /* 0x0078 */ float NormalScale;
    /* 0x007c */ float ScatteringDistribution;
    /* 0x0080 */ float IOR;
    /* 0x0084 */ float Roughness0;
    /* 0x0088 */ float Roughness1;
    /* 0x008c */ float LobeMix;
    /* 0x0090 */ FLinearColor TransmissionTintColor;
};

// Size: 0x30
class USubsystem : public UObject {
};

// Size: 0x28
class USubsystemBlueprintLibrary : public UBlueprintFunctionLibrary {

    static UAudioEngineSubsystem* GetAudioEngineSubsystem(UObject* ContextObject, UClass* Class);
    static UEngineSubsystem* GetEngineSubsystem(UClass* Class);
    static UGameInstanceSubsystem* GetGameInstanceSubsystem(UObject* ContextObject, UClass* Class);
    static ULocalPlayerSubsystem* GetLocalPlayerSubSystemFromPlayerController(APlayerController* PlayerController, UClass* Class);
    static ULocalPlayerSubsystem* GetLocalPlayerSubsystem(UObject* ContextObject, UClass* Class);
    static UWorldSubsystem* GetWorldSubsystem(UObject* ContextObject, UClass* Class);
};

// Size: 0x48
class USubtitleAssetUserData : public UAssetUserData {
    /* 0x0028 */ FText Text;
    /* 0x0038 */ float Duration;
    /* 0x003c */ float StartOffset;
    /* 0x0040 */ float Priority;
    /* 0x0044 */ ESRB ESRB;
    /* 0x0045 */ ESubtitleType SubtitleType;
};

// Size: 0x18
struct FSubtitleCue {
    /* 0x0000 */ FText Text;
    /* 0x0010 */ float Time;
};

// Size: 0x4
struct FSwarmDebugOptions {
    /* 0x0000 */ bool bDistributionEnabled;
    /* 0x0000 */ bool bForceContentExport;
    /* 0x0000 */ bool bInitialized;
};

// Size: 0x30
struct FSwitchCustomInput {
    /* 0x0000 */ FName InputName;
    /* 0x0008 */ FExpressionInput Input;
};

// Size: 0x28
struct FSyncPointDescription {
    /* 0x0000 */ FName RegisteredName;
    /* 0x0010 */ ESyncPointEventType EventType;
    /* 0x0011 */ ESyncPointActivationRules ActivationRules;
    /* 0x0012 */ uint8_t FirstPossibleTickGroup;
    /* 0x0013 */ uint8_t LastPossibleTickGroup;
    /* 0x0018 */ TArray<FName> PrerequisiteSyncGroups;
};

// Size: 0x40
class USystemTimeTimecodeProvider : public UTimecodeProvider {
    /* 0x0030 */ FFrameRate FrameRate;
    /* 0x0038 */ bool bGenerateFullFrame;
    /* 0x0039 */ bool bUseHighPerformanceClock;
};

// Size: 0x28
struct FTTEventTrack : public FTTTrackBase {
    /* 0x0018 */ FName FunctionName;
    /* 0x0020 */ UCurveFloat* CurveKeys;
};

// Size: 0x28
struct FTTFloatTrack : public FTTPropertyTrack {
    /* 0x0020 */ UCurveFloat* CurveFloat;
};

// Size: 0x28
struct FTTLinearColorTrack : public FTTPropertyTrack {
    /* 0x0020 */ UCurveLinearColor* CurveLinearColor;
};

// Size: 0x20
struct FTTPropertyTrack : public FTTTrackBase {
    /* 0x0018 */ FName PropertyName;
};

// Size: 0x18
struct FTTTrackBase {
    /* 0x0008 */ FName TrackName;
    /* 0x0010 */ bool bIsExternalCurve;
};

// Size: 0x8
struct FTTTrackId {
    /* 0x0000 */ int32_t TrackType;
    /* 0x0004 */ int32_t TrackIndex;
};

// Size: 0x28
struct FTTVectorTrack : public FTTPropertyTrack {
    /* 0x0020 */ UCurveVector* CurveVector;
};

// Size: 0x8e0
struct FTViewTarget {
    /* 0x0000 */ AActor* Target;
    /* 0x0010 */ FMinimalViewInfo POV;
    /* 0x08d0 */ APlayerState* PlayerState;
};

// Size: 0x8
struct FTableRowBase {
};

// Size: 0x2a8
class ATargetPoint : public AActor {
};

// Size: 0x48
class UTaskSyncManagerSettings : public UDeveloperSettings {
    /* 0x0038 */ TArray<FSyncPointDescription> RegisteredSyncPoints;
};

// Size: 0xc
struct FTentDistribution {
    /* 0x0000 */ float TipAltitude;
    /* 0x0004 */ float TipValue;
    /* 0x0008 */ float Width;
};

// Size: 0x40
class UTextImportContainer : public UObject {
    /* 0x0028 */ FTextImportTestStruct ResultStruct;
};

// Size: 0x18
struct FTextImportTestStruct {
    /* 0x0000 */ ETextImportTestFlags EmbeddedFlags;
    /* 0x0004 */ int32_t TestInt;
    /* 0x0008 */ FString TestString;
};

// Size: 0x58
class UTextPropertyTestObject : public UObject {
    /* 0x0028 */ FText DefaultedText;
    /* 0x0038 */ FText UndefaultedText;
    /* 0x0048 */ FText TransientText;
};

// Size: 0x2b0
class ATextRenderActor : public AActor {
    /* 0x02a8 */ UTextRenderComponent* TextRender;
};

// Size: 0x570
class UTextRenderComponent : public UPrimitiveComponent {
    /* 0x0520 */ FText Text;
    /* 0x0530 */ UMaterialInterface* TextMaterial;
    /* 0x0538 */ UFont* Font;
    /* 0x0540 */ uint8_t HorizontalAlignment;
    /* 0x0541 */ uint8_t VerticalAlignment;
    /* 0x0544 */ FColor TextRenderColor;
    /* 0x0548 */ float XScale;
    /* 0x054c */ float YScale;
    /* 0x0550 */ float WorldSize;
    /* 0x0554 */ float InvDefaultSize;
    /* 0x0558 */ float HorizSpacingAdjust;
    /* 0x055c */ float VertSpacingAdjust;
    /* 0x0560 */ bool bAlwaysRenderAsText;

    FVector GetTextLocalSize() const;
    FVector GetTextWorldSize() const;
    void K2_SetText(const FText& Value);
    void SetFont(UFont* Value);
    void SetHorizSpacingAdjust(float Value);
    void SetHorizontalAlignment(uint8_t Value);
    void SetText(const FText& Value);
    void SetTextMaterial(UMaterialInterface* Material);
    void SetTextRenderColor(FColor Value);
    void SetVertSpacingAdjust(float Value);
    void SetVerticalAlignment(uint8_t Value);
    void SetWorldSize(float Value);
    void SetXScale(float Value);
    void SetYScale(float Value);
};

// Size: 0x38
struct FTextSizingParameters {
    /* 0x0000 */ float DrawX;
    /* 0x0004 */ float DrawY;
    /* 0x0008 */ float DrawXL;
    /* 0x000c */ float DrawYL;
    /* 0x0010 */ FVector2D Scaling;
    /* 0x0020 */ UFont* DrawFont;
    /* 0x0028 */ FVector2D SpacingAdjust;
};

// Size: 0x140
class UTexture : public UStreamableRenderAsset {
    /* 0x00e0 */ FGuid LightingGuid;
    /* 0x00f0 */ int32_t LevelIndex;
    /* 0x00f4 */ int32_t LODBias;
    /* 0x00f8 */ uint8_t CompressionSettings;
    /* 0x00f9 */ uint8_t Filter;
    /* 0x00fa */ ETextureMipLoadOptions MipLoadOptions;
    /* 0x00fb */ EVTProducerPriority VirtualTextureStreamingPriority;
    /* 0x00fc */ uint8_t VirtualTexturePrefetchMips;
    /* 0x00fd */ uint8_t CookPlatformTilingSettings;
    /* 0x00fe */ bool bOodlePreserveExtremes;
    /* 0x00ff */ uint8_t LODGroup;
    /* 0x0100 */ FPerPlatformFloat Downscale;
    /* 0x0104 */ ETextureDownscaleOptions DownscaleOptions;
    /* 0x0105 */ ETextureAvailability Availability;
    /* 0x0106 */ bool SRGB;
    /* 0x0106 */ bool bNoTiling;
    /* 0x0106 */ bool VirtualTextureStreaming;
    /* 0x0108 */ bool bUseVirtualTextureStreamingPriority;
    /* 0x010c */ bool CompressionYCoCg;
    /* 0x010c */ bool bNotOfflineProcessed;
    /* 0x010c */ bool bAsyncResourceReleaseHasBeenStarted;
    /* 0x0110 */ TArray<UAssetUserData*> AssetUserData;

    bool AreDownscalePropertiesEditable() const;
    FVector3f Blueprint_GetBuiltTextureSize();
    int64_t Blueprint_GetMemorySize() const;
    void Blueprint_GetTextureSourceDiskAndMemorySize(int64_t& OutDiskSize, int64_t& OutMemorySize) const;
    bool Blueprint_GetTextureSourceIdString(FString& OutTextureSourceId);
    bool ComputeTextureSourceChannelMinMax(FLinearColor& OutColorMin, FLinearColor& OutColorMax) const;
};

// Size: 0x160
class UTexture2D : public UTexture {
    /* 0x0140 */ int32_t FirstResourceMemMip;
    /* 0x0144 */ bool bTemporarilyDisableStreaming;
    /* 0x0145 */ uint8_t AddressX;
    /* 0x0146 */ uint8_t AddressY;
    /* 0x0148 */ FIntPoint ImportedSize;

    FSharedImageConstRefBlueprint Blueprint_GetCPUCopy() const;
    int32_t Blueprint_GetSizeX() const;
    int32_t Blueprint_GetSizeY() const;
};

// Size: 0x150
class UTexture2DArray : public UTexture {
    /* 0x0148 */ uint8_t AddressX;
    /* 0x0149 */ uint8_t AddressY;
    /* 0x014a */ uint8_t AddressZ;
};

// Size: 0x158
class UTexture2DDynamic : public UTexture {
    /* 0x0148 */ uint8_t Format;
};

enum class TextureAddress {
    TA_Wrap = 0,
    TA_Clamp = 1,
    TA_Mirror = 2,
    TA_MAX = 3,
};

// Size: 0x28
class UTextureAllMipDataProviderFactory : public UTextureMipDataProviderFactory {
};

// Size: 0x50
class UTextureCollection : public UDataAsset {
    /* 0x0030 */ TArray<UTexture*> Textures;
};

// Size: 0x28
struct FTextureCollectionParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ UTextureCollection* ParameterValue;
    /* 0x0018 */ FGuid ExpressionGUID;
};

enum class TextureCompressionSettings {
    TC_Default = 0,
    TC_Normalmap = 1,
    TC_Masks = 2,
    TC_Grayscale = 3,
    TC_Displacementmap = 4,
    TC_VectorDisplacementmap = 5,
    TC_HDR = 6,
    TC_EditorIcon = 7,
    TC_Alpha = 8,
    TC_DistanceFieldFont = 9,
    TC_HDR_Compressed = 10,
    TC_BC7 = 11,
    TC_HalfFloat = 12,
    TC_LQ = 13,
    TC_EncodedReflectionCapture = 14,
    TC_SingleFloat = 15,
    TC_HDR_F32 = 16,
    TC_MAX = 17,
};

enum class TextureCookPlatformTilingSettings {
    TCPTS_FromTextureGroup = 0,
    TCPTS_Tile = 1,
    TCPTS_DoNotTile = 2,
    TCPTS_MAX = 3,
};

// Size: 0x148
class UTextureCube : public UTexture {
};

// Size: 0x148
class UTextureCubeArray : public UTexture {
};

// Size: 0x50
class UTextureEncodingProjectSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bSharedLinearTextureEncoding;
    /* 0x0038 */ bool bFinalUsesRDO;
    /* 0x003c */ int8_t FinalRDOLambda;
    /* 0x003d */ ETextureEncodeEffort FinalEffortLevel;
    /* 0x003e */ ETextureUniversalTiling FinalUniversalTiling;
    /* 0x0040 */ bool bFastUsesRDO;
    /* 0x0044 */ int8_t FastRDOLambda;
    /* 0x0045 */ ETextureEncodeEffort FastEffortLevel;
    /* 0x0046 */ ETextureUniversalTiling FastUniversalTiling;
    /* 0x0047 */ ETextureEncodeSpeed CookUsesSpeed;
    /* 0x0048 */ ETextureEncodeSpeed EditorUsesSpeed;
};

// Size: 0x40
class UTextureEncodingUserSettings : public UDeveloperSettings {
    /* 0x0038 */ ETextureEncodeSpeedOverride ForceEncodeSpeed;
};

enum class TextureFilter {
    TF_Nearest = 0,
    TF_Bilinear = 1,
    TF_Trilinear = 2,
    TF_Default = 3,
    TF_MAX = 4,
};

// Size: 0x2
struct FTextureFormatSettings {
    /* 0x0000 */ uint8_t CompressionSettings;
    /* 0x0001 */ bool CompressionNoAlpha;
    /* 0x0001 */ bool CompressionForceAlpha;
    /* 0x0001 */ bool CompressionNone;
    /* 0x0001 */ bool CompressionYCoCg;
    /* 0x0001 */ bool SRGB;
};

enum class TextureGroup {
    TEXTUREGROUP_World = 0,
    TEXTUREGROUP_WorldNormalMap = 1,
    TEXTUREGROUP_WorldSpecular = 2,
    TEXTUREGROUP_Character = 3,
    TEXTUREGROUP_CharacterNormalMap = 4,
    TEXTUREGROUP_CharacterSpecular = 5,
    TEXTUREGROUP_Weapon = 6,
    TEXTUREGROUP_WeaponNormalMap = 7,
    TEXTUREGROUP_WeaponSpecular = 8,
    TEXTUREGROUP_Vehicle = 9,
    TEXTUREGROUP_VehicleNormalMap = 10,
    TEXTUREGROUP_VehicleSpecular = 11,
    TEXTUREGROUP_Cinematic = 12,
    TEXTUREGROUP_Effects = 13,
    TEXTUREGROUP_EffectsNotFiltered = 14,
    TEXTUREGROUP_Skybox = 15,
    TEXTUREGROUP_UI = 16,
    TEXTUREGROUP_Lightmap = 17,
    TEXTUREGROUP_RenderTarget = 18,
    TEXTUREGROUP_MobileFlattened = 19,
    TEXTUREGROUP_ProcBuilding_Face = 20,
    TEXTUREGROUP_ProcBuilding_LightMap = 21,
    TEXTUREGROUP_Shadowmap = 22,
    TEXTUREGROUP_ColorLookupTable = 23,
    TEXTUREGROUP_Terrain_Heightmap = 24,
    TEXTUREGROUP_Terrain_Weightmap = 25,
    TEXTUREGROUP_Bokeh = 26,
    TEXTUREGROUP_IESLightProfile = 27,
    TEXTUREGROUP_Pixels2D = 28,
    TEXTUREGROUP_HierarchicalLOD = 29,
    TEXTUREGROUP_Impostor = 30,
    TEXTUREGROUP_ImpostorNormalDepth = 31,
    TEXTUREGROUP_8BitData = 32,
    TEXTUREGROUP_16BitData = 33,
    TEXTUREGROUP_Project01 = 34,
    TEXTUREGROUP_Project02 = 35,
    TEXTUREGROUP_Project03 = 36,
    TEXTUREGROUP_Project04 = 37,
    TEXTUREGROUP_Project05 = 38,
    TEXTUREGROUP_Project06 = 39,
    TEXTUREGROUP_Project07 = 40,
    TEXTUREGROUP_Project08 = 41,
    TEXTUREGROUP_Project09 = 42,
    TEXTUREGROUP_Project10 = 43,
    TEXTUREGROUP_Project11 = 44,
    TEXTUREGROUP_Project12 = 45,
    TEXTUREGROUP_Project13 = 46,
    TEXTUREGROUP_Project14 = 47,
    TEXTUREGROUP_Project15 = 48,
    TEXTUREGROUP_Project16 = 49,
    TEXTUREGROUP_Project17 = 50,
    TEXTUREGROUP_Project18 = 51,
    TEXTUREGROUP_Project19 = 52,
    TEXTUREGROUP_Project20 = 53,
    TEXTUREGROUP_Project21 = 54,
    TEXTUREGROUP_Project22 = 55,
    TEXTUREGROUP_Project23 = 56,
    TEXTUREGROUP_Project24 = 57,
    TEXTUREGROUP_Project25 = 58,
    TEXTUREGROUP_Project26 = 59,
    TEXTUREGROUP_Project27 = 60,
    TEXTUREGROUP_Project28 = 61,
    TEXTUREGROUP_Project29 = 62,
    TEXTUREGROUP_Project30 = 63,
    TEXTUREGROUP_Project31 = 64,
    TEXTUREGROUP_Project32 = 65,
    TEXTUREGROUP_MAX = 66,
};

// Size: 0x60
struct FTextureLODGroup {
    /* 0x0000 */ uint8_t Group;
    /* 0x0002 */ uint8_t MipGenSettings;
    /* 0x0003 */ ETextureMipLoadOptions MipLoadOptions;
    /* 0x0008 */ int32_t LODBias;
    /* 0x000c */ int32_t LODBias_Smaller;
    /* 0x0010 */ int32_t LODBias_Smallest;
    /* 0x0014 */ int32_t LODBias_VT;
    /* 0x0018 */ int32_t NumStreamedMips;
    /* 0x001c */ int32_t MinLODSize;
    /* 0x0020 */ int32_t MaxLODSize;
    /* 0x0024 */ int32_t MaxLODSize_Smaller;
    /* 0x0028 */ int32_t MaxLODSize_Smallest;
    /* 0x002c */ int32_t MaxLODSize_VT;
    /* 0x0030 */ int32_t OptionalLODBias;
    /* 0x0034 */ int32_t OptionalMaxLODSize;
    /* 0x0038 */ FName MinMagFilter;
    /* 0x0040 */ FName MipFilter;
    /* 0x0048 */ bool HighPriorityLoad;
    /* 0x0048 */ bool DuplicateNonOptionalMips;
    /* 0x0048 */ bool CookPlatformTilingDisabled;
    /* 0x0049 */ ETextureDownscaleOptions DownscaleOptions;
    /* 0x004a */ uint8_t LossyCompressionAmount;
    /* 0x004c */ float Downscale;
    /* 0x0050 */ int32_t VirtualTextureTileCountBias;
    /* 0x0054 */ int32_t VirtualTextureTileSizeBias;
    /* 0x0058 */ EVTProducerPriority VirtualTextureStreamingPriority;
    /* 0x005c */ int32_t MaxAniso;
};

// Size: 0x38
class UTextureLODSettings : public UObject {
    /* 0x0028 */ TArray<FTextureLODGroup> TextureLODGroups;
};

// Size: 0x168
class UTextureLightProfile : public UTexture2D {
    /* 0x0160 */ float Brightness;
    /* 0x0164 */ float TextureMultiplier;
};

// Size: 0x28
class UTextureMipDataProviderFactory : public UAssetUserData {
};

enum class TextureMipGenSettings {
    TMGS_FromTextureGroup = 0,
    TMGS_SimpleAverage = 1,
    TMGS_Sharpen0 = 2,
    TMGS_Sharpen1 = 3,
    TMGS_Sharpen2 = 4,
    TMGS_Sharpen3 = 5,
    TMGS_Sharpen4 = 6,
    TMGS_Sharpen5 = 7,
    TMGS_Sharpen6 = 8,
    TMGS_Sharpen7 = 9,
    TMGS_Sharpen8 = 10,
    TMGS_Sharpen9 = 11,
    TMGS_Sharpen10 = 12,
    TMGS_NoMipmaps = 13,
    TMGS_LeaveExistingMips = 14,
    TMGS_Blur1 = 15,
    TMGS_Blur2 = 16,
    TMGS_Blur3 = 17,
    TMGS_Blur4 = 18,
    TMGS_Blur5 = 19,
    TMGS_Unfiltered = 20,
    TMGS_Angular = 21,
    TMGS_MAX = 22,
};

// Size: 0x28
struct FTextureParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ UTexture* ParameterValue;
    /* 0x0018 */ FGuid ExpressionGUID;
};

// Size: 0x38
struct FTexturePlatformData {
};

// Size: 0x148
class UTextureRenderTarget : public UTexture {
    /* 0x0140 */ float TargetGamma;
};

// Size: 0x170
class UTextureRenderTarget2D : public UTextureRenderTarget {
    /* 0x0148 */ int32_t SizeX;
    /* 0x014c */ int32_t SizeY;
    /* 0x0150 */ FLinearColor ClearColor;
    /* 0x0160 */ uint8_t AddressX;
    /* 0x0161 */ uint8_t AddressY;
    /* 0x0162 */ bool bForceLinearGamma;
    /* 0x0162 */ bool bHDR;
    /* 0x0162 */ bool bGPUSharedFlag;
    /* 0x0163 */ uint8_t RenderTargetFormat;
    /* 0x0164 */ bool bSupportsUAV;
    /* 0x0164 */ bool bAutoGenerateMips;
    /* 0x0165 */ uint8_t MipsSamplerFilter;
    /* 0x0166 */ uint8_t MipsAddressU;
    /* 0x0167 */ uint8_t MipsAddressV;
    /* 0x0168 */ uint8_t OverrideFormat;
};

// Size: 0x168
class UTextureRenderTarget2DArray : public UTextureRenderTarget {
    /* 0x0148 */ int32_t SizeX;
    /* 0x014c */ int32_t SizeY;
    /* 0x0150 */ int32_t Slices;
    /* 0x0154 */ FLinearColor ClearColor;
    /* 0x0164 */ uint8_t OverrideFormat;
    /* 0x0165 */ bool bHDR;
    /* 0x0165 */ bool bSupportsUAV;
    /* 0x0165 */ bool bForceLinearGamma;
};

// Size: 0x168
class UTextureRenderTargetCube : public UTextureRenderTarget {
    /* 0x0148 */ int32_t SizeX;
    /* 0x014c */ FLinearColor ClearColor;
    /* 0x015c */ uint8_t OverrideFormat;
    /* 0x015d */ bool bHDR;
    /* 0x015d */ bool bSupportsUAV;
    /* 0x015d */ bool bForceLinearGamma;
    /* 0x015d */ bool bAutoGenerateMips;
    /* 0x015e */ uint8_t MipsSamplerFilter;
};

// Size: 0x168
class UTextureRenderTargetVolume : public UTextureRenderTarget {
    /* 0x0148 */ int32_t SizeX;
    /* 0x014c */ int32_t SizeY;
    /* 0x0150 */ int32_t SizeZ;
    /* 0x0154 */ FLinearColor ClearColor;
    /* 0x0164 */ uint8_t OverrideFormat;
    /* 0x0165 */ bool bHDR;
    /* 0x0165 */ bool bSupportsUAV;
    /* 0x0165 */ bool bForceLinearGamma;
};

// Size: 0x20
struct FTextureSamplingInfo {
    /* 0x0008 */ UTexture* Texture;
};

// Size: 0x70
struct FTextureSource {
};

// Size: 0x18
struct FTextureSourceBlock {
    /* 0x0000 */ int32_t BlockX;
    /* 0x0004 */ int32_t BlockY;
    /* 0x0008 */ int32_t SizeX;
    /* 0x000c */ int32_t SizeY;
    /* 0x0010 */ int32_t NumSlices;
    /* 0x0014 */ int32_t NumMips;
};

// Size: 0x50
struct FTextureSourceColorSettings {
    /* 0x0000 */ ETextureSourceEncoding EncodingOverride;
    /* 0x0001 */ ETextureColorSpace ColorSpace;
    /* 0x0008 */ FVector2D RedChromaticityCoordinate;
    /* 0x0018 */ FVector2D GreenChromaticityCoordinate;
    /* 0x0028 */ FVector2D BlueChromaticityCoordinate;
    /* 0x0038 */ FVector2D WhiteChromaticityCoordinate;
    /* 0x0048 */ ETextureChromaticAdaptationMethod ChromaticAdaptationMethod;
};

// Size: 0x20
struct FTextureSourceLayerColorInfo {
    /* 0x0000 */ FLinearColor ColorMin;
    /* 0x0010 */ FLinearColor ColorMax;
};

// Size: 0x28
class UThumbnailInfo : public UObject {
};

// Size: 0x28
struct FTickFunction {
    /* 0x0008 */ uint8_t TickGroup;
    /* 0x0009 */ uint8_t EndTickGroup;
    /* 0x000a */ bool bTickEvenWhenPaused;
    /* 0x000a */ bool bCanEverTick;
    /* 0x000a */ bool bStartWithTickEnabled;
    /* 0x000a */ bool bAllowTickOnDedicatedServer;
    /* 0x000c */ float TickInterval;
};

// Size: 0x10
struct FTickPrerequisite {
};

// Size: 0x40
class UTickableWorldSubsystem : public UWorldSubsystem {
};

// Size: 0x28
struct FTimeStretchCurve {
    /* 0x0000 */ float SamplingRate;
    /* 0x0004 */ float CurveValueMinPrecision;
    /* 0x0008 */ TArray<FTimeStretchCurveMarker> Markers;
    /* 0x0018 */ float Sum_dT_i_by_C_i[3];
};

// Size: 0x30
struct FTimeStretchCurveInstance {
    /* 0x0000 */ bool bHasValidData;
};

// Size: 0x10
struct FTimeStretchCurveMarker {
    /* 0x0000 */ float Time[3];
    /* 0x000c */ float Alpha;
};

// Size: 0x38
struct FTimecodeCustomAttributeNameSettings {
    /* 0x0000 */ FName HourAttributeName;
    /* 0x0008 */ FName MinuteAttributeName;
    /* 0x0010 */ FName SecondAttributeName;
    /* 0x0018 */ FName FrameAttributeName;
    /* 0x0020 */ FName SubframeAttributeName;
    /* 0x0028 */ FName RateAttributeName;
    /* 0x0030 */ FName TakenameAttributeName;
};

// Size: 0x30
class UTimecodeProvider : public UObject {
    /* 0x0028 */ float FrameDelay;

    void FetchAndUpdate();
    bool FetchTimecode(FQualifiedFrameTime& OutFrameTime);
    FQualifiedFrameTime GetDelayedQualifiedFrameTime() const;
    FTimecode GetDelayedTimecode() const;
    FFrameRate GetFrameRate() const;
    FQualifiedFrameTime GetQualifiedFrameTime() const;
    ETimecodeProviderSynchronizationState GetSynchronizationState() const;
    FTimecode GetTimecode() const;
};

// Size: 0x98
struct FTimeline {
    /* 0x0000 */ uint8_t LengthMode;
    /* 0x0001 */ bool bLooping;
    /* 0x0001 */ bool bReversePlayback;
    /* 0x0001 */ bool bPlaying;
    /* 0x0002 */ uint8_t PlayingStateTracker;
    /* 0x0004 */ float Length;
    /* 0x0008 */ float PlayRate;
    /* 0x000c */ float position;
    /* 0x0010 */ TArray<FTimelineEventEntry> Events;
    /* 0x0020 */ TArray<FTimelineVectorTrack> InterpVectors;
    /* 0x0030 */ TArray<FTimelineFloatTrack> InterpFloats;
    /* 0x0040 */ TArray<FTimelineLinearColorTrack> InterpLinearColors;
    /* 0x0050 */ FDelegate TimelinePostUpdateFunc;
    /* 0x0060 */ FDelegate TimelineFinishedFunc;
    /* 0x0070 */ TWeakObjectPtr<UObject> PropertySetObject;
    /* 0x0078 */ FName DirectionPropertyName;
};

// Size: 0x158
class UTimelineComponent : public UActorComponent {
    /* 0x00b8 */ FTimeline TheTimeline;
    /* 0x0150 */ bool bIgnoreTimeDilation;

    void AddEvent(float Time, FDelegate EventFunc);
    void AddInterpFloat(UCurveFloat* FloatCurve, FDelegate InterpFunc, FName PropertyName, FName TrackName);
    void AddInterpLinearColor(UCurveLinearColor* LinearColorCurve, FDelegate InterpFunc, FName PropertyName, FName TrackName);
    void AddInterpVector(UCurveVector* VectorCurve, FDelegate InterpFunc, FName PropertyName, FName TrackName);
    bool GetIgnoreTimeDilation() const;
    float GetPlayRate() const;
    float GetPlaybackPosition() const;
    float GetScaledTimelineLength() const;
    float GetTimelineLength() const;
    bool IsLooping() const;
    bool IsPlaying() const;
    bool IsReversing() const;
    void OnRep_Timeline(FTimeline& OldTimeline);
    void Play();
    void PlayFromStart();
    void Reverse();
    void ReverseFromEnd();
    void SetFloatCurve(UCurveFloat* NewFloatCurve, FName FloatTrackName);
    void SetIgnoreTimeDilation(bool bNewIgnoreTimeDilation);
    void SetLinearColorCurve(UCurveLinearColor* NewLinearColorCurve, FName LinearColorTrackName);
    void SetLooping(bool bNewLooping);
    void SetNewTime(float NewTime);
    void SetPlayRate(float NewRate);
    void SetPlaybackPosition(float NewPosition, bool bFireEvents, bool bFireUpdate);
    void SetTimelineFinishedFunc(FDelegate NewTimelineFinishedFunc);
    void SetTimelineLength(float NewLength);
    void SetTimelineLengthMode(uint8_t NewLengthMode);
    void SetTimelinePostUpdateFunc(FDelegate NewTimelinePostUpdateFunc);
    void SetVectorCurve(UCurveVector* NewVectorCurve, FName VectorTrackName);
    void Stop();
};

// Size: 0x14
struct FTimelineEventEntry {
    /* 0x0000 */ float Time;
    /* 0x0004 */ FDelegate EventFunc;
};

// Size: 0x40
struct FTimelineFloatTrack {
    /* 0x0000 */ UCurveFloat* FloatCurve;
    /* 0x0008 */ FDelegate InterpFunc;
    /* 0x0018 */ FName TrackName;
    /* 0x0020 */ FName FloatPropertyName;
};

// Size: 0x40
struct FTimelineLinearColorTrack {
    /* 0x0000 */ UCurveLinearColor* LinearColorCurve;
    /* 0x0008 */ FDelegate InterpFunc;
    /* 0x0018 */ FName TrackName;
    /* 0x0020 */ FName LinearColorPropertyName;
};

// Size: 0xb8
class UTimelineTemplate : public UObject {
    /* 0x0028 */ float TimelineLength;
    /* 0x002c */ uint8_t LengthMode;
    /* 0x002d */ bool bAutoPlay;
    /* 0x002d */ bool bLoop;
    /* 0x002d */ bool bReplicated;
    /* 0x002d */ bool bIgnoreTimeDilation;
    /* 0x0030 */ TArray<FTTEventTrack> EventTracks;
    /* 0x0040 */ TArray<FTTFloatTrack> FloatTracks;
    /* 0x0050 */ TArray<FTTVectorTrack> VectorTracks;
    /* 0x0060 */ TArray<FTTLinearColorTrack> LinearColorTracks;
    /* 0x0070 */ TArray<FBPVariableMetaDataEntry> MetaDataArray;
    /* 0x0080 */ FGuid TimelineGuid;
    /* 0x0090 */ uint8_t TimelineTickGroup;
    /* 0x0094 */ FName VariableName;
    /* 0x009c */ FName DirectionPropertyName;
    /* 0x00a4 */ FName UpdateFunctionName;
    /* 0x00ac */ FName FinishedFunctionName;
};

// Size: 0x40
struct FTimelineVectorTrack {
    /* 0x0000 */ UCurveVector* VectorCurve;
    /* 0x0008 */ FDelegate InterpFunc;
    /* 0x0018 */ FName TrackName;
    /* 0x0020 */ FName VectorPropertyName;
};

// Size: 0x8
struct FTimerHandle {
    /* 0x0000 */ uint64_t Handle;
};

// Size: 0x38
class UTireType : public UDataAsset {
    /* 0x0030 */ float FrictionScale;
};

// Size: 0x98
struct FTouchInputControl {
    /* 0x0000 */ bool bTreatAsButton;
    /* 0x0008 */ UTexture2D* Image1;
    /* 0x0010 */ UTexture2D* Image2;
    /* 0x0018 */ FVector2D Center;
    /* 0x0028 */ FVector2D VisualSize;
    /* 0x0038 */ FVector2D ThumbSize;
    /* 0x0048 */ FVector2D InteractionSize;
    /* 0x0058 */ FVector2D InputScale;
    /* 0x0068 */ FKey MainInputKey;
    /* 0x0080 */ FKey AltInputKey;
};

// Size: 0x58
class UTouchInterface : public UObject {
    /* 0x0028 */ TArray<FTouchInputControl> Controls;
    /* 0x0038 */ float ActiveOpacity;
    /* 0x003c */ float InactiveOpacity;
    /* 0x0040 */ float TimeUntilDeactive;
    /* 0x0044 */ float TimeUntilReset;
    /* 0x0048 */ float ActivationDelay;
    /* 0x004c */ bool bPreventRecenter;
    /* 0x0050 */ float StartupDelay;
};

// Size: 0x4
struct FTrackToSkeletonMap {
    /* 0x0000 */ int32_t BoneTreeIndex;
};

// Size: 0x90
struct FTrajectorySample {
    /* 0x0000 */ float AccumulatedSeconds;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FVector LinearVelocity;
};

// Size: 0x98
class UTransactionDiffingTestObject : public UObject {
    /* 0x0028 */ TArray<FName> NamesArray;
    /* 0x0038 */ FName AdditionalName;
    /* 0x0040 */ TArray<UObject*> ObjectsArray;
    /* 0x0050 */ UObject* AdditionalObject;
    /* 0x0058 */ TArray<TSoftObjectPtr<UObject>> SoftObjectsArray;
    /* 0x0068 */ TSoftObjectPtr<UObject> AdditionalSoftObject;
    /* 0x0090 */ int32_t PropertyData;
};

// Size: 0x60
struct FTransformAnimationAttribute {
    /* 0x0000 */ FTransform Value;
};

// Size: 0x4c0
struct FTransformCurve : public FAnimCurveBase {
    /* 0x0010 */ FVectorCurve TranslationCurve;
    /* 0x01a0 */ FVectorCurve RotationCurve;
    /* 0x0330 */ FVectorCurve ScaleCurve;
};

// Size: 0x10
struct FTransformTrajectory {
    /* 0x0000 */ TArray<FTransformTrajectorySample> Samples;
};

// Size: 0x28
class UTransformTrajectoryBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void DebugDrawTrajectory(const FTransformTrajectory& Trajectory, const UWorld* World, const float DebugThickness, float heightOffset);
};

// Size: 0x40
struct FTransformTrajectorySample {
    /* 0x0000 */ FQuat Facing;
    /* 0x0020 */ FVector position;
    /* 0x0038 */ float TimeInSeconds;
};

// Size: 0x20
struct FTranslationTrack {
    /* 0x0000 */ TArray<FVector3f> PosKeys;
    /* 0x0010 */ TArray<float> Times;
};

// Size: 0x2b0
class ATriggerBase : public AActor {
    /* 0x02a8 */ UShapeComponent* CollisionComponent;
};

// Size: 0x2b0
class ATriggerBox : public ATriggerBase {
};

// Size: 0x2b0
class ATriggerCapsule : public ATriggerBase {
};

// Size: 0x2b0
class ATriggerSphere : public ATriggerBase {
};

// Size: 0x2e0
class ATriggerVolume : public AVolume {
};

// Size: 0x1c
struct FTwistConstraint : public FConstraintBaseParams {
    /* 0x0014 */ float TwistLimitDegrees;
    /* 0x0018 */ uint8_t TwistMotion;
};

// Size: 0x38
class UTwitterIntegrationBase : public UPlatformInterfaceBase {

    bool AuthorizeAccounts();
    bool CanShowTweetUI();
    FString GetAccountName(int32_t AccountIndex);
    int32_t GetNumAccounts();
    void Init();
    bool ShowTweetUI(FString InitialMessage, FString URL, FString Picture);
    bool TwitterRequest(FString URL, const TArray<FString>& ParamKeysAndValues, uint8_t RequestMethod, int32_t AccountIndex);
};

// Size: 0x828
class UTypedElementCommonActions : public UObject {

    bool CopyNormalizedElements(const FScriptTypedElementListProxy& ElementList);
    bool CopyNormalizedElementsToString(const FScriptTypedElementListProxy& ElementList, FString& OutputString);
    bool CopySelectedElements(UTypedElementSelectionSet* SelectionSet);
    bool CopySelectedElementsToString(UTypedElementSelectionSet* SelectionSet, FString& OutputString);
    bool DeleteNormalizedElements(const FScriptTypedElementListProxy ElementList, UWorld* World, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& DeletionOptions);
    bool DeleteSelectedElements(UTypedElementSelectionSet* SelectionSet, UWorld* World, const FTypedElementDeletionOptions& DeletionOptions);
    TArray<FScriptTypedElementHandle> DuplicateNormalizedElements(const FScriptTypedElementListProxy ElementList, UWorld* World, const FVector& LocationOffset);
    TArray<FScriptTypedElementHandle> K2_DuplicateSelectedElements(const UTypedElementSelectionSet* SelectionSet, UWorld* World, const FVector& LocationOffset);
    TArray<FScriptTypedElementHandle> K2_PasteElements(UTypedElementSelectionSet* SelectionSet, UWorld* World, const FTypedElementPasteOptions& PasteOption);
    TArray<FScriptTypedElementHandle> K2_PasteNormalizedElements(const FScriptTypedElementListProxy& ElementList, UWorld* World, const FTypedElementPasteOptions& PasteOption);
    TArray<FScriptTypedElementHandle> PasteElementsFromString(UTypedElementSelectionSet* SelectionSet, UWorld* World, const FTypedElementPasteOptions& PasteOption, FString InputString);
    TArray<FScriptTypedElementHandle> PasteNormalizedElementsFromString(const FScriptTypedElementListProxy& ElementList, UWorld* World, const FTypedElementPasteOptions& PasteOption, FString InputString);
};

// Size: 0x3
struct FTypedElementDeletionOptions {
    /* 0x0000 */ bool bVerifyDeletionCanHappen;
    /* 0x0001 */ bool bWarnAboutReferences;
    /* 0x0002 */ bool bWarnAboutSoftReferences;
};

// Size: 0x78
struct FTypedElementPasteOptions {
    /* 0x0000 */ UTypedElementSelectionSet* SelectionSetToModify;
    /* 0x0008 */ bool bPasteAtLocation;
    /* 0x0010 */ FVector PasteLocation;
};

// Size: 0x28
class ITypedElementWorldInterface : public UInterface {

    bool CanDeleteElement(const FScriptTypedElementHandle& InElementHandle);
    bool CanDuplicateElement(const FScriptTypedElementHandle& InElementHandle);
    bool CanEditElement(const FScriptTypedElementHandle& InElementHandle);
    bool CanMoveElement(const FScriptTypedElementHandle& InElementHandle, const ETypedElementWorldType InWorldType);
    bool CanPromoteElement(const FScriptTypedElementHandle& InElementHandle);
    bool CanScaleElement(const FScriptTypedElementHandle& InElementHandle);
    bool DeleteElement(const FScriptTypedElementHandle& InElementHandle, UWorld* InWorld, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& InDeletionOptions);
    FScriptTypedElementHandle DuplicateElement(const FScriptTypedElementHandle& InElementHandle, UWorld* InWorld, const FVector& InLocationOffset);
    bool GetBounds(const FScriptTypedElementHandle& InElementHandle, FBoxSphereBounds& OutBounds);
    ULevel* GetOwnerLevel(const FScriptTypedElementHandle& InElementHandle);
    UWorld* GetOwnerWorld(const FScriptTypedElementHandle& InElementHandle);
    bool GetPivotOffset(const FScriptTypedElementHandle& InElementHandle, FVector& OutPivotOffset);
    bool GetRelativeTransform(const FScriptTypedElementHandle& InElementHandle, FTransform& OutTransform);
    bool GetWorldTransform(const FScriptTypedElementHandle& InElementHandle, FTransform& OutTransform);
    bool IsTemplateElement(const FScriptTypedElementHandle& InElementHandle);
    void NotifyMovementEnded(const FScriptTypedElementHandle& InElementHandle);
    void NotifyMovementOngoing(const FScriptTypedElementHandle& InElementHandle);
    void NotifyMovementStarted(const FScriptTypedElementHandle& InElementHandle);
    FScriptTypedElementHandle PromoteElement(const FScriptTypedElementHandle& InElementHandle, UWorld* OverrideWorld);
    bool SetPivotOffset(const FScriptTypedElementHandle& InElementHandle, const FVector& InPivotOffset);
    bool SetRelativeTransform(const FScriptTypedElementHandle& InElementHandle, const FTransform& InTransform);
    bool SetWorldTransform(const FScriptTypedElementHandle& InElementHandle, const FTransform& InTransform);
};

// Size: 0x68
struct FURL {
    /* 0x0000 */ FString Protocol;
    /* 0x0010 */ FString Host;
    /* 0x0020 */ int32_t Port;
    /* 0x0024 */ int32_t Valid;
    /* 0x0028 */ FString Map;
    /* 0x0038 */ FString RedirectURL;
    /* 0x0048 */ TArray<FString> Op;
    /* 0x0058 */ FString Portal;
};

// Size: 0x30
struct FUniqueNetIdRepl : public FUniqueNetIdWrapper {
    /* 0x0020 */ TArray<uint8_t> ReplicationBytes;
};

// Size: 0x10
struct FUniqueNetIdReplNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x8
struct FUniqueNetIdReplNetSerializerNameStruct {
    /* 0x0000 */ FName Name;
};

// Size: 0x10
struct FUniqueNetIdReplNetSerializerStringStruct {
    /* 0x0000 */ FString String;
};

// Size: 0x28
class UUniversalObjectLocatorScriptingExtensions : public UBlueprintFunctionLibrary {

    static bool IsEmpty(const FUniversalObjectLocator& Locator);
    static FUniversalObjectLocator MakeUniversalObjectLocator(UObject* Object, UObject* Context);
    static UObject* SyncFind(const FUniversalObjectLocator& Locator, UObject* Context);
    static UObject* SyncLoad(const FUniversalObjectLocator& Locator, UObject* Context);
    static void SyncUnload(const FUniversalObjectLocator& Locator, UObject* Context);
    static FString ToString(const FUniversalObjectLocator& Locator);
    static FUniversalObjectLocator UniversalObjectLocatorFromString(FString InString);
};

// Size: 0x10
struct FUpdateLevelStreamingLevelStatus {
    /* 0x0000 */ FName PackageName;
    /* 0x0008 */ int32_t LODIndex;
    /* 0x000c */ bool bNewShouldBeLoaded;
    /* 0x000d */ bool bNewShouldBeVisible;
    /* 0x000e */ bool bNewShouldBlockOnLoad;
    /* 0x000f */ bool bNewShouldBlockOnUnload;
};

// Size: 0x18
struct FUpdateLevelVisibilityLevelInfo {
    /* 0x0000 */ FName PackageName;
    /* 0x0008 */ FName Filename;
    /* 0x0010 */ FNetLevelVisibilityTransactionId VisibilityRequestId;
    /* 0x0014 */ bool bIsVisible;
    /* 0x0014 */ bool bTryMakeVisible;
    /* 0x0014 */ bool bSkipCloseOnError;
};

// Size: 0x18
struct FUserActivity {
    /* 0x0000 */ FString ActionName;
};

// Size: 0xb8
class UUserDefinedEnum : public UEnum {
    /* 0x0068 */ TMap<FName, FText> DisplayNameMap;
};

// Size: 0x2b0
class UUserInterfaceSettings : public UDeveloperSettings {
    /* 0x0038 */ ERenderFocusRule RenderFocusRule;
    /* 0x0040 */ TMap<uint8_t, FHardwareCursorReference> HardwareCursors;
    /* 0x0090 */ TMap<uint8_t, FSoftClassPath> SoftwareCursors;
    /* 0x00e0 */ FSoftClassPath DefaultCursor;
    /* 0x0100 */ FSoftClassPath TextEditBeamCursor;
    /* 0x0120 */ FSoftClassPath CrosshairsCursor;
    /* 0x0140 */ FSoftClassPath HandCursor;
    /* 0x0160 */ FSoftClassPath GrabHandCursor;
    /* 0x0180 */ FSoftClassPath GrabHandClosedCursor;
    /* 0x01a0 */ FSoftClassPath SlashedCircleCursor;
    /* 0x01c0 */ float ApplicationScale;
    /* 0x01c4 */ EUIScalingRule UIScaleRule;
    /* 0x01c8 */ FSoftClassPath CustomScalingRuleClass;
    /* 0x01e8 */ FRuntimeFloatCurve UIScaleCurve;
    /* 0x0270 */ bool bAllowHighDPIInGameMode;
    /* 0x0274 */ FIntPoint DesignScreenSize;
    /* 0x027c */ bool bLoadWidgetsOnDedicatedServer;
    /* 0x027d */ bool bAuthorizeAutomaticWidgetVariableCreation;
    /* 0x027e */ bool bEnableDistanceFieldFontRasterization;
    /* 0x0280 */ TArray<UObject*> CursorClasses;
    /* 0x0290 */ UClass* CustomScalingRuleClassInstance;
    /* 0x0298 */ UDPICustomScalingRule* CustomScalingRule;

    static bool ShouldDisplayDistanceFieldFontSettings();
};

// Size: 0x10
struct FUserSceneTextureOverride {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FName Value;
};

// Size: 0x28
class UVOIPStatics : public UBlueprintFunctionLibrary {

    static void SetMicThreshold(float InThreshold);
};

// Size: 0xf8
class UVOIPTalker : public UActorComponent {
    /* 0x00b8 */ FVoiceSettings Settings;

    void BPOnTalkingBegin(UAudioComponent* AudioComponent);
    void BPOnTalkingEnd();
    static UVOIPTalker* CreateTalkerForPlayer(APlayerState* OwningState);
    float GetVoiceLevel();
    void RegisterWithPlayerState(APlayerState* OwningState);
};

// Size: 0x58
class UValkyrieMetaData : public UObject {
    /* 0x0028 */ FName DevelopmentStatusKey;
    /* 0x0040 */ FName DeprecationStatusKey;
};

// Size: 0x30
class UVariableFrameStrippingSettings : public UObject {
    /* 0x0028 */ FPerPlatformBool UseVariableFrameStripping;
    /* 0x002c */ FPerPlatformInt FrameStrippingRate;
};

// Size: 0x38
struct FVector2MaterialInput : public FMaterialInput {
    /* 0x0028 */ bool UseConstant;
    /* 0x002c */ float ConstantX;
    /* 0x0030 */ float ConstantY;
};

// Size: 0x20
struct FVector4Distribution {
    /* 0x0000 */ FDistributionLookupTable Table;
};

// Size: 0x18
struct FVectorAnimationAttribute {
    /* 0x0000 */ FVector Value;
};

// Size: 0x190
struct FVectorCurve : public FAnimCurveBase {
    /* 0x0010 */ FRichCurve FloatCurves[3];
};

// Size: 0x20
struct FVectorDistribution {
    /* 0x0000 */ FDistributionLookupTable Table;
};

// Size: 0x68
class UVectorField : public UObject {
    /* 0x0028 */ FBox Bounds;
    /* 0x0060 */ float Intensity;
};

// Size: 0xa8
class UVectorFieldAnimated : public UVectorField {
    /* 0x0068 */ UTexture2D* Texture;
    /* 0x0070 */ uint8_t ConstructionOp;
    /* 0x0074 */ int32_t VolumeSizeX;
    /* 0x0078 */ int32_t VolumeSizeY;
    /* 0x007c */ int32_t VolumeSizeZ;
    /* 0x0080 */ int32_t SubImagesX;
    /* 0x0084 */ int32_t SubImagesY;
    /* 0x0088 */ int32_t FrameCount;
    /* 0x008c */ float FramesPerSecond;
    /* 0x0090 */ bool bLoop;
    /* 0x0098 */ UVectorFieldStatic* NoiseField;
    /* 0x00a0 */ float NoiseScale;
    /* 0x00a4 */ float NoiseMax;
};

// Size: 0x550
class UVectorFieldComponent : public UPrimitiveComponent {
    /* 0x0520 */ UVectorField* VectorField;
    /* 0x0528 */ float Intensity;
    /* 0x052c */ float Tightness;
    /* 0x0530 */ bool bPreviewVectorField;

    void SetIntensity(float NewIntensity);
};

// Size: 0xb8
class UVectorFieldStatic : public UVectorField {
    /* 0x0068 */ int32_t SizeX;
    /* 0x006c */ int32_t SizeY;
    /* 0x0070 */ int32_t SizeZ;
    /* 0x0074 */ bool bAllowCPUAccess;
};

// Size: 0x2b0
class AVectorFieldVolume : public AActor {
    /* 0x02a8 */ UVectorFieldComponent* VectorFieldComponent;
};

// Size: 0x38
struct FVectorMaterialInput : public FMaterialInput {
    /* 0x0028 */ bool UseConstant;
    /* 0x002c */ FVector3f Constant;
};

// Size: 0x30
struct FVectorParameterValue {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ FLinearColor ParameterValue;
    /* 0x0020 */ FGuid ExpressionGUID;
};

// Size: 0x8
struct FVectorRK4SpringInterpolator {
    /* 0x0000 */ float StiffnessConstant;
    /* 0x0004 */ float DampeningRatio;
};

// Size: 0x38
struct FVectorSpringState {
};

// Size: 0x18
struct FVector_NetQuantize : public FVector {
};

// Size: 0x18
struct FVector_NetQuantize10 : public FVector {
};

// Size: 0x18
struct FVector_NetQuantize100 : public FVector {
};

// Size: 0x18
struct FVector_NetQuantizeNormal : public FVector {
};

// Size: 0x4
struct FVertexOffsetUsage {
    /* 0x0000 */ int32_t Usage;
};

// Size: 0x1
struct FViewLightingChannels {
    /* 0x0000 */ bool bViewChannel0;
    /* 0x0000 */ bool bViewChannel1;
    /* 0x0000 */ bool bViewChannel2;
    /* 0x0000 */ bool bViewChannel3;
    /* 0x0000 */ bool bViewChannel4;
};

// Size: 0x28
class UViewModeUtils : public UObject {
};

// Size: 0x10
struct FViewTargetTransitionParams {
    /* 0x0000 */ float BlendTime;
    /* 0x0004 */ uint8_t BlendFunction;
    /* 0x0008 */ float BlendExp;
    /* 0x000c */ bool bLockOutgoing;
};

// Size: 0x28
class IViewportSelectableObject : public UInterface {
};

// Size: 0x50
class UViewportStatsSubsystem : public UWorldSubsystem {

    int32_t AddDisplayDelegate(const FDelegate& Delegate);
    void AddTimedDisplay(FText Text, FLinearColor Color, float Duration, const FVector2D& DisplayOffset);
    void RemoveDisplayDelegate(const int32_t IndexToRemove);
};

// Size: 0x18
struct FVirtualBone {
    /* 0x0000 */ FName SourceBoneName;
    /* 0x0008 */ FName TargetBoneName;
    /* 0x0010 */ FName VirtualBoneName;
};

// Size: 0x28
class UVirtualTexture : public UObject {
};

// Size: 0x170
class UVirtualTexture2D : public UTexture2D {
    /* 0x0160 */ FVirtualTextureBuildSettings Settings;
    /* 0x0168 */ bool bContinuousUpdate;
    /* 0x0169 */ bool bSinglePhysicalSpace;
};

// Size: 0x160
class UVirtualTextureAdapter : public UTexture {
    /* 0x0140 */ UTexture* Texture;
    /* 0x0148 */ UTexture2D* OverrideWithTextureFormat;
    /* 0x0150 */ bool bUseDefaultTileSizes;
    /* 0x0154 */ int32_t TileSize;
    /* 0x0158 */ int32_t TileBorderSize;
};

// Size: 0x8
struct FVirtualTextureBuildSettings {
    /* 0x0000 */ int32_t TileSize;
    /* 0x0004 */ int32_t TileBorderSize;
};

// Size: 0x48
class UVirtualTextureBuilder : public UObject {
    /* 0x0028 */ UVirtualTexture2D* Texture;
    /* 0x0030 */ UVirtualTexture2D* TextureMobile;
    /* 0x0038 */ uint64_t BuildHash;
    /* 0x0040 */ bool bSeparateTextureForMobile;
};

// Size: 0x60
class UVirtualTexturePoolConfig : public UDeveloperSettings {
    /* 0x0038 */ int32_t DefaultSizeInMegabyte;
    /* 0x003c */ bool bPoolAutoGrowInEditor;
    /* 0x0040 */ TArray<FVirtualTextureSpacePoolConfig> Pools;
    /* 0x0050 */ TArray<FVirtualTextureSpacePoolConfig> TransientPools;
};

// Size: 0x30
struct FVirtualTextureSpacePoolConfig {
    /* 0x0000 */ TArray<uint8_t> Formats;
    /* 0x0010 */ int32_t MinTileSize;
    /* 0x0014 */ int32_t MaxTileSize;
    /* 0x0018 */ int32_t SizeInMegabyte;
    /* 0x001c */ bool bEnableResidencyMipMapBias;
    /* 0x0020 */ int32_t ResidencyMipMapBiasGroup;
    /* 0x0024 */ bool bAllowSizeScale;
    /* 0x0028 */ int32_t MinScaledSizeInMegabyte;
    /* 0x002c */ int32_t MaxScaledSizeInMegabyte;
};

// Size: 0x28
class UVisualLoggerAutomationTests : public UObject {
};

// Size: 0x28
class IVisualLoggerDebugSnapshotInterface : public UInterface {
};

// Size: 0x2e0
class AVisualLoggerFilterVolume : public AVolume {
};

// Size: 0x28
class UVisualLoggerKismetLibrary : public UBlueprintFunctionLibrary {

    static void EnableRecording(bool bEnabled);
    static void LogArrow(UObject* WorldContextObject, const FVector SegmentStart, const FVector SegmentEnd, FString Text, FLinearColor ObjectColor, FName CategoryName, bool bAddToMessageLog, float ArrowHeadSize);
    static void LogBox(UObject* WorldContextObject, FBox BoxShape, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogCapsule(UObject* WorldContextObject, FVector base, float HalfHeight, float Radius, FQuat Rotation, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogCircle(UObject* WorldContextObject, FVector Center, FVector UpAxis, float Radius, FString Text, FLinearColor ObjectColor, const float Thickness, FName CategoryName, bool bAddToMessageLog, bool bWireframe);
    static void LogCone(UObject* WorldContextObject, FVector Origin, FVector Direction, float Length, float Angle, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogCylinder(UObject* WorldContextObject, FVector Start, FVector End, float Radius, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogLocation(UObject* WorldContextObject, FVector Location, FString Text, FLinearColor ObjectColor, float Radius, FName LogCategory, bool bAddToMessageLog);
    static void LogOrientedBox(UObject* WorldContextObject, FBox BoxShape, FTransform Transform, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogSegment(UObject* WorldContextObject, const FVector SegmentStart, const FVector SegmentEnd, FString Text, FLinearColor ObjectColor, const float Thickness, FName CategoryName, bool bAddToMessageLog);
    static void LogSphere(UObject* WorldContextObject, FVector Center, float Radius, FString Text, FLinearColor ObjectColor, FName LogCategory, bool bAddToMessageLog, bool bWireframe);
    static void LogText(UObject* WorldContextObject, FString Text, FName LogCategory, bool bAddToMessageLog);
    static void RedirectVislog(UObject* SourceOwner, UObject* DestinationOwner);
};

// Size: 0x78
class UVoiceChannel : public UChannel {
};

// Size: 0x18
struct FVoiceSettings {
    /* 0x0000 */ USceneComponent* ComponentToAttachTo;
    /* 0x0008 */ USoundAttenuation* AttenuationSettings;
    /* 0x0010 */ USoundEffectSourcePresetChain* SourceEffectChain;
};

// Size: 0x2e0
class AVolume : public ABrush {
};

// Size: 0x150
class UVolumeTexture : public UTexture {
    /* 0x0148 */ uint8_t AddressMode;
};

// Size: 0x2b0
class AVolumetricCloud : public AInfo {
    /* 0x02a8 */ UVolumetricCloudComponent* VolumetricCloudComponent;
};

// Size: 0x2e0
class UVolumetricCloudComponent : public USceneComponent {
    /* 0x0240 */ float LayerBottomAltitude;
    /* 0x0244 */ float LayerHeight;
    /* 0x0248 */ float TracingStartMaxDistance;
    /* 0x024c */ float TracingStartDistanceFromCamera;
    /* 0x0250 */ EVolumetricCloudTracingMaxDistanceMode TracingMaxDistanceMode;
    /* 0x0254 */ float TracingMaxDistance;
    /* 0x0258 */ float PlanetRadius;
    /* 0x025c */ FColor GroundAlbedo;
    /* 0x0260 */ TSoftObjectPtr<UMaterialInterface> Material;
    /* 0x0288 */ bool bUsePerSampleAtmosphericLightTransmittance;
    /* 0x028c */ float SkyLightCloudBottomOcclusion;
    /* 0x0290 */ float ViewSampleCountScale;
    /* 0x0294 */ float ReflectionViewSampleCountScaleValue;
    /* 0x0298 */ float ReflectionViewSampleCountScale;
    /* 0x029c */ float ReflectionSampleCountScale;
    /* 0x02a0 */ float ShadowViewSampleCountScale;
    /* 0x02a4 */ float ShadowReflectionViewSampleCountScaleValue;
    /* 0x02a8 */ float ShadowReflectionViewSampleCountScale;
    /* 0x02ac */ float ShadowReflectionSampleCountScale;
    /* 0x02b0 */ float ShadowTracingDistance;
    /* 0x02b4 */ float StopTracingTransmittanceThreshold;
    /* 0x02b8 */ float AerialPespectiveRayleighScatteringStartDistance;
    /* 0x02bc */ float AerialPespectiveRayleighScatteringFadeDistance;
    /* 0x02c0 */ float AerialPespectiveMieScatteringStartDistance;
    /* 0x02c4 */ float AerialPespectiveMieScatteringFadeDistance;
    /* 0x02c8 */ bool bHoldout;
    /* 0x02c8 */ bool bRenderInMainPass;
    /* 0x02c8 */ bool bVisibleInRealTimeSkyCaptures;
    /* 0x02d8 */ UMaterialInterface* MaterialLifetimePtr;

    void SetGroundAlbedo(FColor NewValue);
    void SetHoldout(bool bNewHoldout);
    void SetLayerBottomAltitude(float NewValue);
    void SetLayerHeight(float NewValue);
    void SetMaterial(UMaterialInterface* NewValue);
    void SetPlanetRadius(float NewValue);
    void SetReflectionSampleCountScale(float NewValue);
    void SetReflectionViewSampleCountScale(float NewValue);
    void SetRenderInMainPass(bool bValue);
    void SetShadowReflectionSampleCountScale(float NewValue);
    void SetShadowReflectionViewSampleCountScale(float NewValue);
    void SetShadowTracingDistance(float NewValue);
    void SetShadowViewSampleCountScale(float NewValue);
    void SetSkyLightCloudBottomOcclusion(float NewValue);
    void SetStopTracingTransmittanceThreshold(float NewValue);
    void SetTracingMaxDistance(float NewValue);
    void SetTracingStartDistanceFromCamera(float NewValue);
    void SetTracingStartMaxDistance(float NewValue);
    void SetViewSampleCountScale(float NewValue);
    void SetVisibleInRealTimeSkyCaptures(bool bValue);
    void SetbUsePerSampleAtmosphericLightTransmittance(bool NewValue);
};

// Size: 0x68
struct FVolumetricLightMapGridCell {
    /* 0x0000 */ FBox Bounds;
    /* 0x0060 */ uint32_t CellID;
};

// Size: 0x68
struct FVolumetricLightMapGridDesc {
    /* 0x0000 */ FBox GridBounds;
    /* 0x0038 */ FGuid Guid;
    /* 0x0048 */ float CellSize;
    /* 0x004c */ float DetailCellSize;
    /* 0x0050 */ float BrickSize;
    /* 0x0058 */ TArray<FVolumetricLightMapGridCell> Cells;
};

// Size: 0x2e8
class AVolumetricLightmapDensityVolume : public AVolume {
    /* 0x02e0 */ FInt32Interval AllowedMipLevelRange;
};

// Size: 0x10
struct FWalkableSlopeOverride {
    /* 0x0000 */ uint8_t WalkableSlopeBehavior;
    /* 0x0004 */ float WalkableSlopeAngle;
};

// Size: 0x8
struct FWeightedBlendSample {
    /* 0x0000 */ int32_t SampleIndex;
    /* 0x0004 */ float SampleWeight;
};

// Size: 0x10
struct FWeightedBlendable {
    /* 0x0000 */ float Weight;
    /* 0x0008 */ UObject* Object;
};

// Size: 0x10
struct FWeightedBlendables {
    /* 0x0000 */ TArray<FWeightedBlendable> Array;
};

// Size: 0x2b0
class AWindDirectionalSource : public AInfo {
    /* 0x02a8 */ UWindDirectionalSourceComponent* Component;
};

// Size: 0x260
class UWindDirectionalSourceComponent : public USceneComponent {
    /* 0x0240 */ float Strength;
    /* 0x0244 */ float Speed;
    /* 0x0248 */ float MinGustAmount;
    /* 0x024c */ float MaxGustAmount;
    /* 0x0250 */ float Radius;
    /* 0x0254 */ bool bPointWind;

    void SetMaximumGustAmount(float InNewMaxGust);
    void SetMinimumGustAmount(float InNewMinGust);
    void SetRadius(float InNewRadius);
    void SetSpeed(float InNewSpeed);
    void SetStrength(float InNewStrength);
    void SetWindType(EWindSourceType InNewType);
};

// Size: 0x9e8
class UWorld : public UObject {
    /* 0x0030 */ ULevel* PersistentLevel;
    /* 0x0038 */ UNetDriver* NetDriver;
    /* 0x0040 */ ULineBatchComponent* LineBatcher;
    /* 0x0048 */ ULineBatchComponent* PersistentLineBatcher;
    /* 0x0050 */ ULineBatchComponent* ForegroundLineBatcher;
    /* 0x0058 */ AGameNetworkManager* NetworkManager;
    /* 0x0060 */ UPhysicsCollisionHandler* PhysicsCollisionHandler;
    /* 0x0068 */ UPhysicsQueryHandler* PhysicsQueryHandler;
    /* 0x0070 */ TArray<UObject*> ExtraReferencedObjects;
    /* 0x0080 */ TArray<UObject*> PerModuleDataObjects;
    /* 0x0090 */ TArray<ULevelStreaming*> StreamingLevels;
    /* 0x00a0 */ FStreamingLevelsToConsider StreamingLevelsToConsider;
    /* 0x00c8 */ AServerStreamingLevelsVisibility* ServerStreamingLevelsVisibility;
    /* 0x00d0 */ FString StreamingLevelsPrefix;
    /* 0x00f0 */ ULineBatchComponent* LineBatchers[4];
    /* 0x0120 */ TArray<ULevel*> MakingVisibleLevels;
    /* 0x0130 */ TArray<ULevel*> MakingInvisibleLevels;
    /* 0x0140 */ UDemoNetDriver* DemoNetDriver;
    /* 0x0148 */ AParticleEventManager* MyParticleEventManager;
    /* 0x0150 */ APhysicsVolume* DefaultPhysicsVolume;
    /* 0x018e */ bool bAreConstraintsDirty;
    /* 0x01a0 */ UNavigationSystemBase* NavigationSystem;
    /* 0x01a8 */ AGameModeBase* AuthorityGameMode;
    /* 0x01b0 */ AGameStateBase* GameState;
    /* 0x01b8 */ UAISystemBase* AISystem;
    /* 0x01c0 */ UAvoidanceManager* AvoidanceManager;
    /* 0x01c8 */ TArray<ULevel*> Levels;
    /* 0x01d8 */ TArray<FLevelCollection> LevelCollections;
    /* 0x0228 */ UGameInstance* OwningGameInstance;
    /* 0x0230 */ TArray<UMaterialParameterCollectionInstance*> ParameterCollectionInstances;
    /* 0x0240 */ UCanvas* CanvasForRenderingToTarget;
    /* 0x0248 */ UCanvas* CanvasForDrawMaterialToRenderTarget;
    /* 0x02c0 */ UPhysicsFieldComponent* PhysicsField;
    /* 0x02c8 */ TSet<UActorComponent*> ComponentsThatNeedPreEndOfFrameSync;
    /* 0x0318 */ TArray<UActorComponent*> ComponentsThatNeedEndOfFrameUpdate;
    /* 0x0328 */ TArray<UActorComponent*> ComponentsThatNeedEndOfFrameUpdate_OnGameThread;
    /* 0x0800 */ UWorldComposition* WorldComposition;
    /* 0x0808 */ UContentBundleManager* ContentBundleManager;
    /* 0x08d0 */ FWorldPSCPool PSCPool;

    UDataLayerManager* GetDataLayerManager() const;
    void HandleTimelineScrubbed();
    AWorldSettings* K2_GetWorldSettings();
};

// Size: 0x68
class UWorldComposition : public UObject {
    /* 0x0048 */ TArray<ULevelStreaming*> TilesStreaming;
    /* 0x0058 */ double TilesStreamingTimeThreshold;
    /* 0x0060 */ bool bLoadAllTilesDuringCinematic;
    /* 0x0061 */ bool bRebaseOriginIn3DSpace;
    /* 0x0064 */ float RebaseOriginDistance;
};

// Size: 0x2c8
struct FWorldContext {
    /* 0x00c0 */ FURL LastURL;
    /* 0x0128 */ FURL LastRemoteURL;
    /* 0x0190 */ UPendingNetGame* PendingNetGame;
    /* 0x0198 */ TArray<FFullyLoadedPackagesInfo> PackagesToFullyLoad;
    /* 0x01b8 */ TArray<ULevel*> LoadedLevelsForPendingMapChange;
    /* 0x01e0 */ TArray<UObjectReferencer*> ObjectReferencers;
    /* 0x01f0 */ TArray<FLevelStreamingStatus> PendingLevelStreamingStatusUpdates;
    /* 0x0200 */ UGameViewportClient* GameViewport;
    /* 0x0208 */ UGameInstance* OwningGameInstance;
    /* 0x0210 */ TArray<FNamedNetDriver> ActiveNetDrivers;
};

// Size: 0x830
class AWorldDataLayers : public AInfo {
    /* 0x0350 */ UExternalDataLayerInstance* RootExternalDataLayerInstance;
    /* 0x0358 */ TSet<UDataLayerInstance*> DataLayerInstances;
    /* 0x03a8 */ TSet<UDataLayerInstance*> ExternalPackageDataLayerInstances;
    /* 0x03f8 */ TArray<UDataLayerInstance*> LoadedExternalPackageDataLayerInstances;
    /* 0x0408 */ TArray<UDataLayerInstance*> TransientDataLayerInstances;
    /* 0x0418 */ TMap<FName, TWeakObjectPtr<UDataLayerInstance>> DeprecatedDataLayerNameToDataLayerInstance;
    /* 0x0468 */ TSet<UDataLayer*> WorldDataLayers;
    /* 0x04b8 */ TArray<FName> RepActiveDataLayerNames;
    /* 0x04c8 */ TArray<FName> RepLoadedDataLayerNames;
    /* 0x0618 */ TArray<FName> RepEffectiveActiveDataLayerNames;
    /* 0x0628 */ TArray<FName> RepEffectiveLoadedDataLayerNames;

    void OnDataLayerRuntimeStateChanged(const UDataLayerInstance* InDataLayer, EDataLayerRuntimeState InState);
    void OnRep_ActiveDataLayerNames();
    void OnRep_EffectiveActiveDataLayerNames();
    void OnRep_EffectiveLoadedDataLayerNames();
    void OnRep_LoadedDataLayerNames();
};

// Size: 0x58
struct FWorldPSCPool {
    /* 0x0000 */ TMap<UParticleSystem*, FPSCPool> WorldParticleSystemPools;
};

// Size: 0x150
class UWorldPartition : public UObject {
    /* 0x0030 */ UWorldPartitionRuntimeHash* RuntimeHash;
    /* 0x0038 */ bool bEnableStreaming;
    /* 0x0039 */ EWorldPartitionServerStreamingMode ServerStreamingMode;
    /* 0x003a */ EWorldPartitionServerStreamingOutMode ServerStreamingOutMode;
    /* 0x003b */ EWorldPartitionDataLayersLogicOperator DataLayersLogicOperator;
    /* 0x003c */ bool bHasStandaloneHLOD;
    /* 0x003c */ bool bIsStandaloneHLODWorld;
    /* 0x003c */ bool bDisableContentBundles;
    /* 0x0048 */ TSet<UObject*> ReferencedObjects;
    /* 0x0120 */ UDataLayerManager* DataLayerManager;
    /* 0x0128 */ UExternalDataLayerManager* ExternalDataLayerManager;
    /* 0x0130 */ UWorldPartitionStreamingPolicy* StreamingPolicy;
};

// Size: 0x1
struct FWorldPartitionActorFilter {
};

// Size: 0x28
class IWorldPartitionActorLoaderInterface : public UInterface {
};

// Size: 0x2a8
class AWorldPartitionAutoInstancedActor : public AActor {
};

// Size: 0x28
class UWorldPartitionBlueprintLibrary : public UBlueprintFunctionLibrary {

    static bool GetActorDescs(TArray<FActorDesc>& OutActorDescs);
    static bool GetActorDescsForActors(const TArray<AActor*>& InActors, TArray<FActorDesc>& OutActorDescs);
    static UDataLayerManager* GetDataLayerManager(UObject* WorldContextObject);
    static FBox GetEditorWorldBounds();
    static bool GetIntersectingActorDescs(const FBox& InBox, TArray<FActorDesc>& OutActorDescs);
    static FBox GetRuntimeWorldBounds();
    static void LoadActors(const TArray<FGuid>& InActorsToLoad);
    static void PinActors(const TArray<FGuid>& InActorsToPin);
    static void UnloadActors(const TArray<FGuid>& InActorsToUnload);
    static void UnpinActors(const TArray<FGuid>& InActorsToUnpin);
};

// Size: 0x28
class IWorldPartitionCell : public UInterface {
};

// Size: 0x28
class IWorldPartitionCookPackageObject : public UInterface {
};

// Size: 0x250
class UWorldPartitionDestructibleHLODComponent : public USceneComponent {
    /* 0x0240 */ TArray<FName> DestructibleActors;
};

// Size: 0x14
struct FWorldPartitionDestructibleHLODDamagedActorState : public FFastArraySerializerItem {
    /* 0x000c */ int32_t ActorIndex;
    /* 0x0010 */ uint8_t ActorHealth;
};

// Size: 0x3b0
class UWorldPartitionDestructibleHLODMeshComponent : public UWorldPartitionDestructibleHLODComponent {
    /* 0x0250 */ UMaterialInterface* DestructibleHLODMaterial;
    /* 0x0258 */ FWorldPartitionDestructibleHLODState DestructibleHLODState;
    /* 0x03a0 */ UMaterialInstanceDynamic* VisibilityMaterial;
    /* 0x03a8 */ UTexture2DDynamic* VisibilityTexture;
};

// Size: 0x148
struct FWorldPartitionDestructibleHLODState : public FFastArraySerializer {
    /* 0x0108 */ TArray<FWorldPartitionDestructibleHLODDamagedActorState> DamagedActors;
    /* 0x0118 */ UWorldPartitionDestructibleHLODComponent* OwnerComponent;
};

// Size: 0x28
class IWorldPartitionDestructibleInHLODInterface : public UInterface {

    FWorldPartitionHLODDestructionTag GetHLODDestructionTag() const;
    void SetHLODDestructionTag(const FWorldPartitionHLODDestructionTag& InDestructionTag);
};

// Size: 0x28
class UWorldPartitionDestructibleInHLODSupportLibrary : public UBlueprintFunctionLibrary {

    static void DamageInHLOD(const TScriptInterface<IWorldPartitionDestructibleInHLODInterface>& DestructibleInHLOD, float DamagePercent);
    static void DestroyInHLOD(const TScriptInterface<IWorldPartitionDestructibleInHLODInterface>& DestructibleInHLOD);
};

// Size: 0x28
class UWorldPartitionEditorHash : public UObject {
};

// Size: 0x30
class UWorldPartitionEditorLoaderAdapter : public UObject {
};

// Size: 0x38
class UWorldPartitionEditorPerProjectUserSettings : public UDeveloperSettings {
};

// Size: 0x28
class UWorldPartitionEditorSpatialHash : public UWorldPartitionEditorHash {
};

// Size: 0x2d8
class AWorldPartitionHLOD : public AActor {
    /* 0x02b0 */ uint32_t LODLevel;
    /* 0x02b4 */ bool bRequireWarmup;
    /* 0x02b8 */ FGuid SourceCellGuid;
    /* 0x02c8 */ FGuid StandaloneHLODGuid;
};

// Size: 0x10
struct FWorldPartitionHLODDestructionTag {
    /* 0x0000 */ UWorldPartitionDestructibleHLODComponent* HLODDestructionComponent;
    /* 0x0008 */ int32_t ActorIndex;
};

// Size: 0x28
class UWorldPartitionHLODModifier : public UObject {
};

// Size: 0x28
class IWorldPartitionHLODProvider : public UInterface {
};

// Size: 0x250
class UWorldPartitionHLODRuntimeSubsystem : public UWorldSubsystem {
};

// Size: 0x28
class UWorldPartitionHLODSourceActors : public UObject {
};

// Size: 0x28
class UWorldPartitionHLODSourceActorsFromCell : public UWorldPartitionHLODSourceActors {
};

// Size: 0x28
class UWorldPartitionHLODSourceActorsFromLevel : public UWorldPartitionHLODSourceActors {
};

// Size: 0x210
class UWorldPartitionLevelStreamingDynamic : public ULevelStreamingDynamic {
    /* 0x01d0 */ bool bShouldBeAlwaysLoaded;
    /* 0x01d4 */ TWeakObjectPtr<UWorldPartitionRuntimeLevelStreamingCell> StreamingCell;
    /* 0x01e0 */ TSoftObjectPtr<UWorldPartition> OuterWorldPartition;
};

// Size: 0x508
class UWorldPartitionLevelStreamingPolicy : public UWorldPartitionStreamingPolicy {
    /* 0x03f0 */ FTopLevelAssetPath SourceWorldAssetPath;
    /* 0x0400 */ TMap<FName, FName> SubObjectsToCellRemapping;
    /* 0x0450 */ FWorldPartitionRuntimeContainerResolver ContainerResolver;
    /* 0x04a8 */ TArray<TWeakObjectPtr<URuntimeHashExternalStreamingObjectBase>> ExternalStreamingObjects;
    /* 0x04b8 */ TMap<FName, TWeakObjectPtr<URuntimeHashExternalStreamingObjectBase>> SubObjectsToExternalStreamingObjectsRemapping;
};

// Size: 0x378
class AWorldPartitionMiniMap : public AInfo {
    /* 0x02a8 */ FBox MiniMapWorldBounds;
    /* 0x02e0 */ FBox2D UVOffset;
    /* 0x0308 */ UTexture2D* MiniMapTexture;
    /* 0x0310 */ TSet<UDataLayerAsset*> ExcludedDataLayers;
    /* 0x0360 */ int32_t WorldUnitsPerPixel;
    /* 0x0364 */ int32_t BuilderCellSize;
    /* 0x0368 */ uint8_t CaptureSource;
    /* 0x036c */ uint32_t CaptureWarmupFrames;
    /* 0x0370 */ int32_t MiniMapTileSize;
};

// Size: 0x2e0
class AWorldPartitionMiniMapVolume : public AVolume {
};

// Size: 0x28
class IWorldPartitionObjectResolver : public UInterface {
};

// Size: 0x1
struct FWorldPartitionPerWorldSettings {
};

// Size: 0x28
class UWorldPartitionPropertyOverride : public UObject {
};

// Size: 0x28
class UWorldPartitionPropertyOverridePolicy : public UObject {
};

// Size: 0x2c8
class AWorldPartitionReplay : public AActor {
    /* 0x02a8 */ TArray<FName> StreamingSourceNames;
};

// Size: 0x20
struct FWorldPartitionResolveData {
    /* 0x0000 */ FActorContainerID ContainerID;
    /* 0x0010 */ FTopLevelAssetPath SourceWorldAssetPath;
};

// Size: 0xb0
class UWorldPartitionRuntimeCell : public UObject {
    /* 0x0038 */ bool bIsAlwaysLoaded;
    /* 0x0039 */ bool bIsSpatiallyLoaded;
    /* 0x0040 */ FDataLayerInstanceNames DataLayers;
    /* 0x0058 */ bool bClientOnlyVisible;
    /* 0x0059 */ bool bIsHLOD;
    /* 0x005a */ bool bBlockOnSlowLoading;
    /* 0x005c */ FGuid ContentBundleID;
    /* 0x006c */ FLinearColor CellDebugColor;
    /* 0x007c */ FGuid CellGuid;
    /* 0x008c */ FGuid SourceCellGuid;
    /* 0x00a8 */ UWorldPartitionRuntimeCellData* RuntimeCellData;
};

// Size: 0xf0
class UWorldPartitionRuntimeCellData : public UObject {
    /* 0x0060 */ FBox ContentBounds;
    /* 0x0098 */ TOptional<FBox> CellBounds;
    /* 0x00d8 */ FName GridName;
    /* 0x00e0 */ int32_t Priority;
    /* 0x00e4 */ int32_t HierarchicalLevel;
};

// Size: 0xf8
class UWorldPartitionRuntimeCellDataHashSet : public UWorldPartitionRuntimeCellData {
    /* 0x00f0 */ bool bIs2D;
};

// Size: 0x168
class UWorldPartitionRuntimeCellDataSpatialHash : public UWorldPartitionRuntimeCellData {
    /* 0x00f0 */ FVector position;
    /* 0x0108 */ float Extent;
};

// Size: 0x30
struct FWorldPartitionRuntimeCellDebugInfo {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FName GridName;
    /* 0x0018 */ int64_t CoordX;
    /* 0x0020 */ int64_t CoordY;
    /* 0x0028 */ int64_t CoordZ;
};

// Size: 0x1
struct FWorldPartitionRuntimeCellObjectMapping {
};

// Size: 0x1
struct FWorldPartitionRuntimeCellPropertyOverride {
};

// Size: 0x30
struct FWorldPartitionRuntimeCellStreamingData {
    /* 0x0000 */ FString PackageName;
    /* 0x0010 */ FSoftObjectPath WorldAsset;
};

// Size: 0x30
class UWorldPartitionRuntimeCellTransformer : public UObject {
    /* 0x0028 */ bool bEnabled;
};

// Size: 0x30
class UWorldPartitionRuntimeCellTransformerISM : public UWorldPartitionRuntimeCellTransformer {
};

// Size: 0x30
class UWorldPartitionRuntimeCellTransformerLog : public UWorldPartitionRuntimeCellTransformer {
};

// Size: 0x50
struct FWorldPartitionRuntimeContainer {
    /* 0x0000 */ TMap<FName, FWorldPartitionRuntimeContainerInstance> ContainerInstances;
};

// Size: 0x18
struct FWorldPartitionRuntimeContainerInstance {
    /* 0x0000 */ FGuid ActorGuid;
    /* 0x0010 */ FName ContainerPackage;
};

// Size: 0x58
struct FWorldPartitionRuntimeContainerResolver {
    /* 0x0000 */ TMap<FName, FWorldPartitionRuntimeContainer> Containers;
    /* 0x0050 */ FName MainContainerPackage;
};

// Size: 0x78
class UWorldPartitionRuntimeHash : public UObject {
};

// Size: 0x198
class UWorldPartitionRuntimeHashSet : public UWorldPartitionRuntimeHash {
    /* 0x0078 */ TArray<FRuntimePartitionDesc> RuntimePartitions;
    /* 0x0088 */ TArray<FRuntimePartitionStreamingData> RuntimeStreamingData;
    /* 0x0098 */ TMap<FGuid, URuntimeHashSetExternalStreamingObject*> WorldAssetStreamingObjects;
    /* 0x00e8 */ TMap<FGuid, FGuid> StandaloneHLODActorToSourceCellsMap;
};

// Size: 0xb8
class UWorldPartitionRuntimeLevelStreamingCell : public UWorldPartitionRuntimeCell {
    /* 0x00b0 */ UWorldPartitionLevelStreamingDynamic* LevelStreaming;

    void OnLevelHidden();
    void OnLevelShown();
};

// Size: 0x138
class UWorldPartitionRuntimeSpatialHash : public UWorldPartitionRuntimeHash {
    /* 0x0078 */ bool bEnableZCulling;
    /* 0x0079 */ FSpatialHashSettings Settings;
    /* 0x0080 */ TArray<FSpatialHashStreamingGrid> StreamingGrids;
    /* 0x00e8 */ TMap<FGuid, URuntimeSpatialHashExternalStreamingObject*> WorldAssetStreamingObjects;
};

// Size: 0x1
struct FWorldPartitionRuntimeSpatialHashGridPreviewer {
};

// Size: 0x58
class UWorldPartitionSettings : public UDeveloperSettings {
    /* 0x0038 */ EWorldPartitionDataLayersLogicOperator NewMapsDataLayersLogicOperator;
    /* 0x0039 */ bool bNewMapsEnableWorldPartition;
    /* 0x003a */ bool bNewMapsEnableWorldPartitionStreaming;
    /* 0x0040 */ UClass* EditorHashDefaultClass;
    /* 0x0048 */ UClass* RuntimeHashDefaultClass;
    /* 0x0050 */ UWorldPartitionPropertyOverridePolicy* PropertyOverridePolicy;
};

// Size: 0x340
class AWorldPartitionStandaloneHLOD : public AActor {
    /* 0x02b0 */ TSoftObjectPtr<UWorld> WorldAsset;
    /* 0x02d8 */ FGuid LevelInstanceSpawnGuid;
};

// Size: 0x30
class UWorldPartitionStandaloneHLODSubsystem : public UWorldSubsystem {
};

// Size: 0x3f0
class UWorldPartitionStreamingPolicy : public UObject {
    /* 0x0030 */ FWorldPartitionUpdateStreamingCurrentState CurrentState;
    /* 0x0130 */ EWorldPartitionStreamingPerformance CurrentStreamingPerformance;
    /* 0x0131 */ bool bCurrentBlockOnSlowStreaming;
    /* 0x0138 */ FWorldPartitionUpdateStreamingTargetState TargetState;
    /* 0x0180 */ FWorldPartitionUpdateStreamingCurrentState AsyncTaskCurrentState;
    /* 0x0280 */ FWorldPartitionUpdateStreamingTargetState AsyncTaskTargetState;
    /* 0x02c8 */ bool bShouldMergeStreamingSourceInfo;
};

// Size: 0x108
struct FWorldPartitionStreamingQuerySource {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ float Radius;
    /* 0x001c */ bool bUseGridLoadingRange;
    /* 0x0020 */ TArray<FName> DataLayers;
    /* 0x0030 */ bool bDataLayersOnly;
    /* 0x0031 */ bool bSpatialQuery;
};

// Size: 0x118
class UWorldPartitionStreamingSourceComponent : public UActorComponent {
    /* 0x00c0 */ EStreamingSourceTargetBehavior TargetBehavior;
    /* 0x00c8 */ TArray<FName> TargetGrids;
    /* 0x00d8 */ FName TargetGrid;
    /* 0x00e0 */ FColor DebugColor;
    /* 0x00e8 */ TArray<UHLODLayer*> TargetHLODLayers;
    /* 0x00f8 */ UHLODLayer* TargetHLODLayer;
    /* 0x0100 */ TArray<FStreamingSourceShape> Shapes;
    /* 0x0110 */ EStreamingSourcePriority Priority;
    /* 0x0111 */ bool bStreamingSourceEnabled;
    /* 0x0112 */ EStreamingSourceTargetState TargetState;

    void DisableStreamingSource();
    void EnableStreamingSource();
    bool IsStreamingCompleted() const;
    bool IsStreamingSourceEnabled() const;
};

// Size: 0x2f8
class UWorldPartitionSubsystem : public UTickableWorldSubsystem {

    bool IsAllStreamingCompleted();
    bool IsStreamingCompleted(EWorldPartitionRuntimeCellState QueryState, const TArray<FWorldPartitionStreamingQuerySource>& QuerySources, bool bExactState) const;
};

// Size: 0x100
struct FWorldPartitionUpdateStreamingCurrentState {
    /* 0x0010 */ TSet<UWorldPartitionRuntimeCell*> LoadedCells;
    /* 0x0060 */ FActivatedCells ActivatedCells;
};

// Size: 0x48
struct FWorldPartitionUpdateStreamingTargetState {
    /* 0x0000 */ TArray<UWorldPartitionRuntimeCell*> ToLoadCells;
    /* 0x0010 */ TArray<UWorldPartitionRuntimeCell*> ToActivateCells;
    /* 0x0020 */ TArray<UWorldPartitionRuntimeCell*> ToDeactivateCells;
    /* 0x0030 */ TArray<UWorldPartitionRuntimeCell*> ToUnloadCells;
};

// Size: 0x2e0
class AWorldPartitionVolume : public AVolume {
};

// Size: 0x4d8
class AWorldSettings : public AInfo {
    /* 0x02b0 */ int32_t VisibilityCellSize;
    /* 0x02b4 */ uint8_t VisibilityAggressiveness;
    /* 0x02b5 */ bool bPrecomputeVisibility;
    /* 0x02b5 */ bool bPlaceCellsOnlyAlongCameraTracks;
    /* 0x02b5 */ bool bEnableWorldBoundsChecks;
    /* 0x02b5 */ bool bEnableNavigationSystem;
    /* 0x02b5 */ bool bEnableAISystem;
    /* 0x02b5 */ bool bEnableWorldComposition;
    /* 0x02b5 */ bool bUseClientSideLevelStreamingVolumes;
    /* 0x02b5 */ bool bEnableWorldOriginRebasing;
    /* 0x02b6 */ bool bWorldGravitySet;
    /* 0x02b6 */ bool bGlobalGravitySet;
    /* 0x02b6 */ bool bMinimizeBSPSections;
    /* 0x02b6 */ bool bForceNoPrecomputedLighting;
    /* 0x02b6 */ bool bForceVolumetricLightmapsOnly;
    /* 0x02b6 */ bool bHighPriorityLoading;
    /* 0x02b6 */ bool bHighPriorityLoadingLocal;
    /* 0x02b6 */ bool bOverrideDefaultBroadphaseSettings;
    /* 0x02b7 */ bool bGenerateSingleClusterForLevel;
    /* 0x02b7 */ bool bAllowTimeDilation;
    /* 0x02b7 */ bool bReuseAddressAndPort;
    /* 0x02b8 */ TSoftClassPtr<UAISystemBase> AISystemClass;
    /* 0x02e0 */ FVector LevelInstancePivotOffset;
    /* 0x02f8 */ UNavigationSystemConfig* NavigationSystemConfig;
    /* 0x0300 */ UNavigationSystemConfig* NavigationSystemConfigOverride;
    /* 0x0308 */ UWorldPartition* WorldPartition;
    /* 0x0310 */ TArray<UDataLayerAsset*> BaseNavmeshDataLayers;
    /* 0x0320 */ float WorldToMeters;
    /* 0x0324 */ float KillZ;
    /* 0x0328 */ UClass* KillZDamageType;
    /* 0x0330 */ float WorldGravityZ;
    /* 0x0334 */ float GlobalGravityZ;
    /* 0x0338 */ UClass* DefaultPhysicsVolumeClass;
    /* 0x0340 */ UClass* PhysicsCollisionHandlerClass;
    /* 0x0348 */ UClass* DefaultGameMode;
    /* 0x0350 */ UClass* GameNetworkManagerClass;
    /* 0x0358 */ int32_t PackedLightAndShadowMapTextureSize;
    /* 0x0360 */ FVector DefaultColorScale;
    /* 0x0378 */ float DefaultMaxDistanceFieldOcclusionDistance;
    /* 0x037c */ float GlobalDistanceFieldViewDistance;
    /* 0x0380 */ float DynamicIndirectShadowsSelfShadowingIntensity;
    /* 0x0384 */ float VolumetricLightmapLoadingRange;
    /* 0x0388 */ FNaniteSettings NaniteSettings;
    /* 0x0390 */ FReverbSettings DefaultReverbSettings;
    /* 0x03b0 */ FInteriorSettings DefaultAmbientZoneSettings;
    /* 0x03d8 */ USoundMix* DefaultBaseSoundMix;
    /* 0x03e0 */ float TimeDilation;
    /* 0x03e4 */ float CinematicTimeDilation;
    /* 0x03e8 */ float DemoPlayTimeDilation;
    /* 0x03ec */ float MinGlobalTimeDilation;
    /* 0x03f0 */ float MaxGlobalTimeDilation;
    /* 0x03f4 */ float MinCinematicTimeDilation;
    /* 0x03f8 */ float MaxCinematicTimeDilation;
    /* 0x03fc */ float MinUndilatedFrameTime;
    /* 0x0400 */ float MaxUndilatedFrameTime;
    /* 0x0408 */ FBroadphaseSettings BroadphaseSettings;
    /* 0x0488 */ TArray<FNetViewer> ReplicationViewers;
    /* 0x0498 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x04a8 */ APlayerState* PauserPlayerState;
    /* 0x04b0 */ int32_t MaxNumberOfBookmarks;
    /* 0x04b8 */ UClass* DefaultBookmarkClass;
    /* 0x04c0 */ TArray<UBookmarkBase*> BookmarkArray;
    /* 0x04d0 */ UClass* LastBookmarkClass;

    void OnRep_NaniteSettings();
    void OnRep_WorldGravityZ();
};

// Size: 0x30
class UWorldSubsystem : public USubsystem {
};

// Size: 0x20
struct FWrappedStringElement {
    /* 0x0000 */ FString Value;
    /* 0x0010 */ FVector2D LineExtent;
};

// Size: 0x78
struct FActiveCameraAnimationInfo {
    /* 0x0000 */ UCameraAnimationSequence* Sequence;
    /* 0x0008 */ FCameraAnimationParams Params;
    /* 0x0050 */ FCameraAnimationHandle Handle;
    /* 0x0058 */ UCameraAnimationSequencePlayer* Player;
    /* 0x0060 */ UCameraAnimationSequenceCameraStandIn* CameraStandIn;
    /* 0x0068 */ float EaseInCurrentTime;
    /* 0x006c */ float EaseOutCurrentTime;
    /* 0x0070 */ bool bIsEasingIn;
    /* 0x0071 */ bool bIsEasingOut;
};

// Size: 0x60
class UCameraAnimationCameraModifier : public UCameraModifier {
    /* 0x0048 */ TArray<FActiveCameraAnimationInfo> ActiveAnimations;
    /* 0x0058 */ uint16_t NextInstanceSerialNumber;

    static UCameraAnimationCameraModifier* GetCameraAnimationCameraModifier(const UObject* WorldContextObject, int32_t PlayerIndex);
    static UCameraAnimationCameraModifier* GetCameraAnimationCameraModifierFromID(const UObject* WorldContextObject, int32_t ControllerId);
    static UCameraAnimationCameraModifier* GetCameraAnimationCameraModifierFromPlayerController(const APlayerController* PlayerController);
    bool IsCameraAnimationActive(const FCameraAnimationHandle& Handle) const;
    FCameraAnimationHandle PlayCameraAnimation(UCameraAnimationSequence* Sequence, FCameraAnimationParams Params);
    void StopAllCameraAnimations(bool bImmediate);
    void StopAllCameraAnimationsOf(UCameraAnimationSequence* Sequence, bool bImmediate);
    void StopCameraAnimation(const FCameraAnimationHandle& Handle, bool bImmediate);
};

// Size: 0x4
struct FCameraAnimationHandle {
};

// Size: 0x48
struct FCameraAnimationParams {
    /* 0x0000 */ float PlayRate;
    /* 0x0004 */ float Scale;
    /* 0x0008 */ ECameraAnimationEasingType EaseInType;
    /* 0x000c */ float EaseInDuration;
    /* 0x0010 */ ECameraAnimationEasingType EaseOutType;
    /* 0x0014 */ float EaseOutDuration;
    /* 0x0018 */ bool bLoop;
    /* 0x001c */ int32_t StartOffset;
    /* 0x0020 */ bool bRandomStartTime;
    /* 0x0024 */ float DurationOverride;
    /* 0x0028 */ ECameraAnimationPlaySpace PlaySpace;
    /* 0x0030 */ FRotator UserPlaySpaceRot;
};

// Size: 0x38
class UCompositeCameraShakePattern : public UCameraShakePattern {
    /* 0x0028 */ TArray<UCameraShakePattern*> ChildPatterns;
};

// Size: 0x88
class UConstantCameraShakePattern : public USimpleCameraShakePattern {
    /* 0x0058 */ FVector LocationOffset;
    /* 0x0070 */ FRotator RotationOffset;
};

// Size: 0xe0
class UDefaultCameraShakeBase : public UCameraShakeBase {
};

enum class ECameraAnimationEasingType {
    Linear = 0,
    Sinusoidal = 1,
    Quadratic = 2,
    Cubic = 3,
    Quartic = 4,
    Quintic = 5,
    Exponential = 6,
    Circular = 7,
    ECameraAnimationEasingType_MAX = 8,
};

enum class ECameraAnimationPlaySpace {
    CameraLocal = 0,
    World = 1,
    UserDefined = 2,
    ECameraAnimationPlaySpace_MAX = 3,
};

enum class EInitialOscillatorOffset {
    EOO_OffsetRandom = 0,
    EOO_OffsetZero = 1,
    EOO_MAX = 2,
};

enum class EInitialWaveOscillatorOffsetType {
    Random = 0,
    Zero = 1,
    EInitialWaveOscillatorOffsetType_MAX = 2,
};

enum class EOscillatorWaveform {
    SineWave = 0,
    PerlinNoise = 1,
    EOscillatorWaveform_MAX = 2,
};

// Size: 0x28
class UEngineCameraAnimationFunctionLibrary : public UBlueprintFunctionLibrary {

    static UCameraAnimationCameraModifier* Conv_CameraAnimationCameraModifier(APlayerCameraManager* PlayerCameraManager);
    static ECameraAnimationPlaySpace Conv_CameraAnimationPlaySpace(ECameraShakePlaySpace CameraShakePlaySpace);
    static ECameraShakePlaySpace Conv_CameraShakePlaySpace(ECameraAnimationPlaySpace CameraAnimationPlaySpace);
};

// Size: 0x30
class UEngineCamerasSubsystem : public UWorldSubsystem {

    bool IsCameraAnimationActive(APlayerController* PlayerController, const FCameraAnimationHandle& Handle) const;
    FCameraAnimationHandle PlayCameraAnimation(APlayerController* PlayerController, UCameraAnimationSequence* Sequence, FCameraAnimationParams Params);
    void StopAllCameraAnimations(APlayerController* PlayerController, bool bImmediate);
    void StopAllCameraAnimationsOf(APlayerController* PlayerController, UCameraAnimationSequence* Sequence, bool bImmediate);
    void StopCameraAnimation(APlayerController* PlayerController, const FCameraAnimationHandle& Handle, bool bImmediate);
};

// Size: 0xc
struct FFOscillator {
    /* 0x0000 */ float Amplitude;
    /* 0x0004 */ float Frequency;
    /* 0x0008 */ uint8_t InitialOffset;
    /* 0x0009 */ EOscillatorWaveform Waveform;
};

// Size: 0x1f0
class ULegacyCameraShake : public UCameraShakeBase {
    /* 0x00d8 */ float OscillationDuration;
    /* 0x00dc */ float OscillationBlendInTime;
    /* 0x00e0 */ float OscillationBlendOutTime;
    /* 0x00e4 */ FROscillator RotOscillation;
    /* 0x0108 */ FVOscillator LocOscillation;
    /* 0x012c */ FFOscillator FOVOscillation;
    /* 0x0138 */ float AnimPlayRate;
    /* 0x013c */ float AnimScale;
    /* 0x0140 */ float AnimBlendInTime;
    /* 0x0144 */ float AnimBlendOutTime;
    /* 0x0148 */ float RandomAnimSegmentDuration;
    /* 0x0150 */ UCameraAnimationSequence* AnimSequence;
    /* 0x0158 */ bool bRandomAnimSegment;
    /* 0x015c */ float OscillatorTimeRemaining;
    /* 0x01d8 */ USequenceCameraShakePattern* SequenceShakePattern;

    void BlueprintUpdateCameraShake(float deltaTime, float Alpha, const FMinimalViewInfo& POV, FMinimalViewInfo& ModifiedPOV);
    bool ReceiveIsFinished() const;
    void ReceivePlayShake(float Scale);
    void ReceiveStopShake(bool bImmediately);
    static ULegacyCameraShake* StartLegacyCameraShake(APlayerCameraManager* PlayerCameraManager, UClass* ShakeClass, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
    static ULegacyCameraShake* StartLegacyCameraShakeFromSource(APlayerCameraManager* PlayerCameraManager, UClass* ShakeClass, UCameraShakeSourceComponent* SourceComponent, float Scale, ECameraShakePlaySpace PlaySpace, FRotator UserPlaySpaceRot);
};

// Size: 0x28
class ULegacyCameraShakeFunctionLibrary : public UBlueprintFunctionLibrary {

    static ULegacyCameraShake* Conv_LegacyCameraShake(UCameraShakeBase* CameraShake);
};

// Size: 0x28
class ULegacyCameraShakePattern : public UCameraShakePattern {
};

// Size: 0xd8
class UPerlinNoiseCameraShakePattern : public USimpleCameraShakePattern {
    /* 0x0058 */ float LocationAmplitudeMultiplier;
    /* 0x005c */ float LocationFrequencyMultiplier;
    /* 0x0060 */ FPerlinNoiseShaker X;
    /* 0x0068 */ FPerlinNoiseShaker Y;
    /* 0x0070 */ FPerlinNoiseShaker Z;
    /* 0x0078 */ float RotationAmplitudeMultiplier;
    /* 0x007c */ float RotationFrequencyMultiplier;
    /* 0x0080 */ FPerlinNoiseShaker Pitch;
    /* 0x0088 */ FPerlinNoiseShaker Yaw;
    /* 0x0090 */ FPerlinNoiseShaker Roll;
    /* 0x0098 */ FPerlinNoiseShaker FOV;
};

// Size: 0x8
struct FPerlinNoiseShaker {
    /* 0x0000 */ float Amplitude;
    /* 0x0004 */ float Frequency;
};

// Size: 0x24
struct FROscillator {
    /* 0x0000 */ FFOscillator Pitch;
    /* 0x000c */ FFOscillator Yaw;
    /* 0x0018 */ FFOscillator Roll;
};

// Size: 0x58
class USimpleCameraShakePattern : public UCameraShakePattern {
    /* 0x0028 */ float Duration;
    /* 0x002c */ float BlendInTime;
    /* 0x0030 */ float BlendOutTime;
};

// Size: 0xe0
class UTestCameraShake : public UCameraShakeBase {
};

// Size: 0x24
struct FVOscillator {
    /* 0x0000 */ FFOscillator X;
    /* 0x000c */ FFOscillator Y;
    /* 0x0018 */ FFOscillator Z;
};

// Size: 0xc
struct FWaveOscillator {
    /* 0x0000 */ float Amplitude;
    /* 0x0004 */ float Frequency;
    /* 0x0008 */ EInitialWaveOscillatorOffsetType InitialOffsetType;
};

// Size: 0xf8
class UWaveOscillatorCameraShakePattern : public USimpleCameraShakePattern {
    /* 0x0058 */ float LocationAmplitudeMultiplier;
    /* 0x005c */ float LocationFrequencyMultiplier;
    /* 0x0060 */ FWaveOscillator X;
    /* 0x006c */ FWaveOscillator Y;
    /* 0x0078 */ FWaveOscillator Z;
    /* 0x0084 */ float RotationAmplitudeMultiplier;
    /* 0x0088 */ float RotationFrequencyMultiplier;
    /* 0x008c */ FWaveOscillator Pitch;
    /* 0x0098 */ FWaveOscillator Yaw;
    /* 0x00a4 */ FWaveOscillator Roll;
    /* 0x00b0 */ FWaveOscillator FOV;
};

// Size: 0x20
struct FEngineServiceAuthDeny {
    /* 0x0000 */ FString UserName;
    /* 0x0010 */ FString UserToDeny;
};

// Size: 0x20
struct FEngineServiceAuthGrant {
    /* 0x0000 */ FString UserName;
    /* 0x0010 */ FString UserToGrant;
};

// Size: 0x20
struct FEngineServiceExecuteCommand {
    /* 0x0000 */ FString Command;
    /* 0x0010 */ FString UserName;
};

// Size: 0x18
struct FEngineServiceNotification {
    /* 0x0000 */ FString Text;
    /* 0x0010 */ double TimeSeconds;
};

// Size: 0x1
struct FEngineServicePing {
};

// Size: 0x50
struct FEngineServicePong {
    /* 0x0000 */ FString CurrentLevel;
    /* 0x0010 */ int32_t EngineVersion;
    /* 0x0014 */ bool HasBegunPlay;
    /* 0x0018 */ FGuid InstanceId;
    /* 0x0028 */ FString InstanceType;
    /* 0x0038 */ FGuid SessionId;
    /* 0x0048 */ float WorldTimeSeconds;
};

// Size: 0x10
struct FEngineServiceTerminate {
    /* 0x0000 */ FString UserName;
};

// Size: 0x28
struct FTraceChannelPreset {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString ChannelList;
    /* 0x0020 */ bool bIsReadOnly;
};

// Size: 0x10
struct FTraceControlBookmark {
    /* 0x0000 */ FString Label;
};

// Size: 0x40
struct FTraceControlChannelsDesc {
    /* 0x0000 */ TArray<FString> Channels;
    /* 0x0010 */ TArray<uint32_t> Ids;
    /* 0x0020 */ TArray<FString> Descriptions;
    /* 0x0030 */ TArray<uint32_t> ReadOnlyIds;
};

// Size: 0x4
struct FTraceControlChannelsPing {
    /* 0x0000 */ uint32_t KnownChannelCount;
};

// Size: 0x20
struct FTraceControlChannelsSet {
    /* 0x0000 */ TArray<uint32_t> ChannelIdsToEnable;
    /* 0x0010 */ TArray<uint32_t> ChannelIdsToDisable;
};

// Size: 0x10
struct FTraceControlChannelsStatus {
    /* 0x0000 */ TArray<uint32_t> EnabledIds;
};

// Size: 0x88
struct FTraceControlDiscovery : public FTraceControlStatus {
    /* 0x0068 */ FGuid SessionId;
    /* 0x0078 */ FGuid InstanceId;
};

// Size: 0x20
struct FTraceControlDiscoveryPing {
    /* 0x0000 */ FGuid SessionId;
    /* 0x0010 */ FGuid InstanceId;
};

// Size: 0x30
struct FTraceControlFile : public FTraceControlStartCommon {
    /* 0x0018 */ FString File;
    /* 0x0028 */ bool bTruncateFile;
};

// Size: 0x1
struct FTraceControlPause {
};

// Size: 0x1
struct FTraceControlResume {
};

// Size: 0x18
struct FTraceControlScreenshot {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ bool bShowUI;
};

// Size: 0x28
struct FTraceControlSend : public FTraceControlStartCommon {
    /* 0x0018 */ FString Host;
};

// Size: 0x1
struct FTraceControlSetStatNamedEvents {
    /* 0x0000 */ bool bEnabled;
};

// Size: 0x18
struct FTraceControlSettings {
    /* 0x0000 */ bool bUseWorkerThread;
    /* 0x0001 */ bool bUseImportantCache;
    /* 0x0004 */ uint32_t TailSizeBytes;
    /* 0x0008 */ TArray<FTraceChannelPreset> ChannelPresets;
};

// Size: 0x1
struct FTraceControlSettingsPing {
};

// Size: 0x10
struct FTraceControlSnapshotFile {
    /* 0x0000 */ FString File;
};

// Size: 0x10
struct FTraceControlSnapshotSend {
    /* 0x0000 */ FString Host;
};

// Size: 0x18
struct FTraceControlStartCommon {
    /* 0x0000 */ FString Channels;
    /* 0x0010 */ bool bExcludeTail;
};

// Size: 0x68
struct FTraceControlStatus {
    /* 0x0000 */ FString Endpoint;
    /* 0x0010 */ FGuid SessionGuid;
    /* 0x0020 */ FGuid TraceGuid;
    /* 0x0030 */ uint64_t BytesSent;
    /* 0x0038 */ uint64_t BytesTraced;
    /* 0x0040 */ uint64_t MemoryUsed;
    /* 0x0048 */ uint32_t CacheAllocated;
    /* 0x004c */ uint32_t CacheUsed;
    /* 0x0050 */ uint32_t CacheWaste;
    /* 0x0054 */ bool bAreStatNamedEventsEnabled;
    /* 0x0055 */ bool bIsPaused;
    /* 0x0056 */ bool bIsTracing;
    /* 0x0058 */ FDateTime StatusTimestamp;
    /* 0x0060 */ uint8_t TraceSystemStatus;
};

// Size: 0x1
struct FTraceControlStatusPing {
};

// Size: 0x1
struct FTraceControlStop {
};

// Size: 0x28
struct FAutoCompleteCommand {
    /* 0x0000 */ FString Command;
    /* 0x0010 */ FString Desc;
};

// Size: 0x70
class UConsoleSettings : public UObject {
    /* 0x0028 */ int32_t MaxScrollbackSize;
    /* 0x0030 */ TArray<FAutoCompleteCommand> ManualAutoCompleteList;
    /* 0x0040 */ TArray<FString> AutoCompleteMapPaths;
    /* 0x0050 */ float BackgroundOpacityPercentage;
    /* 0x0054 */ bool bOrderTopToBottom;
    /* 0x0055 */ bool bDisplayHelpInAutoComplete;
    /* 0x0058 */ FColor InputColor;
    /* 0x005c */ FColor HistoryColor;
    /* 0x0060 */ FColor AutoCompleteCommandColor;
    /* 0x0064 */ FColor AutoCompleteCVarColor;
    /* 0x0068 */ FColor AutoCompleteFadedColor;
};

enum class EFourPlayerSplitScreenType {
    Grid = 0,
    Vertical = 1,
    Horizontal = 2,
    EFourPlayerSplitScreenType_MAX = 3,
};

enum class ESubLevelStripMode {
    ExactClass = 0,
    IsChildOf = 1,
    ESubLevelStripMode_MAX = 2,
};

enum class EThreePlayerSplitScreenType {
    FavorTop = 0,
    FavorBottom = 1,
    Vertical = 2,
    Horizontal = 3,
    EThreePlayerSplitScreenType_MAX = 4,
};

enum class ETwoPlayerSplitScreenType {
    Horizontal = 0,
    Vertical = 1,
    ETwoPlayerSplitScreenType_MAX = 2,
};

// Size: 0x120
class UGameMapsSettings : public UObject {
    /* 0x0028 */ FString LocalMapOptions;
    /* 0x0038 */ FSoftObjectPath TransitionMap;
    /* 0x0058 */ bool bUseSplitscreen;
    /* 0x0059 */ uint8_t TwoPlayerSplitscreenLayout;
    /* 0x005a */ uint8_t ThreePlayerSplitscreenLayout;
    /* 0x005b */ EFourPlayerSplitScreenType FourPlayerSplitscreenLayout;
    /* 0x005c */ bool bOffsetPlayerGamepadIds;
    /* 0x0060 */ FSoftClassPath GameInstanceClass;
    /* 0x0080 */ FSoftObjectPath GameDefaultMap;
    /* 0x00a0 */ FSoftObjectPath ServerDefaultMap;
    /* 0x00c0 */ FSoftClassPath GlobalDefaultGameMode;
    /* 0x00e0 */ FSoftClassPath GlobalDefaultServerGameMode;
    /* 0x0100 */ TArray<FGameModeName> GameModeMapPrefixes;
    /* 0x0110 */ TArray<FGameModeName> GameModeClassAliases;

    static UGameMapsSettings* GetGameMapsSettings();
    bool GetSkipAssigningGamepadToPlayer1() const;
    void SetSkipAssigningGamepadToPlayer1(bool bSkipFirstPlayer);
};

// Size: 0x30
struct FGameModeName {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FSoftClassPath GameMode;
};

// Size: 0x58
class UGameNetworkManagerSettings : public UObject {
    /* 0x0028 */ int32_t MinDynamicBandwidth;
    /* 0x002c */ int32_t MaxDynamicBandwidth;
    /* 0x0030 */ int32_t TotalNetBandwidth;
    /* 0x0034 */ int32_t BadPingThreshold;
    /* 0x0038 */ bool bIsStandbyCheckingEnabled;
    /* 0x003c */ float StandbyRxCheatTime;
    /* 0x0040 */ float StandbyTxCheatTime;
    /* 0x0044 */ float PercentMissingForRxStandby;
    /* 0x0048 */ float PercentMissingForTxStandby;
    /* 0x004c */ float PercentForBadPing;
    /* 0x0050 */ float JoinInProgressStandbyWaitTime;
};

// Size: 0x38
class UGameSessionSettings : public UObject {
    /* 0x0028 */ int32_t MaxSpectators;
    /* 0x002c */ int32_t MaxPlayers;
    /* 0x0030 */ bool bRequiresPushToTalk;
};

// Size: 0x28
class UGeneralEngineSettings : public UObject {
};

// Size: 0x110
class UGeneralProjectSettings : public UObject {
    /* 0x0028 */ FString CompanyName;
    /* 0x0038 */ FString CompanyDistinguishedName;
    /* 0x0048 */ FString CopyrightNotice;
    /* 0x0058 */ FString Description;
    /* 0x0068 */ FString Homepage;
    /* 0x0078 */ FString LicensingTerms;
    /* 0x0088 */ FString PrivacyPolicy;
    /* 0x0098 */ FGuid ProjectID;
    /* 0x00a8 */ FString ProjectName;
    /* 0x00b8 */ FString ProjectVersion;
    /* 0x00c8 */ FString SupportContact;
    /* 0x00d8 */ FText ProjectDisplayedTitle;
    /* 0x00e8 */ FText ProjectDebugTitleInfo;
    /* 0x00f8 */ bool bShouldWindowPreserveAspectRatio;
    /* 0x00f9 */ bool bUseBorderlessWindow;
    /* 0x00fa */ bool bStartInVR;
    /* 0x00fb */ bool bAllowWindowResize;
    /* 0x00fc */ bool bAllowClose;
    /* 0x00fd */ bool bAllowMaximize;
    /* 0x00fe */ bool bAllowMinimize;
    /* 0x0100 */ float EyeOffsetForFakeStereoRenderingDevice;
    /* 0x0104 */ float FOVForFakeStereoRenderingDevice;
    /* 0x0108 */ float TopFOVRatioForFakeStereoRenderingDevice;
    /* 0x010c */ float DifferenceBetweenEyesForFakeStereoRenderingDevice;
};

// Size: 0x40
class UHudSettings : public UObject {
    /* 0x0028 */ bool bShowHUD;
    /* 0x0030 */ TArray<FName> DebugDisplay;
};

// Size: 0x50
struct FTemplateMapInfoOverride {
    /* 0x0000 */ FSoftObjectPath Thumbnail;
    /* 0x0020 */ FSoftObjectPath Map;
    /* 0x0040 */ FText DisplayName;
};

// Size: 0x8
struct FAppliedInputContextData {
    /* 0x0000 */ int32_t Priority;
    /* 0x0004 */ int32_t RegistrationCount;
};

// Size: 0x18
struct FBlueprintEnhancedInputActionBinding {
    /* 0x0000 */ UInputAction* InputAction;
    /* 0x0008 */ ETriggerEvent TriggerEvent;
    /* 0x000c */ FName FunctionNameToBind;
};

// Size: 0x30
struct FBlueprintInputDebugKeyDelegateBinding {
    /* 0x0000 */ FInputChord InputChord;
    /* 0x0020 */ uint8_t InputKeyEvent;
    /* 0x0024 */ FName FunctionNameToBind;
    /* 0x002c */ bool bExecuteWhenPaused;
};

// Size: 0x30
struct FDefaultContextSetting {
    /* 0x0000 */ TSoftObjectPtr<UInputMappingContext> InputMappingContext;
    /* 0x0028 */ int32_t Priority;
    /* 0x002c */ bool bAddImmediately;
    /* 0x002d */ bool bRegisterWithUserSettings;
};

enum class EDeadZoneType {
    Axial = 0,
    Radial = 1,
    UnscaledRadial = 2,
    EDeadZoneType_MAX = 3,
};

enum class EFOVScalingType {
    Standard = 0,
    UE4_BackCompat = 1,
    EFOVScalingType_MAX = 2,
};

enum class EInputActionAccumulationBehavior {
    TakeHighestAbsoluteValue = 0,
    Cumulative = 1,
    EInputActionAccumulationBehavior_MAX = 2,
};

enum class EInputActionValueType {
    Boolean = 0,
    Axis1D = 1,
    Axis2D = 2,
    Axis3D = 3,
    EInputActionValueType_MAX = 4,
};

enum class EInputAxisSwizzle {
    YXZ = 0,
    ZYX = 1,
    XZY = 2,
    YZX = 3,
    ZXY = 4,
    EInputAxisSwizzle_MAX = 5,
};

enum class EInputMappingRebuildType {
    None = 0,
    Rebuild = 1,
    RebuildWithFlush = 2,
    EInputMappingRebuildType_MAX = 3,
};

enum class EMappingContextInputModeFilterOptions {
    UseProjectDefaultQuery = 0,
    UseCustomQuery = 1,
    DoNotFilter = 2,
    EMappingContextInputModeFilterOptions_MAX = 3,
};

enum class EMappingContextRegistrationTrackingMode {
    Untracked = 0,
    CountRegistrations = 1,
    EMappingContextRegistrationTrackingMode_MAX = 2,
};

enum class EMappingQueryIssue {
    NoIssue = 0,
    ReservedByAction = 1,
    HidesExistingMapping = 2,
    HiddenByExistingMapping = 4,
    CollisionWithMappingInSameContext = 8,
    ForcesTypePromotion = 16,
    ForcesTypeDemotion = 32,
    EMappingQueryIssue_MAX = 33,
};

enum class EMappingQueryResult {
    Error_EnhancedInputNotEnabled = 0,
    Error_InputContextNotInActiveContexts = 1,
    Error_InvalidAction = 2,
    NotMappable = 3,
    MappingAvailable = 4,
    EMappingQueryResult_MAX = 5,
};

enum class ENormalizeInputSmoothingType {
    None = 0,
    Lerp = 1,
    Interp_To = 2,
    Interp_Constant_To = 3,
    Interp_Circular_In = 4,
    Interp_Circular_Out = 5,
    Interp_Circular_In_Out = 6,
    Interp_Ease_In = 7,
    Interp_Ease_Out = 8,
    Interp_Ease_In_Out = 9,
    Interp_Expo_In = 10,
    Interp_Expo_Out = 11,
    Interp_Expo_In_Out = 12,
    Interp_Sin_In = 13,
    Interp_Sin_Out = 14,
    Interp_Sin_In_Out = 15,
    ENormalizeInputSmoothingType_MAX = 16,
};

enum class EPlayerMappableKeySettingBehaviors {
    InheritSettingsFromAction = 0,
    OverrideSettings = 1,
    IgnoreSettings = 2,
    EPlayerMappableKeySettingBehaviors_MAX = 3,
};

enum class EPlayerMappableKeySlot {
    First = 0,
    Second = 1,
    Third = 2,
    Fourth = 3,
    Fifth = 4,
    Sixth = 5,
    Seventh = 6,
    Unspecified = 7,
    Max = 8,
};

enum class ETriggerEvent {
    None = 0,
    Triggered = 1,
    Started = 2,
    Ongoing = 4,
    Canceled = 8,
    Completed = 16,
    ETriggerEvent_MAX = 17,
};

enum class ETriggerEventsSupported {
    None = 0,
    Instant = 1,
    Uninterruptible = 2,
    Ongoing = 4,
    All = 7,
    ETriggerEventsSupported_MAX = 8,
};

enum class ETriggerState {
    None = 0,
    Ongoing = 1,
    Triggered = 2,
    ETriggerState_MAX = 3,
};

enum class ETriggerType {
    Explicit = 0,
    Implicit = 1,
    Blocker = 2,
    ETriggerType_MAX = 3,
};

// Size: 0x50
struct FEnhancedActionKeyMapping {
    /* 0x0000 */ TArray<UInputTrigger*> Triggers;
    /* 0x0010 */ TArray<UInputModifier*> Modifiers;
    /* 0x0020 */ UInputAction* action;
    /* 0x0028 */ FKey Key;
    /* 0x0040 */ bool bShouldBeIgnored;
    /* 0x0040 */ bool bHasAlwaysTickTrigger;
    /* 0x0041 */ EPlayerMappableKeySettingBehaviors SettingBehavior;
    /* 0x0048 */ UPlayerMappableKeySettings* PlayerMappableKeySettings;
};

// Size: 0x38
class UEnhancedInputActionDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintEnhancedInputActionBinding> InputActionDelegateBindings;
};

// Size: 0x38
class UEnhancedInputActionValueBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintEnhancedInputActionBinding> InputActionValueBindings;
};

// Size: 0x178
class UEnhancedInputComponent : public UInputComponent {

    FInputActionValue GetBoundActionValue(const UInputAction* action) const;
};

// Size: 0x160
class UEnhancedInputDeveloperSettings : public UDeveloperSettingsBackedByCVars {
    /* 0x0038 */ TArray<FDefaultContextSetting> DefaultMappingContexts;
    /* 0x0048 */ TArray<FDefaultContextSetting> DefaultWorldSubsystemMappingContexts;
    /* 0x0058 */ FPerPlatformSettings PlatformSettings;
    /* 0x0068 */ TSoftClassPtr<UEnhancedInputUserSettings> UserSettingsClass;
    /* 0x0090 */ TSoftClassPtr<UEnhancedPlayerMappableKeyProfile> DefaultPlayerMappableKeyProfileClass;
    /* 0x00b8 */ FString InputSettingsSaveSlotName;
    /* 0x00c8 */ TSoftClassPtr<UEnhancedPlayerInput> DefaultWorldInputClass;
    /* 0x00f0 */ bool bSendTriggeredEventsWhenInputIsFlushed;
    /* 0x00f0 */ bool bEnableUserSettings;
    /* 0x00f0 */ bool bEnableDefaultMappingContexts;
    /* 0x00f0 */ bool bShouldOnlyTriggerLastActionInChord;
    /* 0x00f0 */ bool bEnableInputModeFiltering;
    /* 0x00f0 */ bool bEnableWorldSubsystem;
    /* 0x00f8 */ FGameplayTagQuery DefaultMappingContextInputModeQuery;
    /* 0x0140 */ FGameplayTagContainer DefaultInputMode;
};

// Size: 0x28
class UEnhancedInputLibrary : public UBlueprintFunctionLibrary {

    static void BreakInputActionValue(FInputActionValue InActionValue, double& X, double& Y, double& Z, EInputActionValueType& Type);
    static double Conv_InputActionValueToAxis1D(FInputActionValue InValue);
    static FVector2D Conv_InputActionValueToAxis2D(FInputActionValue InValue);
    static FVector Conv_InputActionValueToAxis3D(FInputActionValue ActionValue);
    static bool Conv_InputActionValueToBool(FInputActionValue InValue);
    static FString Conv_InputActionValueToString(FInputActionValue ActionValue);
    static FString Conv_TriggerEventValueToString(const ETriggerEvent TriggerEvent);
    static void FlushPlayerInput(APlayerController* PlayerController);
    static FInputActionValue GetBoundActionValue(AActor* Actor, const UInputAction* action);
    static FName GetMappingName(const FEnhancedActionKeyMapping& ActionKeyMapping);
    static UPlayerMappableKeySettings* GetPlayerMappableKeySettings(const FEnhancedActionKeyMapping& ActionKeyMapping);
    static bool IsActionKeyMappingPlayerMappable(const FEnhancedActionKeyMapping& ActionKeyMapping);
    static FInputActionValue MakeInputActionValueOfType(double X, double Y, double Z, const EInputActionValueType ValueType);
    static void RequestRebuildControlMappingsUsingContext(const UInputMappingContext* Context, bool bForceImmediately);
};

// Size: 0x208
class UEnhancedInputLocalPlayerSubsystem : public ULocalPlayerSubsystem {
    /* 0x0180 */ FMulticastInlineDelegate ControlMappingsRebuiltDelegate;
    /* 0x0190 */ FMulticastInlineDelegate OnMappingContextAdded;
    /* 0x01a0 */ FMulticastInlineDelegate OnMappingContextRemoved;
    /* 0x01b0 */ UEnhancedInputUserSettings* UserSettings;
    /* 0x01b8 */ TMap<UInputAction*, FInjectedInput> ContinuouslyInjectedInputs;

    void OnControlMappingsRebuilt__DelegateSignature();
    void OnMappingContextAdded__DelegateSignature(const UInputMappingContext* MappingContext);
    void OnMappingContextRemoved__DelegateSignature(const UInputMappingContext* MappingContext);
};

// Size: 0x78
class UEnhancedInputPlatformData : public UObject {
    /* 0x0028 */ TMap<UInputMappingContext*, UInputMappingContext*> MappingContextRedirects;

    UInputMappingContext* GetContextRedirect(UInputMappingContext* InContext) const;
};

// Size: 0x68
class UEnhancedInputPlatformSettings : public UPlatformSettings {
    /* 0x0040 */ TArray<TSoftClassPtr<UEnhancedInputPlatformData>> InputData;
    /* 0x0050 */ TArray<UClass*> InputDataClasses;
    /* 0x0060 */ bool bShouldLogMappingContextRedirects;
};

// Size: 0x28
class IEnhancedInputSubsystemInterface : public UInterface {

    void AddMappingContext(const UInputMappingContext* MappingContext, int32_t Priority, const FModifyContextOptions& Options);
    void AddTagToInputMode(const FGameplayTag& TagToAdd, const FModifyContextOptions& Options);
    void AppendTagsToInputMode(const FGameplayTagContainer& TagsToAdd, const FModifyContextOptions& Options);
    void ClearAllMappings();
    TArray<FEnhancedActionKeyMapping> GetAllPlayerMappableActionKeyMappings() const;
    FGameplayTagContainer GetInputMode() const;
    UEnhancedInputUserSettings* GetUserSettings() const;
    bool HasMappingContext(const UInputMappingContext* MappingContext, int32_t& OutFoundPriority) const;
    void InjectInputForAction(const UInputAction* action, FInputActionValue RawValue, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void InjectInputForPlayerMapping(const FName MappingName, FInputActionValue RawValue, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void InjectInputVectorForAction(const UInputAction* action, FVector Value, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void InjectInputVectorForPlayerMapping(const FName MappingName, FVector Value, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void OnUserKeyProfileChanged(const UEnhancedPlayerMappableKeyProfile* InNewProfile);
    void OnUserSettingsChanged(UEnhancedInputUserSettings* Settings);
    TArray<FKey> QueryKeysMappedToAction(const UInputAction* action) const;
    EMappingQueryResult QueryMapKeyInActiveContextSet(const UInputMappingContext* InputContext, const UInputAction* action, FKey Key, TArray<FMappingQueryIssue>& OutIssues, EMappingQueryIssue BlockingIssues);
    EMappingQueryResult QueryMapKeyInContextSet(const TArray<UInputMappingContext*>& PrioritizedActiveContexts, const UInputMappingContext* InputContext, const UInputAction* action, FKey Key, TArray<FMappingQueryIssue>& OutIssues, EMappingQueryIssue BlockingIssues);
    void RemoveMappingContext(const UInputMappingContext* MappingContext, const FModifyContextOptions& Options);
    void RemoveTagFromInputMode(const FGameplayTag& TagToRemove, const FModifyContextOptions& Options);
    void RemoveTagsFromInputMode(const FGameplayTagContainer& TagsToRemove, const FModifyContextOptions& Options);
    void RequestRebuildControlMappings(const FModifyContextOptions& Options, EInputMappingRebuildType RebuildType);
    void SetInputMode(const FGameplayTagContainer& NewMode, const FModifyContextOptions& Options);
    void StartContinuousInputInjectionForAction(const UInputAction* action, FInputActionValue RawValue, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void StartContinuousInputInjectionForPlayerMapping(const FName MappingName, FInputActionValue RawValue, const TArray<UInputModifier*>& Modifiers, const TArray<UInputTrigger*>& Triggers);
    void StopContinuousInputInjectionForAction(const UInputAction* action);
    void StopContinuousInputInjectionForPlayerMapping(const FName MappingName);
    void UpdateValueOfContinuousInputInjectionForAction(const UInputAction* action, FInputActionValue RawValue);
    void UpdateValueOfContinuousInputInjectionForPlayerMapping(const FName MappingName, FInputActionValue RawValue);
};

// Size: 0x180
class UEnhancedInputUserSettings : public USaveGame {
    /* 0x0030 */ FMulticastInlineDelegate OnSettingsChanged;
    /* 0x0040 */ FMulticastInlineDelegate OnSettingsApplied;
    /* 0x0070 */ FGameplayTag CurrentProfileIdentifier;
    /* 0x0078 */ FString CurrentProfileIdentifierString;
    /* 0x0088 */ TMap<FGameplayTag, UEnhancedPlayerMappableKeyProfile*> SavedKeyProfiles;
    /* 0x00d8 */ TMap<FString, UEnhancedPlayerMappableKeyProfile*> SavedKeyProfilesMap;
    /* 0x0128 */ TWeakObjectPtr<ULocalPlayer> OwningLocalPlayer;
    /* 0x0130 */ TSet<UInputMappingContext*> RegisteredMappingContexts;

    void ApplySettings();
    void AsyncSaveSettings();
    UEnhancedPlayerMappableKeyProfile* CreateNewKeyProfile(const FPlayerMappableKeyProfileCreationArgs& InArgs);
    void EnhancedInputUserSettingsApplied__DelegateSignature();
    void EnhancedInputUserSettingsChanged__DelegateSignature(UEnhancedInputUserSettings* Settings);
    TSet<FPlayerKeyMapping> FindMappingsInRow(const FName MappingName) const;
    UEnhancedPlayerMappableKeyProfile* GetActiveKeyProfile() const;
    FString GetActiveKeyProfileId() const;
    UEnhancedPlayerMappableKeyProfile* GetKeyProfileWithId(FString ProfileId) const;
    bool IsMappingContextRegistered(const UInputMappingContext* IMC) const;
    void MapPlayerKey(const FMapPlayerKeyArgs& InArgs, FGameplayTagContainer& FailureReason);
    void MappableKeyProfileChanged__DelegateSignature(const UEnhancedPlayerMappableKeyProfile* NewProfile);
    void MappingContextRegisteredWithSettings__DelegateSignature(const UInputMappingContext* IMC);
    bool RegisterInputMappingContext(const UInputMappingContext* IMC);
    bool RegisterInputMappingContexts(const TSet<UInputMappingContext*>& MappingContexts);
    void ResetAllPlayerKeysInRow(const FMapPlayerKeyArgs& InArgs, FGameplayTagContainer& FailureReason);
    void ResetKeyProfileIdToDefault(FString ProfileId, FGameplayTagContainer& FailureReason);
    void ResetKeyProfileToDefault(const FGameplayTag& ProfileId, FGameplayTagContainer& FailureReason);
    void SaveSettings();
    bool SetActiveKeyProfile(FString InProfileId);
    void UnMapPlayerKey(const FMapPlayerKeyArgs& InArgs, FGameplayTagContainer& FailureReason);
    bool UnregisterInputMappingContext(const UInputMappingContext* IMC);
    bool UnregisterInputMappingContexts(const TSet<UInputMappingContext*>& MappingContexts);
};

// Size: 0x1f8
class UEnhancedInputWorldSubsystem : public UWorldSubsystem {
    /* 0x0180 */ UEnhancedPlayerInput* PlayerInput;
    /* 0x0198 */ TArray<TWeakObjectPtr<UInputComponent>> CurrentInputStack;
    /* 0x01a8 */ TMap<UInputAction*, FInjectedInput> ContinuouslyInjectedInputs;

    void AddActorInputComponent(AActor* Actor);
    bool RemoveActorInputComponent(AActor* Actor);
};

// Size: 0x8b0
class UEnhancedPlayerInput : public UPlayerInput {
    /* 0x0498 */ TMap<UInputAction*, FKeyConsumptionOptions> KeyConsumptionData;
    /* 0x04e8 */ TMap<UInputAction*, FInputActionInstance> ActionInstanceData;
    /* 0x0538 */ TMap<UInputMappingContext*, FAppliedInputContextData> AppliedInputContextData;
    /* 0x0588 */ TMap<UInputMappingContext*, int32_t> AppliedInputContexts;
    /* 0x05d8 */ TArray<FEnhancedActionKeyMapping> EnhancedActionMappings;
    /* 0x05e8 */ FGameplayTagContainer CurrentInputMode;
    /* 0x0748 */ TMap<FKey, FVector> KeysPressedThisTick;
    /* 0x0798 */ TMap<UInputAction*, FInjectedInputArray> InputsInjectedThisTick;
    /* 0x07e8 */ TSet<UInputAction*> LastInjectedActions;
};

// Size: 0xa8
class UEnhancedPlayerMappableKeyProfile : public UObject {
    /* 0x0028 */ FGameplayTag ProfileIdentifier;
    /* 0x0030 */ FString ProfileIdentifierString;
    /* 0x0040 */ FPlatformUserId OwningUserId;
    /* 0x0048 */ FText DisplayName;
    /* 0x0058 */ TMap<FName, FKeyMappingRow> PlayerMappedKeys;

    bool DoesMappingPassQueryOptions(const FPlayerKeyMapping& PlayerMapping, const FPlayerMappableKeyQueryOptions& Options) const;
    void DumpProfileToLog() const;
    int32_t GetMappedKeysInRow(const FName MappingName, TArray<FKey>& OutKeys) const;
    int32_t GetMappingNamesForKey(const FKey& InKey, TArray<FName>& OutMappingNames) const;
    TMap<FName, FKeyMappingRow> GetPlayerMappingRows() const;
    FText GetProfileDisplayName() const;
    FString GetProfileIdString() const;
    void K2_FindKeyMapping(FPlayerKeyMapping& OutKeyMapping, const FMapPlayerKeyArgs& InArgs) const;
    int32_t QueryPlayerMappedKeys(const FPlayerMappableKeyQueryOptions& Options, TArray<FKey>& OutKeys) const;
    void ResetMappingToDefault(const FName InMappingName);
    void ResetToDefault();
    void SetDisplayName(const FText& NewDisplayName);
    FString ToString() const;
};

// Size: 0x40
struct FInjectedInput {
    /* 0x0020 */ TArray<UInputTrigger*> Triggers;
    /* 0x0030 */ TArray<UInputModifier*> Modifiers;
};

// Size: 0x10
struct FInjectedInputArray {
    /* 0x0000 */ TArray<FInjectedInput> Injected;
};

// Size: 0x78
class UInputAction : public UDataAsset {
    /* 0x0030 */ FText ActionDescription;
    /* 0x0040 */ bool bTriggerWhenPaused;
    /* 0x0041 */ bool bConsumeInput;
    /* 0x0042 */ bool bConsumesActionAndAxisMappings;
    /* 0x0043 */ bool bReserveAllMappings;
    /* 0x0044 */ int32_t TriggerEventsThatConsumeLegacyKeys;
    /* 0x0048 */ EInputActionValueType ValueType;
    /* 0x0049 */ EInputActionAccumulationBehavior AccumulationBehavior;
    /* 0x0050 */ TArray<UInputTrigger*> Triggers;
    /* 0x0060 */ TArray<UInputModifier*> Modifiers;
    /* 0x0070 */ UPlayerMappableKeySettings* PlayerMappableKeySettings;
};

// Size: 0x60
struct FInputActionInstance {
    /* 0x0000 */ UInputAction* SourceAction;
    /* 0x0013 */ ETriggerEvent TriggerEvent;
    /* 0x0014 */ float LastTriggeredWorldTime;
    /* 0x0018 */ TArray<UInputTrigger*> Triggers;
    /* 0x0028 */ TArray<UInputModifier*> Modifiers;
    /* 0x0058 */ float ElapsedProcessedTime;
    /* 0x005c */ float ElapsedTriggeredTime;
};

// Size: 0x20
struct FInputActionValue {
};

// Size: 0x10
struct FInputCancelAction {
    /* 0x0000 */ UInputAction* CancelAction;
    /* 0x0008 */ uint8_t CancellationStates;
};

// Size: 0x10
struct FInputComboStepData {
    /* 0x0000 */ UInputAction* ComboStepAction;
    /* 0x0008 */ uint8_t ComboStepCompletionStates;
    /* 0x000c */ float TimeToPressKey;
};

// Size: 0x38
class UInputDebugKeyDelegateBinding : public UInputDelegateBinding {
    /* 0x0028 */ TArray<FBlueprintInputDebugKeyDelegateBinding> InputDebugKeyDelegateBindings;
};

// Size: 0xa8
class UInputMappingContext : public UDataAsset {
    /* 0x0030 */ TArray<FEnhancedActionKeyMapping> Mappings;
    /* 0x0040 */ EMappingContextInputModeFilterOptions InputModeFilterOptions;
    /* 0x0048 */ FGameplayTagQuery InputModeQueryOverride;
    /* 0x0090 */ EMappingContextRegistrationTrackingMode RegistrationTrackingMode;
    /* 0x0098 */ FText ContextDescription;

    FEnhancedActionKeyMapping MapKey(const UInputAction* action, FKey ToKey);
    static bool ShouldShowInputModeQuery();
    void UnmapAll();
    void UnmapAllKeysFromAction(const UInputAction* action);
    void UnmapKey(const UInputAction* action, FKey Key);
};

// Size: 0x28
class UInputModifier : public UObject {

    FLinearColor GetVisualizationColor(FInputActionValue SampleValue, FInputActionValue FinalValue) const;
    FInputActionValue ModifyRaw(const UEnhancedPlayerInput* PlayerInput, FInputActionValue CurrentValue, float deltaTime) const;
};

// Size: 0x38
class UInputModifierDeadZone : public UInputModifier {
    /* 0x0028 */ float LowerThreshold;
    /* 0x002c */ float UpperThreshold;
    /* 0x0030 */ EDeadZoneType Type;
};

// Size: 0x30
class UInputModifierFOVScaling : public UInputModifier {
    /* 0x0028 */ float FOVScale;
    /* 0x002c */ EFOVScalingType FOVScalingType;
};

// Size: 0x30
class UInputModifierNegate : public UInputModifier {
    /* 0x0028 */ bool bX;
    /* 0x0029 */ bool bY;
    /* 0x002a */ bool bZ;
};

// Size: 0x40
class UInputModifierResponseCurveExponential : public UInputModifier {
    /* 0x0028 */ FVector CurveExponent;
};

// Size: 0x40
class UInputModifierResponseCurveUser : public UInputModifier {
    /* 0x0028 */ UCurveFloat* ResponseX;
    /* 0x0030 */ UCurveFloat* ResponseY;
    /* 0x0038 */ UCurveFloat* ResponseZ;
};

// Size: 0x40
class UInputModifierScalar : public UInputModifier {
    /* 0x0028 */ FVector Scalar;
};

// Size: 0x28
class UInputModifierScaleByDeltaTime : public UInputModifier {
};

// Size: 0x58
class UInputModifierSmooth : public UInputModifier {
};

// Size: 0x68
class UInputModifierSmoothDelta : public UInputModifier {
    /* 0x0028 */ ENormalizeInputSmoothingType SmoothingMethod;
    /* 0x002c */ float Speed;
    /* 0x0030 */ float EasingExponent;
};

// Size: 0x30
class UInputModifierSwizzleAxis : public UInputModifier {
    /* 0x0028 */ EInputAxisSwizzle order;
};

// Size: 0x28
class UInputModifierToWorldSpace : public UInputModifier {
};

// Size: 0x50
class UInputTrigger : public UObject {
    /* 0x0028 */ float ActuationThreshold;
    /* 0x002c */ bool bShouldAlwaysTick;
    /* 0x0030 */ FInputActionValue LastValue;

    ETriggerType GetTriggerType() const;
    bool IsActuated(const FInputActionValue& ForValue) const;
    ETriggerState UpdateState(const UEnhancedPlayerInput* PlayerInput, FInputActionValue ModifiedValue, float deltaTime);
};

// Size: 0x58
class UInputTriggerChordAction : public UInputTrigger {
    /* 0x0050 */ UInputAction* ChordAction;
};

// Size: 0x58
class UInputTriggerChordBlocker : public UInputTriggerChordAction {
};

// Size: 0x78
class UInputTriggerCombo : public UInputTrigger {
    /* 0x0050 */ int32_t CurrentComboStepIndex;
    /* 0x0054 */ float CurrentTimeBetweenComboSteps;
    /* 0x0058 */ TArray<FInputComboStepData> ComboActions;
    /* 0x0068 */ TArray<FInputCancelAction> InputCancelActions;
};

// Size: 0x50
class UInputTriggerDown : public UInputTrigger {
};

// Size: 0x68
class UInputTriggerHold : public UInputTriggerTimedBase {
    /* 0x005c */ float HoldTimeThreshold;
    /* 0x0060 */ bool bIsOneShot;
};

// Size: 0x60
class UInputTriggerHoldAndRelease : public UInputTriggerTimedBase {
    /* 0x0058 */ float HoldTimeThreshold;
};

// Size: 0x50
class UInputTriggerPressed : public UInputTrigger {
};

// Size: 0x68
class UInputTriggerPulse : public UInputTriggerTimedBase {
    /* 0x005c */ bool bTriggerOnStart;
    /* 0x0060 */ float interval;
    /* 0x0064 */ int32_t TriggerLimit;
};

// Size: 0x50
class UInputTriggerReleased : public UInputTrigger {
};

// Size: 0x78
class UInputTriggerRepeatedTap : public UInputTriggerTimedBase {
    /* 0x0058 */ double RepeatDelay;
    /* 0x0060 */ double RepeatTime;
    /* 0x0068 */ int32_t NumberOfTapsWhichTriggerRepeat;
    /* 0x006c */ float TapReleaseTimeThreshold;
    /* 0x0070 */ int32_t NumberOfTapsSinceLastTrigger;
};

// Size: 0x60
class UInputTriggerTap : public UInputTriggerTimedBase {
    /* 0x0058 */ float TapReleaseTimeThreshold;
};

// Size: 0x58
class UInputTriggerTimedBase : public UInputTrigger {
    /* 0x0050 */ float HeldDuration;
    /* 0x0054 */ bool bAffectedByTimeDilation;
};

// Size: 0x18
struct FKeyConsumptionOptions {
};

// Size: 0x50
struct FKeyMappingRow {
    /* 0x0000 */ TSet<FPlayerKeyMapping> Mappings;
};

// Size: 0x50
struct FMapPlayerKeyArgs {
    /* 0x0000 */ FName MappingName;
    /* 0x0008 */ EPlayerMappableKeySlot Slot;
    /* 0x0010 */ FKey NewKey;
    /* 0x0028 */ FName HardwareDeviceId;
    /* 0x0030 */ FGameplayTag ProfileId;
    /* 0x0038 */ FString ProfileIdString;
    /* 0x0048 */ bool bCreateMatchingSlotIfNeeded;
    /* 0x0048 */ bool bDeferOnSettingsChangedBroadcast;
};

// Size: 0x18
struct FMappingQueryIssue {
    /* 0x0000 */ EMappingQueryIssue Issue;
    /* 0x0008 */ UInputMappingContext* BlockingContext;
    /* 0x0010 */ UInputAction* BlockingAction;
};

// Size: 0x1
struct FModifyContextOptions {
    /* 0x0000 */ bool bIgnoreAllPressedKeysUntilRelease;
    /* 0x0000 */ bool bForceImmediately;
    /* 0x0000 */ bool bNotifyUserSettings;
};

// Size: 0xa8
struct FPlayerKeyMapping {
    /* 0x0000 */ FName MappingName;
    /* 0x0008 */ FText DisplayName;
    /* 0x0018 */ FText DisplayCategory;
    /* 0x0028 */ EPlayerMappableKeySlot Slot;
    /* 0x0029 */ bool bIsDirty;
    /* 0x0030 */ FKey DefaultKey;
    /* 0x0048 */ FKey CurrentKey;
    /* 0x0060 */ FHardwareDeviceIdentifier HardwareDeviceId;
    /* 0x0078 */ UInputAction* AssociatedInputAction;
    /* 0x0080 */ TSoftObjectPtr<UInputAction> AssociatedInputActionSoft;
};

// Size: 0xa8
class UPlayerMappableInputConfig : public UPrimaryDataAsset {
    /* 0x0030 */ FName ConfigName;
    /* 0x0038 */ FText ConfigDisplayName;
    /* 0x0048 */ bool bIsDeprecated;
    /* 0x0050 */ UObject* MetaData;
    /* 0x0058 */ TMap<UInputMappingContext*, int32_t> Contexts;

    FName GetConfigName() const;
    FText GetDisplayName() const;
    TArray<FEnhancedActionKeyMapping> GetKeysBoundToAction(const UInputAction* InAction) const;
    FEnhancedActionKeyMapping GetMappingByName(const FName MappingName) const;
    TMap<UInputMappingContext*, int32_t> GetMappingContexts() const;
    UObject* GetMetadata() const;
    TArray<FEnhancedActionKeyMapping> GetPlayerMappableKeys() const;
    bool IsDeprecated() const;
    void ResetToDefault();
};

// Size: 0x40
struct FPlayerMappableKeyProfileCreationArgs {
    /* 0x0000 */ UClass* ProfileType;
    /* 0x0008 */ FGameplayTag ProfileIdentifier;
    /* 0x0010 */ FString ProfileStringIdentifier;
    /* 0x0020 */ FPlatformUserId UserId;
    /* 0x0028 */ FText DisplayName;
    /* 0x0038 */ bool bSetAsCurrentProfile;
};

// Size: 0x28
struct FPlayerMappableKeyQueryOptions {
    /* 0x0000 */ FName MappingName;
    /* 0x0008 */ FKey KeyToMatch;
    /* 0x0020 */ EPlayerMappableKeySlot SlotToMatch;
    /* 0x0021 */ bool bMatchBasicKeyTypes;
    /* 0x0021 */ bool bMatchKeyAxisType;
    /* 0x0022 */ EHardwareDevicePrimaryType RequiredDeviceType;
    /* 0x0024 */ int32_t RequiredDeviceFlags;
};

// Size: 0x88
class UPlayerMappableKeySettings : public UObject {
    /* 0x0028 */ UObject* MetaData;
    /* 0x0030 */ FName Name;
    /* 0x0038 */ FText DisplayName;
    /* 0x0048 */ FText DisplayCategory;
    /* 0x0058 */ FGameplayTagContainer SupportedKeyProfiles;
    /* 0x0078 */ TArray<FString> SupportedKeyProfileIds;
};

enum class EEyeTrackerStatus {
    NotConnected = 0,
    NotTracking = 1,
    Tracking = 2,
    EEyeTrackerStatus_MAX = 3,
};

// Size: 0x28
class UEyeTrackerFunctionLibrary : public UBlueprintFunctionLibrary {

    static bool GetGazeData(FEyeTrackerGazeData& OutGazeData);
    static bool GetStereoGazeData(FEyeTrackerStereoGazeData& OutGazeData);
    static bool IsEyeTrackerConnected();
    static bool IsStereoGazeDataAvailable();
    static void SetEyeTrackedPlayer(APlayerController* PlayerController);
};

// Size: 0x58
struct FEyeTrackerGazeData {
    /* 0x0000 */ FVector GazeOrigin;
    /* 0x0018 */ FVector GazeDirection;
    /* 0x0030 */ FVector FixationPoint;
    /* 0x0048 */ float ConfidenceValue;
    /* 0x004c */ bool bIsLeftEyeBlink;
    /* 0x004d */ bool bIsRightEyeBlink;
    /* 0x0050 */ float LeftPupilDiameter;
    /* 0x0054 */ float RightPupilDiameter;
};

// Size: 0x80
struct FEyeTrackerStereoGazeData {
    /* 0x0000 */ FVector LeftEyeOrigin;
    /* 0x0018 */ FVector LeftEyeDirection;
    /* 0x0030 */ FVector RightEyeOrigin;
    /* 0x0048 */ FVector RightEyeDirection;
    /* 0x0060 */ FVector FixationPoint;
    /* 0x0078 */ float ConfidenceValue;
};

enum class EFFXFSR4DeDitherMode {
    Off = 0,
    Full = 1,
    HairOnly = 2,
    EFFXFSR4DeDitherMode_MAX = 3,
};

enum class EFFXFSR4FrameGenUIMode {
    SlateRedraw = 0,
    UIExtraction = 1,
    EFFXFSR4FrameGenUIMode_MAX = 2,
};

enum class EFFXFSR4HistoryFormat {
    FloatRGBA = 0,
    FloatR11G11B10 = 1,
    EFFXFSR4HistoryFormat_MAX = 2,
};

enum class EFFXFSR4LandscapeHISMMode {
    Off = 0,
    AllStatic = 1,
    StaticWPO = 2,
    EFFXFSR4LandscapeHISMMode_MAX = 3,
};

enum class EFFXFSR4PaceRHIFrameMode {
    None = 0,
    CustomPresentVSync = 1,
    EFFXFSR4PaceRHIFrameMode_MAX = 2,
};

enum class EFFXFSR4QualityMode {
    NativeAA = 0,
    Quality = 1,
    Balanced = 2,
    Performance = 3,
    UltraPerformance = 4,
    EFFXFSR4QualityMode_MAX = 5,
};

// Size: 0xc8
class UFFXFSR4Settings : public UDeveloperSettings {
    /* 0x0038 */ bool bEnabled;
    /* 0x0039 */ bool bAutoExposure;
    /* 0x003a */ bool bEnabledInEditorViewport;
    /* 0x003b */ bool bUseSSRExperimentalDenoiser;
    /* 0x003c */ bool bFrameGenEnabled;
    /* 0x003d */ bool bCaptureDebugUI;
    /* 0x003e */ bool bUpdateGlobalFrameTime;
    /* 0x003f */ bool bModifySlateDeltaTime;
    /* 0x0040 */ EFFXFSR4FrameGenUIMode UIMode;
    /* 0x0044 */ bool bUseDistortionTexture;
    /* 0x0045 */ bool bD3D12AsyncInterpolation;
    /* 0x0046 */ bool bD3D12AsyncPresent;
    /* 0x0048 */ EFFXFSR4QualityMode QualityMode;
    /* 0x004c */ EFFXFSR4HistoryFormat HistoryFormat;
    /* 0x0050 */ EFFXFSR4DeDitherMode DeDither;
    /* 0x0054 */ float Sharpness;
    /* 0x0058 */ bool bAdjustMipBias;
    /* 0x0059 */ bool bForceVertexDeformationOutputsVelocity;
    /* 0x005c */ EFFXFSR4LandscapeHISMMode ForceLandscapeHISMMobility;
    /* 0x0060 */ float VelocityFactor;
    /* 0x0064 */ bool bReactiveMask;
    /* 0x0068 */ float ReflectionScale;
    /* 0x006c */ float ReflectionLuminanceBias;
    /* 0x0070 */ float RoughnessScale;
    /* 0x0074 */ float RoughnessBias;
    /* 0x0078 */ float RoughnessMaxDistance;
    /* 0x007c */ bool bReactiveMaskRoughnessForceMaxDistance;
    /* 0x0080 */ float TranslucencyBias;
    /* 0x0084 */ float TranslucencyLuminanceBias;
    /* 0x0088 */ float TranslucencyMaxDistance;
    /* 0x008c */ uint8_t ReactiveShadingModelID;
    /* 0x0090 */ float ForceReactiveMaterialValue;
    /* 0x0094 */ float ReactiveHistoryTranslucencyBias;
    /* 0x0098 */ float ReactiveHistoryTranslucencyLumaBias;
    /* 0x009c */ float PreDOFTranslucencyScale;
    /* 0x00a0 */ bool bPreDOFTranslucencyMax;
    /* 0x00a4 */ float ReactiveMaskDeferredDecalScale;
    /* 0x00a8 */ float ReactiveHistoryDeferredDecalScale;
    /* 0x00ac */ float ReactiveMaskTAAResponsiveValue;
    /* 0x00b0 */ float ReactiveHistoryTAAResponsiveValue;
    /* 0x00b4 */ float ReactiveMaskCustomStencilScale;
    /* 0x00b8 */ float ReactiveHistoryCustomStencilScale;
    /* 0x00bc */ int32_t CustomStencilMask;
    /* 0x00c0 */ int32_t CustomStencilShift;
};

// Size: 0xc70
class UAudioCurveSourceComponent : public UAudioComponent {
    /* 0x0c38 */ FName CurveSourceBindingName;
    /* 0x0c40 */ float CurveSyncOffset;
};

// Size: 0x8
struct FFieldNotificationId {
    /* 0x0000 */ FName FieldName;
};

// Size: 0x28
class INotifyFieldValueChanged : public UInterface {
};

// Size: 0x140
class UBoxFalloff : public UFieldNodeFloat {
    /* 0x00b8 */ float Magnitude;
    /* 0x00bc */ float MinRange;
    /* 0x00c0 */ float MaxRange;
    /* 0x00c4 */ float Default;
    /* 0x00d0 */ FTransform Transform;
    /* 0x0130 */ uint8_t Falloff;

    UBoxFalloff* SetBoxFalloff(float Magnitude, float MinRange, float MaxRange, float Default, FTransform Transform, uint8_t Falloff);
};

// Size: 0xd0
class UCullingField : public UFieldNodeBase {
    /* 0x00b8 */ UFieldNodeBase* Culling;
    /* 0x00c0 */ UFieldNodeBase* Field;
    /* 0x00c8 */ uint8_t Operation;

    UCullingField* SetCullingField(const UFieldNodeBase* Culling, const UFieldNodeBase* Field, uint8_t Operation);
};

// Size: 0xb8
class UFieldNodeBase : public UActorComponent {
};

// Size: 0xb8
class UFieldNodeFloat : public UFieldNodeBase {
};

// Size: 0xb8
class UFieldNodeInt : public UFieldNodeBase {
};

// Size: 0xb8
class UFieldNodeVector : public UFieldNodeBase {
};

// Size: 0x30
struct FFieldObjectCommands {
    /* 0x0000 */ TArray<FName> TargetNames;
    /* 0x0010 */ TArray<UFieldNodeBase*> RootNodes;
    /* 0x0020 */ TArray<UFieldSystemMetaData*> MetaDatas;
};

// Size: 0x38
class UFieldSystem : public UObject {
};

// Size: 0x2b0
class AFieldSystemActor : public AActor {
    /* 0x02a8 */ UFieldSystemComponent* FieldSystemComponent;
};

// Size: 0x5f0
class UFieldSystemComponent : public UPrimitiveComponent {
    /* 0x0520 */ UFieldSystem* FieldSystem;
    /* 0x0528 */ bool bIsWorldField;
    /* 0x0529 */ bool bIsChaosField;
    /* 0x0530 */ TArray<TSoftObjectPtr<AChaosSolverActor>> SupportedSolvers;
    /* 0x0540 */ FFieldObjectCommands ConstructionCommands;
    /* 0x0570 */ FFieldObjectCommands BufferCommands;

    void AddFieldCommand(bool Enabled, uint8_t Target, UFieldSystemMetaData* MetaData, UFieldNodeBase* Field);
    void AddPersistentField(bool Enabled, uint8_t Target, UFieldSystemMetaData* MetaData, UFieldNodeBase* Field);
    void ApplyLinearForce(bool Enabled, FVector Direction, float Magnitude);
    void ApplyPhysicsField(bool Enabled, uint8_t Target, UFieldSystemMetaData* MetaData, UFieldNodeBase* Field);
    void ApplyRadialForce(bool Enabled, FVector position, float Magnitude);
    void ApplyRadialVectorFalloffForce(bool Enabled, FVector position, float Radius, float Magnitude);
    void ApplyStayDynamicField(bool Enabled, FVector position, float Radius);
    void ApplyStrainField(bool Enabled, FVector position, float Radius, float Magnitude, int32_t Iterations);
    void ApplyUniformVectorFalloffForce(bool Enabled, FVector position, FVector Direction, float Radius, float Magnitude);
    void RemovePersistentFields();
    void ResetFieldSystem();
};

// Size: 0xb8
class UFieldSystemMetaData : public UActorComponent {
};

// Size: 0xc0
class UFieldSystemMetaDataFilter : public UFieldSystemMetaData {
    /* 0x00b8 */ uint8_t FilterType;
    /* 0x00b9 */ uint8_t ObjectType;
    /* 0x00ba */ uint8_t PositionType;

    UFieldSystemMetaDataFilter* SetMetaDataFilterType(uint8_t FilterType, uint8_t ObjectType, uint8_t PositionType);
};

// Size: 0xc0
class UFieldSystemMetaDataIteration : public UFieldSystemMetaData {
    /* 0x00b8 */ int32_t Iterations;

    UFieldSystemMetaDataIteration* SetMetaDataIteration(int32_t Iterations);
};

// Size: 0xc0
class UFieldSystemMetaDataProcessingResolution : public UFieldSystemMetaData {
    /* 0x00b8 */ uint8_t ResolutionType;

    UFieldSystemMetaDataProcessingResolution* SetMetaDataaProcessingResolutionType(uint8_t ResolutionType);
};

// Size: 0x120
class UNoiseField : public UFieldNodeFloat {
    /* 0x00b8 */ float MinRange;
    /* 0x00bc */ float MaxRange;
    /* 0x00c0 */ FTransform Transform;

    UNoiseField* SetNoiseField(float MinRange, float MaxRange, FTransform Transform);
};

// Size: 0xd8
class UOperatorField : public UFieldNodeBase {
    /* 0x00b8 */ float Magnitude;
    /* 0x00c0 */ UFieldNodeBase* RightField;
    /* 0x00c8 */ UFieldNodeBase* LeftField;
    /* 0x00d0 */ uint8_t Operation;

    UOperatorField* SetOperatorField(float Magnitude, const UFieldNodeBase* LeftField, const UFieldNodeBase* RightField, uint8_t Operation);
};

// Size: 0x108
class UPlaneFalloff : public UFieldNodeFloat {
    /* 0x00b8 */ float Magnitude;
    /* 0x00bc */ float MinRange;
    /* 0x00c0 */ float MaxRange;
    /* 0x00c4 */ float Default;
    /* 0x00c8 */ float Distance;
    /* 0x00d0 */ FVector position;
    /* 0x00e8 */ FVector Normal;
    /* 0x0100 */ uint8_t Falloff;

    UPlaneFalloff* SetPlaneFalloff(float Magnitude, float MinRange, float MaxRange, float Default, float Distance, FVector position, FVector Normal, uint8_t Falloff);
};

// Size: 0xf0
class URadialFalloff : public UFieldNodeFloat {
    /* 0x00b8 */ float Magnitude;
    /* 0x00bc */ float MinRange;
    /* 0x00c0 */ float MaxRange;
    /* 0x00c4 */ float Default;
    /* 0x00c8 */ float Radius;
    /* 0x00d0 */ FVector position;
    /* 0x00e8 */ uint8_t Falloff;

    URadialFalloff* SetRadialFalloff(float Magnitude, float MinRange, float MaxRange, float Default, float Radius, FVector position, uint8_t Falloff);
};

// Size: 0xe8
class URadialIntMask : public UFieldNodeInt {
    /* 0x00b8 */ float Radius;
    /* 0x00c0 */ FVector position;
    /* 0x00d8 */ int32_t InteriorValue;
    /* 0x00dc */ int32_t ExteriorValue;
    /* 0x00e0 */ uint8_t SetMaskCondition;

    URadialIntMask* SetRadialIntMask(float Radius, FVector position, int32_t InteriorValue, int32_t ExteriorValue, uint8_t SetMaskConditionIn);
};

// Size: 0xd8
class URadialVector : public UFieldNodeVector {
    /* 0x00b8 */ float Magnitude;
    /* 0x00c0 */ FVector position;

    URadialVector* SetRadialVector(float Magnitude, FVector position);
};

// Size: 0xc0
class URandomVector : public UFieldNodeVector {
    /* 0x00b8 */ float Magnitude;

    URandomVector* SetRandomVector(float Magnitude);
};

// Size: 0xb8
class UReturnResultsTerminal : public UFieldNodeBase {

    UReturnResultsTerminal* SetReturnResultsTerminal();
};

// Size: 0xc0
class UToFloatField : public UFieldNodeFloat {
    /* 0x00b8 */ UFieldNodeInt* IntField;

    UToFloatField* SetToFloatField(const UFieldNodeInt* IntegerField);
};

// Size: 0xc0
class UToIntegerField : public UFieldNodeInt {
    /* 0x00b8 */ UFieldNodeFloat* FloatField;

    UToIntegerField* SetToIntegerField(const UFieldNodeFloat* FloatField);
};

// Size: 0xc0
class UUniformInteger : public UFieldNodeInt {
    /* 0x00b8 */ int32_t Magnitude;

    UUniformInteger* SetUniformInteger(int32_t Magnitude);
};

// Size: 0xc0
class UUniformScalar : public UFieldNodeFloat {
    /* 0x00b8 */ float Magnitude;

    UUniformScalar* SetUniformScalar(float Magnitude);
};

// Size: 0xd8
class UUniformVector : public UFieldNodeVector {
    /* 0x00b8 */ float Magnitude;
    /* 0x00c0 */ FVector Direction;

    UUniformVector* SetUniformVector(float Magnitude, FVector Direction);
};

// Size: 0xe8
class UWaveScalar : public UFieldNodeFloat {
    /* 0x00b8 */ float Magnitude;
    /* 0x00c0 */ FVector position;
    /* 0x00d8 */ float Wavelength;
    /* 0x00dc */ float Period;
    /* 0x00e0 */ uint8_t Function;
    /* 0x00e1 */ uint8_t Falloff;

    UWaveScalar* SetWaveScalar(float Magnitude, FVector position, float Wavelength, float Period, float Time, uint8_t Function, uint8_t Falloff);
};

enum class EFoliageScaling {
    Uniform = 0,
    Free = 1,
    LockXY = 2,
    LockXZ = 3,
    LockYZ = 4,
    EFoliageScaling_MAX = 5,
};

enum class ESimulationOverlap {
    CollisionOverlap = 0,
    ShadeOverlap = 1,
    None = 2,
    ESimulationOverlap_MAX = 3,
};

enum class ESimulationQuery {
    None = 0,
    CollisionOverlap = 1,
    ShadeOverlap = 2,
    AnyOverlap = 3,
    ESimulationQuery_MAX = 4,
};

enum class EVertexColorMaskChannel {
    Red = 0,
    Green = 1,
    Blue = 2,
    Alpha = 3,
    MAX_None = 4,
    EVertexColorMaskChannel_MAX = 5,
};

// Size: 0x90
struct FFoliageDensityFalloff {
    /* 0x0000 */ bool bUseFalloffCurve;
    /* 0x0008 */ FRuntimeFloatCurve FalloffCurve;
};

// Size: 0xb80
class UFoliageInstancedStaticMeshComponent : public UHierarchicalInstancedStaticMeshComponent {
    /* 0x0b48 */ FMulticastInlineDelegate OnInstanceTakePointDamage;
    /* 0x0b58 */ FMulticastInlineDelegate OnInstanceTakeRadialDamage;
    /* 0x0b68 */ bool bEnableDiscardOnLoad;
    /* 0x0b6c */ FGuid GenerationGuid;
};

// Size: 0x28
class UFoliageStatistics : public UBlueprintFunctionLibrary {

    static int32_t FoliageOverlappingBoxCount(UObject* WorldContextObject, const UStaticMesh* StaticMesh, FBox Box);
    static void FoliageOverlappingBoxTransforms(UObject* WorldContextObject, const UStaticMesh* StaticMesh, FBox Box, TArray<FTransform>& OutTransforms);
    static int32_t FoliageOverlappingSphereCount(UObject* WorldContextObject, const UStaticMesh* StaticMesh, FVector CenterPosition, float Radius);
};

// Size: 0x4b0
class UFoliageType : public UObject {
    /* 0x0028 */ FGuid UpdateGuid;
    /* 0x0038 */ float Density;
    /* 0x003c */ float DensityAdjustmentFactor;
    /* 0x0040 */ float Radius;
    /* 0x0044 */ bool bSingleInstanceModeOverrideRadius;
    /* 0x0048 */ float SingleInstanceModeRadius;
    /* 0x004c */ EFoliageScaling Scaling;
    /* 0x0050 */ FFloatInterval ScaleX;
    /* 0x0058 */ FFloatInterval ScaleY;
    /* 0x0060 */ FFloatInterval ScaleZ;
    /* 0x0068 */ FFoliageVertexColorChannelMask VertexColorMaskByChannel[4];
    /* 0x0098 */ uint8_t VertexColorMask;
    /* 0x009c */ float VertexColorMaskThreshold;
    /* 0x00a0 */ bool VertexColorMaskInvert;
    /* 0x00a4 */ FFloatInterval ZOffset;
    /* 0x00ac */ bool AlignToNormal;
    /* 0x00ac */ bool AverageNormal;
    /* 0x00ac */ bool AverageNormalSingleComponent;
    /* 0x00b0 */ float AlignMaxAngle;
    /* 0x00b4 */ bool RandomYaw;
    /* 0x00b8 */ float RandomPitchAngle;
    /* 0x00bc */ FFloatInterval GroundSlopeAngle;
    /* 0x00c4 */ FFloatInterval Height;
    /* 0x00d0 */ TArray<FName> LandscapeLayers;
    /* 0x00e0 */ float MinimumLayerWeight;
    /* 0x00e8 */ TArray<FName> ExclusionLandscapeLayers;
    /* 0x00f8 */ float MinimumExclusionLayerWeight;
    /* 0x00fc */ FName LandscapeLayer;
    /* 0x0104 */ bool CollisionWithWorld;
    /* 0x0108 */ FVector CollisionScale;
    /* 0x0120 */ int32_t AverageNormalSampleCount;
    /* 0x0128 */ FBoxSphereBounds MeshBounds;
    /* 0x0160 */ FVector LowBoundOriginRadius;
    /* 0x0178 */ uint8_t Mobility;
    /* 0x017c */ FInt32Interval CullDistance;
    /* 0x0184 */ bool bEnableStaticLighting;
    /* 0x0184 */ bool CastShadow;
    /* 0x0184 */ bool bAffectDynamicIndirectLighting;
    /* 0x0184 */ bool bAffectDistanceFieldLighting;
    /* 0x0184 */ bool bCastDynamicShadow;
    /* 0x0184 */ bool bCastStaticShadow;
    /* 0x0188 */ bool bCastContactShadow;
    /* 0x018c */ bool bCastShadowAsTwoSided;
    /* 0x018c */ bool bReceivesDecals;
    /* 0x018c */ bool bOverrideLightMapRes;
    /* 0x0190 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
    /* 0x0194 */ int32_t OverriddenLightMapRes;
    /* 0x0198 */ ELightmapType LightmapType;
    /* 0x019c */ bool bUseAsOccluder;
    /* 0x01a0 */ bool bVisibleInRayTracing;
    /* 0x01a0 */ bool bEvaluateWorldPositionOffset;
    /* 0x01a4 */ int32_t WorldPositionOffsetDisableDistance;
    /* 0x01a8 */ FBodyInstance BodyInstance;
    /* 0x0328 */ uint8_t CustomNavigableGeometry;
    /* 0x0329 */ FLightingChannels LightingChannels;
    /* 0x032c */ bool bRenderCustomDepth;
    /* 0x0330 */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x0334 */ int32_t CustomDepthStencilValue;
    /* 0x0338 */ int32_t TranslucencySortPriority;
    /* 0x033c */ float collisionRadius;
    /* 0x0340 */ float ShadeRadius;
    /* 0x0344 */ int32_t NumSteps;
    /* 0x0348 */ float InitialSeedDensity;
    /* 0x034c */ float AverageSpreadDistance;
    /* 0x0350 */ float SpreadVariance;
    /* 0x0354 */ int32_t SeedsPerStep;
    /* 0x0358 */ int32_t DistributionSeed;
    /* 0x035c */ float MaxInitialSeedOffset;
    /* 0x0360 */ bool bCanGrowInShade;
    /* 0x0361 */ bool bSpawnsInShade;
    /* 0x0364 */ float MaxInitialAge;
    /* 0x0368 */ float MaxAge;
    /* 0x036c */ float OverlapPriority;
    /* 0x0370 */ FFloatInterval ProceduralScale;
    /* 0x0378 */ FRuntimeFloatCurve ScaleCurve;
    /* 0x0400 */ FFoliageDensityFalloff DensityFalloff;
    /* 0x0490 */ int32_t ChangeCount;
    /* 0x0494 */ bool ReapplyDensity;
    /* 0x0494 */ bool ReapplyRadius;
    /* 0x0494 */ bool ReapplyAlignToNormal;
    /* 0x0494 */ bool ReapplyRandomYaw;
    /* 0x0494 */ bool ReapplyScaling;
    /* 0x0494 */ bool ReapplyScaleX;
    /* 0x0494 */ bool ReapplyScaleY;
    /* 0x0494 */ bool ReapplyScaleZ;
    /* 0x0495 */ bool ReapplyRandomPitchAngle;
    /* 0x0495 */ bool ReapplyGroundSlope;
    /* 0x0495 */ bool ReapplyHeight;
    /* 0x0495 */ bool ReapplyLandscapeLayers;
    /* 0x0495 */ bool ReapplyZOffset;
    /* 0x0495 */ bool ReapplyCollisionWithWorld;
    /* 0x0495 */ bool ReapplyVertexColorMask;
    /* 0x0495 */ bool bEnableDensityScaling;
    /* 0x0496 */ bool bEnableDiscardOnLoad;
    /* 0x0496 */ bool bEnableCullDistanceScaling;
    /* 0x0498 */ TArray<URuntimeVirtualTexture*> RuntimeVirtualTextures;
    /* 0x04a8 */ int32_t VirtualTextureCullMips;
    /* 0x04ac */ ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType;
};

// Size: 0x20
struct FFoliageTypeObject {
    /* 0x0000 */ UObject* FoliageTypeObject;
    /* 0x0008 */ UFoliageType* TypeInstance;
    /* 0x0010 */ bool bIsAsset;
    /* 0x0018 */ UClass* Type;
};

// Size: 0x4c8
class UFoliageType_Actor : public UFoliageType {
    /* 0x04b0 */ UClass* ActorClass;
    /* 0x04b8 */ bool bShouldAttachToBaseComponent;
    /* 0x04b9 */ bool bStaticMeshOnly;
    /* 0x04c0 */ UClass* StaticMeshOnlyComponentClass;
};

// Size: 0x4e0
class UFoliageType_InstancedStaticMesh : public UFoliageType {
    /* 0x04b0 */ UStaticMesh* Mesh;
    /* 0x04b8 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x04c8 */ TArray<UMaterialInterface*> NaniteOverrideMaterials;
    /* 0x04d8 */ UClass* ComponentClass;
};

// Size: 0xc
struct FFoliageVertexColorChannelMask {
    /* 0x0000 */ bool UseMask;
    /* 0x0004 */ float MaskThreshold;
    /* 0x0008 */ bool InvertMask;
};

enum class FoliageVertexColorMask {
    FOLIAGEVERTEXCOLORMASK_Disabled = 0,
    FOLIAGEVERTEXCOLORMASK_Red = 1,
    FOLIAGEVERTEXCOLORMASK_Green = 2,
    FOLIAGEVERTEXCOLORMASK_Blue = 3,
    FOLIAGEVERTEXCOLORMASK_Alpha = 4,
    FOLIAGEVERTEXCOLORMASK_MAX = 5,
};

// Size: 0xb50
class UGrassInstancedStaticMeshComponent : public UHierarchicalInstancedStaticMeshComponent {
};

// Size: 0x308
class AInstancedFoliageActor : public AISMPartitionActor {
};

// Size: 0x348
class AInteractiveFoliageActor : public AStaticMeshActor {
    /* 0x02b8 */ UCapsuleComponent* CapsuleComponent;
    /* 0x02c0 */ FVector TouchingActorEntryPosition;
    /* 0x02d8 */ FVector FoliageVelocity;
    /* 0x02f0 */ FVector FoliageForce;
    /* 0x0308 */ FVector FoliagePosition;
    /* 0x0320 */ float FoliageDamageImpulseScale;
    /* 0x0324 */ float FoliageTouchImpulseScale;
    /* 0x0328 */ float FoliageStiffness;
    /* 0x032c */ float FoliageStiffnessQuadratic;
    /* 0x0330 */ float FoliageDamping;
    /* 0x0334 */ float MaxDamageImpulse;
    /* 0x0338 */ float MaxTouchImpulse;
    /* 0x033c */ float MaxForce;
    /* 0x0340 */ float Mass;

    void CapsuleTouched(UPrimitiveComponent* OverlappedComp, AActor* Other, UPrimitiveComponent* OtherComp, int32_t OtherBodyIndex, bool bFromSweep, const FHitResult& OverlapInfo);
};

// Size: 0x620
class UInteractiveFoliageComponent : public UStaticMeshComponent {
};

// Size: 0x378
class AProceduralFoliageBlockingVolume : public AVolume {
    /* 0x02e0 */ AProceduralFoliageVolume* ProceduralFoliageVolume;
    /* 0x02e8 */ FFoliageDensityFalloff DensityFalloff;
};

// Size: 0xe0
class UProceduralFoliageComponent : public UActorComponent {
    /* 0x00b8 */ UProceduralFoliageSpawner* FoliageSpawner;
    /* 0x00c0 */ float TileOverlap;
    /* 0x00c8 */ AVolume* SpawningVolume;
    /* 0x00d0 */ FGuid ProceduralGuid;
};

// Size: 0x80
struct FProceduralFoliageInstance {
    /* 0x0000 */ FQuat Rotation;
    /* 0x0020 */ FVector Location;
    /* 0x0038 */ float Age;
    /* 0x0040 */ FVector Normal;
    /* 0x0058 */ float Scale;
    /* 0x0060 */ UFoliageType* Type;
};

// Size: 0x80
class UProceduralFoliageSpawner : public UObject {
    /* 0x0028 */ int32_t RandomSeed;
    /* 0x002c */ float TileSize;
    /* 0x0030 */ int32_t NumUniqueTiles;
    /* 0x0034 */ float MinimumQuadTreeSize;
    /* 0x0040 */ TArray<FFoliageTypeObject> FoliageTypes;
    /* 0x0050 */ bool bUseOverrideFoliageTerrainMaterials;
    /* 0x0058 */ TArray<TSoftObjectPtr<UMaterialInterface>> OverrideFoliageTerrainMaterials;

    void Simulate(int32_t NumSteps);
};

// Size: 0x170
class UProceduralFoliageTile : public UObject {
    /* 0x0028 */ UProceduralFoliageSpawner* FoliageSpawner;
    /* 0x00d0 */ TArray<FProceduralFoliageInstance> InstancesArray;
};

// Size: 0x2f0
class AProceduralFoliageVolume : public AVolume {
    /* 0x02e8 */ UProceduralFoliageComponent* ProceduralComponent;
};

enum class EFBIKBoneLimitType {
    Free = 0,
    Limit = 1,
    Locked = 2,
    EFBIKBoneLimitType_MAX = 3,
};

enum class EPoleVectorOption {
    Direction = 0,
    Location = 1,
    EPoleVectorOption_MAX = 2,
};

// Size: 0x20
struct FFBIKBoneLimit {
    /* 0x0000 */ EFBIKBoneLimitType LimitType_X;
    /* 0x0001 */ EFBIKBoneLimitType LimitType_Y;
    /* 0x0002 */ EFBIKBoneLimitType LimitType_Z;
    /* 0x0008 */ FVector Limit;
};

// Size: 0xa0
struct FFBIKConstraintOption {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x000c */ bool bEnabled;
    /* 0x000d */ bool bUseStiffness;
    /* 0x0010 */ FVector LinearStiffness;
    /* 0x0028 */ FVector AngularStiffness;
    /* 0x0040 */ bool bUseAngularLimit;
    /* 0x0048 */ FFBIKBoneLimit AngularLimit;
    /* 0x0068 */ bool bUsePoleVector;
    /* 0x0069 */ EPoleVectorOption PoleVectorOption;
    /* 0x0070 */ FVector PoleVector;
    /* 0x0088 */ FRotator OffsetRotation;
};

// Size: 0x80
struct FFBIKDebugOption {
    /* 0x0000 */ bool bDrawDebugHierarchy;
    /* 0x0001 */ bool bColorAngularMotionStrength;
    /* 0x0002 */ bool bColorLinearMotionStrength;
    /* 0x0003 */ bool bDrawDebugAxes;
    /* 0x0004 */ bool bDrawDebugEffector;
    /* 0x0005 */ bool bDrawDebugConstraints;
    /* 0x0010 */ FTransform DrawWorldOffset;
    /* 0x0070 */ float DrawSize;
};

// Size: 0x60
struct FFBIKEndEffector {
    /* 0x0000 */ FRigElementKey Item;
    /* 0x0010 */ FVector position;
    /* 0x0028 */ float PositionAlpha;
    /* 0x002c */ int32_t PositionDepth;
    /* 0x0030 */ FQuat Rotation;
    /* 0x0050 */ float RotationAlpha;
    /* 0x0054 */ int32_t RotationDepth;
    /* 0x0058 */ float Pull;
};

// Size: 0x2
struct FMotionProcessInput {
    /* 0x0000 */ bool bForceEffectorRotationTarget;
    /* 0x0001 */ bool bOnlyApplyWhenReachedToTarget;
};

// Size: 0x290
struct FRigUnit_FullbodyIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FRigElementKey Root;
    /* 0x0020 */ TArray<FFBIKEndEffector> Effectors;
    /* 0x0030 */ TArray<FFBIKConstraintOption> Constraints;
    /* 0x0040 */ FSolverInput SolverProperty;
    /* 0x0064 */ FMotionProcessInput MotionProperty;
    /* 0x0066 */ bool bPropagateToChildren;
    /* 0x0070 */ FFBIKDebugOption DebugOption;
    /* 0x00f0 */ FRigUnit_FullbodyIK_WorkData WorkData;
};

// Size: 0x198
struct FRigUnit_FullbodyIK_WorkData {
};

// Size: 0x24
struct FSolverInput {
    /* 0x0000 */ float LinearMotionStrength;
    /* 0x0004 */ float MinLinearMotionStrength;
    /* 0x0008 */ float AngularMotionStrength;
    /* 0x000c */ float MinAngularMotionStrength;
    /* 0x0010 */ float DefaultTargetClamp;
    /* 0x0014 */ float Precision;
    /* 0x0018 */ float Damping;
    /* 0x001c */ int32_t MaxIterations;
    /* 0x0020 */ bool bUseJacobianTranspose;
};

enum class EGLTFMaterialBakeMode {
    Disabled = 0,
    Simple = 1,
    UseMeshData = 2,
    EGLTFMaterialBakeMode_MAX = 3,
};

enum class EGLTFMaterialPropertyGroup {
    None = 0,
    BaseColorOpacity = 1,
    MetallicRoughness = 2,
    EmissiveColor = 3,
    Normal = 4,
    AmbientOcclusion = 5,
    ClearCoatRoughness = 6,
    ClearCoatBottomNormal = 7,
    EGLTFMaterialPropertyGroup_MAX = 8,
};

enum class EGLTFMaterialVariantMode {
    None = 0,
    Simple = 1,
    UseMeshData = 2,
    EGLTFMaterialVariantMode_MAX = 3,
};

enum class EGLTFTextureImageFormat {
    None = 0,
    PNG = 1,
    JPEG = 2,
    EGLTFTextureImageFormat_MAX = 3,
};

// Size: 0x78
class UGLTFAnimSequenceExporter : public UGLTFExporter {
};

// Size: 0x30
struct FGLTFExportMessages {
    /* 0x0000 */ TArray<FString> Suggestions;
    /* 0x0010 */ TArray<FString> Warnings;
    /* 0x0020 */ TArray<FString> Errors;
};

// Size: 0xb0
class UGLTFExportOptions : public UObject {
    /* 0x0028 */ float ExportUniformScale;
    /* 0x002c */ bool bExportPreviewMesh;
    /* 0x002d */ bool bSkipNearDefaultValues;
    /* 0x002e */ bool bIncludeCopyrightNotice;
    /* 0x002f */ bool bExportProxyMaterials;
    /* 0x0030 */ bool bUseImporterMaterialMapping;
    /* 0x0031 */ bool bExportUnlitMaterials;
    /* 0x0032 */ bool bExportClearCoatMaterials;
    /* 0x0033 */ bool bExportClothMaterials;
    /* 0x0034 */ bool bExportThinTranslucentMaterials;
    /* 0x0035 */ bool bExportSpecularGlossinessMaterials;
    /* 0x0036 */ bool bExportEmissiveStrength;
    /* 0x0037 */ EGLTFMaterialBakeMode BakeMaterialInputs;
    /* 0x0038 */ FGLTFMaterialBakeSize DefaultMaterialBakeSize;
    /* 0x0044 */ uint8_t DefaultMaterialBakeFilter;
    /* 0x0045 */ uint8_t DefaultMaterialBakeTiling;
    /* 0x0048 */ TMap<EGLTFMaterialPropertyGroup, FGLTFOverrideMaterialBakeSettings> DefaultInputBakeSettings;
    /* 0x0098 */ int32_t DefaultLevelOfDetail;
    /* 0x009c */ bool bExportSourceModel;
    /* 0x009d */ bool bExportVertexColors;
    /* 0x009e */ bool bExportVertexSkinWeights;
    /* 0x009f */ bool bMakeSkinnedMeshesRoot;
    /* 0x00a0 */ bool bUseMeshQuantization;
    /* 0x00a1 */ bool bExportLevelSequences;
    /* 0x00a2 */ bool bExportAnimationSequences;
    /* 0x00a3 */ EGLTFTextureImageFormat TextureImageFormat;
    /* 0x00a4 */ int32_t TextureImageQuality;
    /* 0x00a8 */ bool bExportTextureTransforms;
    /* 0x00a9 */ bool bExportLightmaps;
    /* 0x00aa */ bool bAdjustNormalmaps;
    /* 0x00ab */ bool bExportHiddenInGame;
    /* 0x00ac */ bool bExportLights;
    /* 0x00ad */ bool bExportCameras;
    /* 0x00ae */ EGLTFMaterialVariantMode ExportMaterialVariants;

    void ResetToDefault();
};

// Size: 0x78
class UGLTFExporter : public UExporter {

    static bool ExportToGLTF(UObject* Object, FString FilePath, const UGLTFExportOptions* Options, const TSet<AActor*>& SelectedActors, FGLTFExportMessages& OutMessages);
};

// Size: 0x78
class UGLTFLevelExporter : public UGLTFExporter {
};

// Size: 0x78
class UGLTFLevelSequenceExporter : public UGLTFExporter {
};

// Size: 0x78
class UGLTFLevelVariantSetsExporter : public UGLTFExporter {
};

// Size: 0xc
struct FGLTFMaterialBakeSize {
    /* 0x0000 */ int32_t X;
    /* 0x0004 */ int32_t Y;
    /* 0x0008 */ bool bAutoDetect;
};

// Size: 0x98
class UGLTFMaterialExportOptions : public UAssetUserData {
    /* 0x0028 */ UMaterialInterface* Proxy;
    /* 0x0030 */ FGLTFOverrideMaterialBakeSettings Default;
    /* 0x0048 */ TMap<EGLTFMaterialPropertyGroup, FGLTFOverrideMaterialBakeSettings> Inputs;
};

// Size: 0x78
class UGLTFMaterialExporter : public UGLTFExporter {
};

// Size: 0x14
struct FGLTFOverrideMaterialBakeSettings {
    /* 0x0000 */ bool bOverrideSize;
    /* 0x0004 */ FGLTFMaterialBakeSize Size;
    /* 0x0010 */ bool bOverrideFilter;
    /* 0x0011 */ uint8_t Filter;
    /* 0x0012 */ bool bOverrideTiling;
    /* 0x0013 */ uint8_t Tiling;
};

// Size: 0x90
class UGLTFProxyOptions : public UObject {
    /* 0x0028 */ bool bBakeMaterialInputs;
    /* 0x0029 */ bool bUseThinTranslucentShadingModel;
    /* 0x002c */ FGLTFMaterialBakeSize DefaultMaterialBakeSize;
    /* 0x0038 */ uint8_t DefaultMaterialBakeFilter;
    /* 0x0039 */ uint8_t DefaultMaterialBakeTiling;
    /* 0x0040 */ TMap<EGLTFMaterialPropertyGroup, FGLTFOverrideMaterialBakeSettings> DefaultInputBakeSettings;

    void ResetToDefault();
};

// Size: 0x78
class UGLTFSkeletalMeshExporter : public UGLTFExporter {
};

// Size: 0x78
class UGLTFStaticMeshExporter : public UGLTFExporter {
};

// Size: 0x38
class UAccelerationDecelerationValueInterpolator : public UCameraValueInterpolator {
    /* 0x0028 */ float Acceleration;
    /* 0x002c */ float MaxSpeed;
    /* 0x0030 */ float Deceleration;
};

// Size: 0x28
class UActivateCameraRigFunctions : public UBlueprintFunctionLibrary {

    static void ActivatePersistentBaseCameraRig(UObject* WorldContextObject, APlayerController* PlayerController, UCameraRigAsset* CameraRig);
    static void ActivatePersistentGlobalCameraRig(UObject* WorldContextObject, APlayerController* PlayerController, UCameraRigAsset* CameraRig);
    static void ActivatePersistentVisualCameraRig(UObject* WorldContextObject, APlayerController* PlayerController, UCameraRigAsset* CameraRig);
};

// Size: 0x48
class UArrayCameraNode : public UCameraNode {
    /* 0x0038 */ TArray<UCameraNode*> Children;
};

// Size: 0x28
class IAssetReferenceCameraNode : public UInterface {
};

// Size: 0x80
class UAttachToActorCameraNode : public UCameraNode {
    /* 0x0038 */ FCameraActorAttachmentInfo Attachment;
    /* 0x0058 */ FCameraContextDataID AttachmentDataID;
    /* 0x0060 */ FBooleanCameraParameter AttachToLocation;
    /* 0x0070 */ FBooleanCameraParameter AttachToRotation;
};

// Size: 0x50
class UAttachToActorGroupCameraNode : public UCameraNode {
    /* 0x0038 */ TArray<FCameraActorAttachmentInfo> Attachments;
    /* 0x0048 */ FCameraContextDataID AttachmentsDataID;
};

// Size: 0x58
class UAttachToPlayerPawnCameraNode : public UCameraNode {
    /* 0x0038 */ FBooleanCameraParameter AttachToLocation;
    /* 0x0048 */ FBooleanCameraParameter AttachToRotation;
};

// Size: 0x58
class UAutoFocusCameraNode : public UCameraNode {
    /* 0x0038 */ FBooleanCameraVariableReference EnableAutoFocus;
    /* 0x0048 */ FFloatCameraParameter AutoFocusDampingFactor;
};

// Size: 0xc0
class UAutoRotateInput2DCameraNode : public UInput2DCameraNode {
    /* 0x0038 */ ECameraAutoRotateDirection Direction;
    /* 0x0040 */ FVector3dCameraVariableReference DirectionVector;
    /* 0x0050 */ FFloatCameraParameter WaitTime;
    /* 0x0060 */ FFloatCameraParameter DeactivationThreshold;
    /* 0x0070 */ UCameraValueInterpolator* Interpolator;
    /* 0x0078 */ FBooleanCameraParameter FreezeControlRotation;
    /* 0x0088 */ FBooleanCameraParameter EnableAutoRotate;
    /* 0x0098 */ FBooleanCameraParameter AutoRotateYaw;
    /* 0x00a8 */ FBooleanCameraParameter AutoRotatePitch;
    /* 0x00b8 */ UInput2DCameraNode* InputNode;
};

// Size: 0xa8
class UBaseCameraObject : public UObject {
    /* 0x0028 */ FCameraObjectInterface Interface;
    /* 0x0060 */ FCameraObjectAllocationInfo AllocationInfo;
    /* 0x0088 */ FInstancedPropertyBag DefaultParameters;
    /* 0x0098 */ TArray<FCameraObjectInterfaceParameterDefinition> ParameterDefinitions;
};

// Size: 0x28
struct FBaseCameraObjectReference {
    /* 0x0008 */ FInstancedPropertyBag Parameters;
    /* 0x0018 */ TArray<FCameraObjectInterfaceParameterMetaData> ParameterMetaData;
};

// Size: 0x170
class UBaseFramingCameraNode : public UCameraNode {
    /* 0x0040 */ FVector3dCameraVariableReference TargetLocation;
    /* 0x0050 */ TArray<FCameraActorTargetInfo> TargetInfos;
    /* 0x0060 */ FCameraContextDataID TargetInfosDataID;
    /* 0x0068 */ FBooleanCameraParameter SetTargetDistance;
    /* 0x0078 */ FBooleanCameraParameter InitializeWithIdealFraming;
    /* 0x0088 */ FVector2dCameraParameter IdealFramingLocation;
    /* 0x00a8 */ FFloatCameraParameter ReframeDampingFactor;
    /* 0x00b8 */ FFloatCameraParameter LowReframeDampingFactor;
    /* 0x00c8 */ FFloatCameraParameter ReengageTime;
    /* 0x00d8 */ FFloatCameraParameter DisengageTime;
    /* 0x00e8 */ FFloatCameraParameter TargetMovementAnticipationTime;
    /* 0x00f8 */ FCameraFramingZoneParameter DeadZone;
    /* 0x0120 */ FCameraFramingZoneParameter SoftZone;
    /* 0x0148 */ FCameraActorTargetInfo TargetInfo;
};

// Size: 0x38
class UBlendCameraNode : public UCameraNode {
};

// Size: 0x40
class UBlendStackCameraNode : public UCameraNode {
    /* 0x0038 */ ECameraBlendStackType BlendStackType;
    /* 0x003c */ ECameraRigLayer Layer;
};

// Size: 0x48
class UBlendStackRootCameraNode : public UCameraNode {
    /* 0x0038 */ UBlendCameraNode* Blend;
    /* 0x0040 */ UCameraNode* RootNode;
};

// Size: 0x28
class UBlueprintCameraContextDataTableFunctionLibrary : public UBlueprintFunctionLibrary {

    static UClass* GetClassData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID);
    static uint8_t GetEnumData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, const UEnum* EnumType);
    static FName GetNameData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID);
    static UObject* GetObjectData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID);
    static FString GetStringData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID);
    static FInstancedStruct GetStructData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, const UScriptStruct* DataStructType);
    static bool SetClassData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, UClass* Data);
    static bool SetEnumData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, const UEnum* EnumType, uint8_t Data);
    static bool SetNameData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, const FName& Data);
    static bool SetObjectData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, UObject* Data);
    static bool SetStringData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, FString Data);
    static bool SetStructData(const FBlueprintCameraEvaluationDataRef& CameraData, FCameraContextDataID DataID, const FInstancedStruct& Data);
};

// Size: 0x48
class UBlueprintCameraDirector : public UCameraDirector {
    /* 0x0040 */ UClass* CameraDirectorEvaluatorClass;
};

// Size: 0x8
struct FBlueprintCameraDirectorActivateParams {
    /* 0x0000 */ UObject* EvaluationContextOwner;
};

// Size: 0x8
struct FBlueprintCameraDirectorDeactivateParams {
    /* 0x0000 */ UObject* EvaluationContextOwner;
};

// Size: 0x10
struct FBlueprintCameraDirectorEvaluationParams {
    /* 0x0000 */ float deltaTime;
    /* 0x0008 */ UObject* EvaluationContextOwner;
};

// Size: 0x140
class UBlueprintCameraDirectorEvaluator : public UObject {

    void ActivateCameraDirector(UObject* EvaluationContextOwner, const FBlueprintCameraDirectorActivateParams& Params);
    void ActivateCameraRig(UCameraRigAsset* CameraRig, bool bForceNewInstance);
    void ActivateCameraRigViaProxy(UCameraRigProxyAsset* CameraRigProxy, bool bForceNewInstance);
    void ActivatePersistentBaseCameraRig(UCameraRigAsset* CameraRigPrefab);
    void ActivatePersistentGlobalCameraRig(UCameraRigAsset* CameraRigPrefab);
    void ActivatePersistentVisualCameraRig(UCameraRigAsset* CameraRigPrefab);
    FName AddChildEvaluationContext(UObject* ChildEvaluationContextOwner);
    void DeactivateCameraDirector(UObject* EvaluationContextOwner, const FBlueprintCameraDirectorDeactivateParams& Params);
    void DeactivatePersistentBaseCameraRig(UCameraRigAsset* CameraRigPrefab);
    void DeactivatePersistentGlobalCameraRig(UCameraRigAsset* CameraRigPrefab);
    void DeactivatePersistentVisualCameraRig(UCameraRigAsset* CameraRigPrefab);
    AActor* FindEvaluationContextOwnerActor(UClass* ActorClass) const;
    FBlueprintCameraEvaluationDataRef GetConditionalContextResult(ECameraEvaluationDataCondition Condition) const;
    FBlueprintCameraEvaluationDataRef GetInitialContextResult() const;
    bool RemoveChildEvaluationContext(UObject* ChildEvaluationContextOwner, FName ChildSlotName);
    void RunCameraDirector(float deltaTime, UObject* EvaluationContextOwner, const FBlueprintCameraDirectorEvaluationParams& Params);
    bool RunChildCameraDirector(float deltaTime, FName ChildSlotName);
};

// Size: 0x28
class UBlueprintCameraEvaluationDataFunctionLibrary : public UBlueprintFunctionLibrary {

    static void BlendCameraEvaluationData(const FBlueprintCameraEvaluationDataRef& FromCameraData, const FBlueprintCameraEvaluationDataRef& ToCameraData, float Factor);
    static FBlueprintCameraPose GetCameraPose(const FBlueprintCameraEvaluationDataRef& CameraData);
    static FBlueprintCameraEvaluationDataRef MakeCameraEvaluationData();
    static void SetCameraPose(const FBlueprintCameraEvaluationDataRef& CameraData, const FBlueprintCameraPose& CameraPose);
    static void SetDefaultCameraRigParameters(const FBlueprintCameraEvaluationDataRef& CameraData, const UCameraRigAsset* CameraRig);
};

// Size: 0x18
struct FBlueprintCameraEvaluationDataRef {
};

// Size: 0x70
class UBlueprintCameraNode : public UCameraNode {
    /* 0x0040 */ UBlueprintCameraNodeEvaluator* CameraNodeEvaluatorTemplate;
    /* 0x0048 */ FCustomCameraNodeParameters CameraNodeEvaluatorOverrides;
    /* 0x0068 */ UClass* CameraNodeEvaluatorClass;
};

// Size: 0x110
class UBlueprintCameraNodeEvaluator : public UObject {
    /* 0x0028 */ bool bIsFirstFrame;
    /* 0x0030 */ UObject* EvaluationContextOwner;
    /* 0x0038 */ FBlueprintCameraEvaluationDataRef CameraData;
    /* 0x0050 */ FBlueprintCameraPose CameraPose;
    /* 0x00d8 */ FBlueprintCameraEvaluationDataRef VariableTable;

    AActor* FindEvaluationContextOwnerActor(UClass* ActorClass) const;
    FBlueprintCameraPose GetCameraPose() const;
    FBlueprintCameraPose GetCurrentCameraPose() const;
    APlayerController* GetPlayerController() const;
    void InitializeCameraNode();
    void SetCameraPose(const FBlueprintCameraPose& InCameraPose);
    void SetCurrentCameraPose(const FBlueprintCameraPose& CameraPose);
    void SetDefaultOwningCameraRigParameters(FBlueprintCameraEvaluationDataRef TargetCameraData) const;
    void TickCameraNode(float deltaTime);
};

// Size: 0x88
struct FBlueprintCameraPose {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ double TargetDistance;
    /* 0x0038 */ float FieldOfView;
    /* 0x003c */ float FocalLength;
    /* 0x0040 */ float OrthographicWidth;
    /* 0x0044 */ float Aperture;
    /* 0x0048 */ float ShutterSpeed;
    /* 0x004c */ float FocusDistance;
    /* 0x0050 */ float SensorWidth;
    /* 0x0054 */ float SensorHeight;
    /* 0x0058 */ float SensorHorizontalOffset;
    /* 0x005c */ float SensorVerticalOffset;
    /* 0x0060 */ float ISO;
    /* 0x0064 */ float SqueezeFactor;
    /* 0x0068 */ float Overscan;
    /* 0x006c */ int32_t DiaphragmBladeCount;
    /* 0x0070 */ float NearClippingPlane;
    /* 0x0074 */ float FarClippingPlane;
    /* 0x0078 */ float PhysicalCameraBlendWeight;
    /* 0x007c */ bool EnablePhysicalCamera;
    /* 0x007d */ bool ConstrainAspectRatio;
    /* 0x007e */ bool OverrideAspectRatioAxisConstraint;
    /* 0x007f */ uint8_t AspectRatioAxisConstraint;
    /* 0x0080 */ uint8_t ProjectionMode;
};

// Size: 0x28
class UBlueprintCameraPoseFunctionLibrary : public UBlueprintFunctionLibrary {

    static FVector GetAimDir(const FBlueprintCameraPose& CameraPose);
    static FRay GetAimRay(const FBlueprintCameraPose& CameraPose);
    static double GetEffectiveFieldOfView(const FBlueprintCameraPose& CameraPose);
    static double GetFieldOfView(const FBlueprintCameraPose& CameraPose);
    static double GetFocalLength(const FBlueprintCameraPose& CameraPose);
    static FVector GetLocation(const FBlueprintCameraPose& CameraPose);
    static FRotator GetRotation(const FBlueprintCameraPose& CameraPose);
    static double GetSensorAspectRatio(const FBlueprintCameraPose& CameraPose);
    static FVector GetTarget(const FBlueprintCameraPose& CameraPose);
    static FVector GetTargetAtDistance(const FBlueprintCameraPose& CameraPose, double TargetDistance);
    static double GetTargetDistance(const FBlueprintCameraPose& CameraPose);
    static FTransform GetTransform(const FBlueprintCameraPose& CameraPose);
    static FBlueprintCameraPose MakeCameraPoseFromCameraComponent(const UCameraComponent* CameraComponent);
    static FBlueprintCameraPose MakeCameraPoseFromCineCameraComponent(const UCineCameraComponent* CameraComponent);
    static FBlueprintCameraPose SetFieldOfView(const FBlueprintCameraPose& CameraPose, float FieldOfView);
    static FBlueprintCameraPose SetFocalLength(const FBlueprintCameraPose& CameraPose, float FocalLength);
    static FBlueprintCameraPose SetLocation(const FBlueprintCameraPose& CameraPose, const FVector& Location);
    static FBlueprintCameraPose SetRotation(const FBlueprintCameraPose& CameraPose, const FRotator& Rotation);
    static FBlueprintCameraPose SetTargetDistance(const FBlueprintCameraPose& CameraPose, double TargetDistance);
    static FBlueprintCameraPose SetTransform(const FBlueprintCameraPose& CameraPose, const FTransform& Transform);
};

// Size: 0x28
class UBlueprintCameraVariableTableFunctionLibrary : public UBlueprintFunctionLibrary {

    static bool GetBooleanCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UBooleanCameraVariable* Variable);
    static double GetDoubleCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UDoubleCameraVariable* Variable);
    static float GetFloatCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UFloatCameraVariable* Variable);
    static int32_t GetInteger32CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UInteger32CameraVariable* Variable);
    static FRotator GetRotatorCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, URotator3dCameraVariable* Variable);
    static FTransform GetTransformCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UTransform3dCameraVariable* Variable);
    static FVector2D GetVector2CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector2dCameraVariable* Variable);
    static FVector GetVector3CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector3dCameraVariable* Variable);
    static FVector4 GetVector4CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector4dCameraVariable* Variable);
    static void SetBooleanCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UBooleanCameraVariable* Variable, bool Value);
    static void SetDoubleCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UDoubleCameraVariable* Variable, double Value);
    static void SetFloatCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UFloatCameraVariable* Variable, float Value);
    static void SetInteger32CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UInteger32CameraVariable* Variable, int32_t Value);
    static void SetRotatorCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, URotator3dCameraVariable* Variable, const FRotator& Value);
    static void SetTransformCameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UTransform3dCameraVariable* Variable, const FTransform& Value);
    static void SetVector2CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector2dCameraVariable* Variable, const FVector2D& Value);
    static void SetVector3CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector3dCameraVariable* Variable, const FVector& Value);
    static void SetVector4CameraVariable(const FBlueprintCameraEvaluationDataRef& CameraData, UVector4dCameraVariable* Variable, const FVector4& Value);
};

// Size: 0x58
class UBodyParametersCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter ShutterSpeed;
    /* 0x0048 */ FFloatCameraParameter ISO;
};

// Size: 0x10
struct FBooleanCameraParameter {
    /* 0x0000 */ bool Value;
    /* 0x0004 */ FCameraVariableID VariableID;
    /* 0x0008 */ UBooleanCameraVariable* Variable;
};

// Size: 0x48
struct FBooleanCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FBooleanCameraParameter Value;
};

// Size: 0x48
class UBooleanCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ bool bDefaultValue;
};

// Size: 0x10
struct FBooleanCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UBooleanCameraVariable* Variable;
};

// Size: 0xa0
class UBoomArmCameraNode : public UCameraNode {
    /* 0x0038 */ FVector3dCameraParameter BoomOffset;
    /* 0x0060 */ UCameraValueInterpolator* BoomLengthInterpolator;
    /* 0x0068 */ FDoubleCameraParameter MaxForwardInterpolationFactor;
    /* 0x0080 */ FDoubleCameraParameter MaxBackwardInterpolationFactor;
    /* 0x0098 */ UInput2DCameraNode* InputSlot;
};

// Size: 0x38
class UCalcCameraActorCameraNode : public UCameraNode {
};

// Size: 0x20
struct FCameraActorAttachmentInfo {
    /* 0x0000 */ AActor* Actor;
    /* 0x0008 */ FName SocketName;
    /* 0x0010 */ FName BoneName;
    /* 0x0018 */ float Weight;
};

// Size: 0x28
struct FCameraActorTargetInfo {
    /* 0x0000 */ AActor* Actor;
    /* 0x0008 */ FName SocketName;
    /* 0x0010 */ FName BoneName;
    /* 0x0018 */ ECameraTargetShape TargetShape;
    /* 0x001c */ float TargetSize;
    /* 0x0020 */ float Weight;
};

// Size: 0xd8
class UCameraAsset : public UObject {
    /* 0x0048 */ UCameraDirector* CameraDirector;
    /* 0x0050 */ TArray<UCameraRigTransition*> EnterTransitions;
    /* 0x0060 */ TArray<UCameraRigTransition*> ExitTransitions;
    /* 0x0070 */ ECameraBuildStatus BuildStatus;
    /* 0x0078 */ FInstancedPropertyBag DefaultParameters;
    /* 0x0088 */ TArray<FCameraObjectInterfaceParameterDefinition> ParameterDefinitions;
    /* 0x0098 */ TArray<UCameraRigAsset*> ParameterOwners;
    /* 0x00a8 */ FCameraAssetAllocationInfo AllocationInfo;
    /* 0x00c8 */ TArray<UCameraRigAsset*> CameraRigs;
};

// Size: 0x20
struct FCameraAssetAllocationInfo {
    /* 0x0000 */ FCameraVariableTableAllocationInfo VariableTableInfo;
    /* 0x0010 */ FCameraContextDataTableAllocationInfo ContextDataTableInfo;
};

// Size: 0x38
struct FCameraAssetReference {
    /* 0x0000 */ UCameraAsset* CameraAsset;
    /* 0x0008 */ FInstancedPropertyBag Parameters;
    /* 0x0018 */ TArray<FGuid> ParameterOverrideGuids;
    /* 0x0028 */ TArray<FGuid> ParameterAnimatedGuids;
};

// Size: 0x38
class UCameraComponentCameraNode : public UCameraNode {
};

// Size: 0x20
struct FCameraContextDataDefinition {
    /* 0x0000 */ FCameraContextDataID DataID;
    /* 0x0004 */ ECameraContextDataType DataType;
    /* 0x0008 */ ECameraContextDataContainerType DataContainerType;
    /* 0x0010 */ UObject* DataTypeObject;
    /* 0x0018 */ bool bAutoReset;
};

// Size: 0x4
struct FCameraContextDataID {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x10
struct FCameraContextDataTableAllocationInfo {
    /* 0x0000 */ TArray<FCameraContextDataDefinition> DataDefinitions;
};

// Size: 0x40
class UCameraDirector : public UObject {
    /* 0x0028 */ FCameraRigProxyRedirectTable CameraRigProxyRedirectTable;
    /* 0x0038 */ UCameraRigProxyTable* CameraRigProxyTable;
};

// Size: 0x20
struct FCameraDirectorStateTreeEvaluationData {
    /* 0x0000 */ TArray<UCameraRigAsset*> ActiveCameraRigs;
    /* 0x0010 */ TArray<UCameraRigProxyAsset*> ActiveCameraRigProxies;
};

// Size: 0x38
class UCameraDirectorStateTreeSchema : public UStateTreeSchema {
    /* 0x0028 */ TArray<FStateTreeExternalDataDesc> ContextDataDescs;
};

// Size: 0x20
struct FCameraFramingZone {
    /* 0x0000 */ double Left;
    /* 0x0008 */ double Top;
    /* 0x0010 */ double Right;
    /* 0x0018 */ double Bottom;
};

// Size: 0x28
struct FCameraFramingZoneParameter {
    /* 0x0000 */ FCameraFramingZone Value;
    /* 0x0020 */ FCameraVariableID VariableID;
};

// Size: 0x38
class UCameraNode : public UObject {
    /* 0x0030 */ bool bIsEnabled;
};

// Size: 0x4
struct FCameraNodeEvaluatorAllocationInfo {
    /* 0x0000 */ int16_t TotalSizeof;
    /* 0x0002 */ int16_t MaxAlignof;
};

// Size: 0x28
struct FCameraObjectAllocationInfo {
    /* 0x0000 */ FCameraNodeEvaluatorAllocationInfo EvaluatorInfo;
    /* 0x0008 */ FCameraVariableTableAllocationInfo VariableTableInfo;
    /* 0x0018 */ FCameraContextDataTableAllocationInfo ContextDataTableInfo;
};

// Size: 0x30
struct FCameraObjectInterface {
    /* 0x0000 */ TArray<UCameraObjectInterfaceBlendableParameter*> BlendableParameters;
    /* 0x0010 */ TArray<UCameraObjectInterfaceDataParameter*> DataParameters;
    /* 0x0020 */ FString DisplayName;
};

// Size: 0x80
class UCameraObjectInterfaceBlendableParameter : public UCameraObjectInterfaceParameterBase {
    /* 0x0060 */ ECameraVariableType ParameterType;
    /* 0x0068 */ UScriptStruct* BlendableStructType;
    /* 0x0070 */ bool bIsPreBlended;
    /* 0x0074 */ FCameraVariableID PrivateVariableID;
    /* 0x0078 */ UCameraVariableAsset* PrivateVariable;
};

// Size: 0x78
class UCameraObjectInterfaceDataParameter : public UCameraObjectInterfaceParameterBase {
    /* 0x0060 */ ECameraContextDataType DataType;
    /* 0x0064 */ ECameraContextDataContainerType DataContainerType;
    /* 0x0068 */ UObject* DataTypeObject;
    /* 0x0070 */ FCameraContextDataID PrivateDataID;
};

// Size: 0x60
class UCameraObjectInterfaceParameterBase : public UObject {
    /* 0x0030 */ FString InterfaceParameterName;
    /* 0x0040 */ UCameraNode* Target;
    /* 0x0048 */ FName TargetPropertyName;
    /* 0x0050 */ FGuid Guid;
};

// Size: 0x48
struct FCameraObjectInterfaceParameterDefinition {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ FGuid ParameterGuid;
    /* 0x0018 */ ECameraObjectInterfaceParameterType ParameterType;
    /* 0x001c */ FCameraVariableID VariableID;
    /* 0x0020 */ ECameraVariableType VariableType;
    /* 0x0028 */ UScriptStruct* BlendableStructType;
    /* 0x0030 */ FCameraContextDataID DataID;
    /* 0x0034 */ ECameraContextDataType DataType;
    /* 0x0038 */ ECameraContextDataContainerType DataContainerType;
    /* 0x0040 */ UObject* DataTypeObject;
};

// Size: 0x1c
struct FCameraObjectInterfaceParameterMetaData {
    /* 0x0000 */ FGuid ParameterGuid;
    /* 0x0010 */ FCameraVariableID OverrideVariableID;
    /* 0x0014 */ FCameraContextDataID OverrideDataID;
    /* 0x0018 */ bool bIsOverridden;
    /* 0x0019 */ bool bIsAnimated;
};

// Size: 0x18
struct FCameraParameterClamping {
    /* 0x0000 */ double MinValue;
    /* 0x0008 */ double MaxValue;
    /* 0x0010 */ bool bClampMin;
    /* 0x0011 */ bool bClampMax;
};

// Size: 0x10
struct FCameraParameterNormalization {
    /* 0x0000 */ double MaxValue;
    /* 0x0008 */ bool bNormalize;
};

// Size: 0x88
struct FCameraPose {
    /* 0x0000 */ FVector3d Location;
    /* 0x0018 */ FRotator3d Rotation;
    /* 0x0030 */ double TargetDistance;
    /* 0x0038 */ float FieldOfView;
    /* 0x003c */ float FocalLength;
    /* 0x0040 */ float OrthographicWidth;
    /* 0x0044 */ float Aperture;
    /* 0x0048 */ float ShutterSpeed;
    /* 0x004c */ float FocusDistance;
    /* 0x0050 */ float SensorWidth;
    /* 0x0054 */ float SensorHeight;
    /* 0x0058 */ float SensorHorizontalOffset;
    /* 0x005c */ float SensorVerticalOffset;
    /* 0x0060 */ float ISO;
    /* 0x0064 */ float SqueezeFactor;
    /* 0x0068 */ float Overscan;
    /* 0x006c */ int32_t DiaphragmBladeCount;
    /* 0x0070 */ float NearClippingPlane;
    /* 0x0074 */ float FarClippingPlane;
    /* 0x0078 */ float PhysicalCameraBlendWeight;
    /* 0x007c */ bool EnablePhysicalCamera;
    /* 0x007d */ bool ConstrainAspectRatio;
    /* 0x007e */ bool OverrideAspectRatioAxisConstraint;
    /* 0x007f */ uint8_t AspectRatioAxisConstraint;
    /* 0x0080 */ uint8_t ProjectionMode;
};

// Size: 0x128
class UCameraRigAsset : public UBaseCameraObject {
    /* 0x00c8 */ UCameraNode* RootNode;
    /* 0x00d0 */ FGameplayTagContainer GameplayTags;
    /* 0x00f0 */ TArray<UCameraRigTransition*> EnterTransitions;
    /* 0x0100 */ TArray<UCameraRigTransition*> ExitTransitions;
    /* 0x0110 */ ECameraRigInitialOrientation InitialOrientation;
    /* 0x0114 */ ECameraBuildStatus BuildStatus;
    /* 0x0118 */ FGuid Guid;
};

// Size: 0x120
struct FCameraRigAssetReference : public FBaseCameraObjectReference {
    /* 0x0028 */ UCameraRigAsset* CameraRig;
    /* 0x0030 */ TArray<FGuid> ParameterOverrideGuids;
    /* 0x0040 */ FCameraRigParameterOverrides ParameterOverrides;
};

// Size: 0x168
class UCameraRigCameraNode : public UCameraNode {
    /* 0x0048 */ FCameraRigAssetReference CameraRigReference;
};

// Size: 0x88
class UCameraRigInput1DSlot : public UInput1DCameraNode {
    /* 0x0038 */ FCameraRigInputSlotParameters InputSlotParameters;
    /* 0x0040 */ FCameraParameterClamping clamp;
    /* 0x0058 */ FCameraParameterNormalization Normalize;
    /* 0x0068 */ EBuiltInDoubleCameraVariable BuiltInVariable;
    /* 0x0070 */ FDoubleCameraVariableReference CustomVariable;
    /* 0x0080 */ FCameraVariableID TransientVariableID;
    /* 0x0084 */ FCameraVariableID VariableID;
};

// Size: 0xb0
class UCameraRigInput2DSlot : public UInput2DCameraNode {
    /* 0x0038 */ FCameraRigInputSlotParameters InputSlotParameters;
    /* 0x0040 */ FCameraParameterClamping ClampX;
    /* 0x0058 */ FCameraParameterClamping ClampY;
    /* 0x0070 */ FCameraParameterNormalization NormalizeX;
    /* 0x0080 */ FCameraParameterNormalization NormalizeY;
    /* 0x0090 */ EBuiltInVector2dCameraVariable BuiltInVariable;
    /* 0x0098 */ FVector2dCameraVariableReference CustomVariable;
    /* 0x00a8 */ FCameraVariableID TransientVariableID;
    /* 0x00ac */ FCameraVariableID VariableID;
};

// Size: 0x2
struct FCameraRigInputSlotParameters {
    /* 0x0000 */ bool bIsAccumulated;
    /* 0x0001 */ bool bIsPreBlended;
};

// Size: 0x28
class UCameraRigInstanceFunctions : public UBlueprintFunctionLibrary {

    static bool IsValid(FCameraRigInstanceID InstanceId);
};

// Size: 0x8
struct FCameraRigInstanceID {
    /* 0x0000 */ uint32_t Value;
    /* 0x0004 */ ECameraRigLayer Layer;
};

// Size: 0x28
class UCameraRigParameterInterop : public UBlueprintFunctionLibrary {

    static void GetCameraParameter(const FBlueprintCameraEvaluationDataRef& CameraData, UCameraRigAsset* CameraRig, FName ParameterName, int32_t& ReturnValue);
    static void SetCameraParameter(const FBlueprintCameraEvaluationDataRef& CameraData, UCameraRigAsset* CameraRig, FName ParameterName, const int32_t& NewValue);
};

// Size: 0x38
struct FCameraRigParameterOverrideBase {
    /* 0x0000 */ FGuid InterfaceParameterGuid;
    /* 0x0010 */ FGuid PrivateVariableGuid;
    /* 0x0020 */ FString InterfaceParameterName;
    /* 0x0030 */ bool bInvalid;
};

// Size: 0xe0
struct FCameraRigParameterOverrides {
    /* 0x0000 */ TArray<FBooleanCameraRigParameterOverride> BooleanOverrides;
    /* 0x0010 */ TArray<FInteger32CameraRigParameterOverride> Integer32Overrides;
    /* 0x0020 */ TArray<FFloatCameraRigParameterOverride> FloatOverrides;
    /* 0x0030 */ TArray<FDoubleCameraRigParameterOverride> DoubleOverrides;
    /* 0x0040 */ TArray<FVector2fCameraRigParameterOverride> Vector2fOverrides;
    /* 0x0050 */ TArray<FVector2dCameraRigParameterOverride> Vector2dOverrides;
    /* 0x0060 */ TArray<FVector3fCameraRigParameterOverride> Vector3fOverrides;
    /* 0x0070 */ TArray<FVector3dCameraRigParameterOverride> Vector3dOverrides;
    /* 0x0080 */ TArray<FVector4fCameraRigParameterOverride> Vector4fOverrides;
    /* 0x0090 */ TArray<FVector4dCameraRigParameterOverride> Vector4dOverrides;
    /* 0x00a0 */ TArray<FRotator3fCameraRigParameterOverride> Rotator3fOverrides;
    /* 0x00b0 */ TArray<FRotator3dCameraRigParameterOverride> Rotator3dOverrides;
    /* 0x00c0 */ TArray<FTransform3fCameraRigParameterOverride> Transform3fOverrides;
    /* 0x00d0 */ TArray<FTransform3dCameraRigParameterOverride> Transform3dOverrides;
};

// Size: 0x38
class UCameraRigProxyAsset : public UObject {
    /* 0x0028 */ FGuid Guid;
};

// Size: 0x10
struct FCameraRigProxyRedirectTable {
    /* 0x0000 */ TArray<FCameraRigProxyRedirectTableEntry> Entries;
};

// Size: 0x10
struct FCameraRigProxyRedirectTableEntry {
    /* 0x0000 */ UCameraRigProxyAsset* CameraRigProxy;
    /* 0x0008 */ UCameraRigAsset* CameraRig;
};

// Size: 0x38
class UCameraRigProxyTable : public UObject {
    /* 0x0028 */ TArray<FCameraRigProxyRedirectTableEntry> Entries;
};

// Size: 0x50
class UCameraRigTransition : public UObject {
    /* 0x0030 */ TArray<UCameraRigTransitionCondition*> Conditions;
    /* 0x0040 */ UBlendCameraNode* Blend;
    /* 0x0048 */ ECameraRigInitialOrientation InitialOrientation;
    /* 0x004c */ bool bOverrideInitialOrientation;
    /* 0x004d */ bool bAllowCameraRigMerging;
};

// Size: 0x30
class UCameraRigTransitionCondition : public UObject {
};

// Size: 0x180
struct FCameraRotatorCurve {
    /* 0x0000 */ FRichCurve Curves[3];
};

// Size: 0xf0
class UCameraShakeAsset : public UBaseCameraObject {
    /* 0x00c0 */ UShakeCameraNode* RootNode;
    /* 0x00c8 */ USimpleFixedTimeBlendCameraNode* BlendIn;
    /* 0x00d0 */ USimpleFixedTimeBlendCameraNode* BlendOut;
    /* 0x00d8 */ bool bIsSingleInstance;
    /* 0x00d9 */ ECameraBuildStatus BuildStatus;
    /* 0x00dc */ FGuid Guid;
};

// Size: 0x30
struct FCameraShakeAssetReference : public FBaseCameraObjectReference {
    /* 0x0028 */ UCameraShakeAsset* CameraShake;
};

// Size: 0x78
class UCameraShakeCameraNode : public UCameraNode {
    /* 0x0040 */ FCameraShakeAssetReference CameraShakeReference;
    /* 0x0070 */ ECameraShakeEvaluationMode EvaluationMode;
};

// Size: 0x38
class UCameraShakeServiceCameraNode : public UCameraNode {
};

// Size: 0x80
struct FCameraSingleCurve {
    /* 0x0000 */ FRichCurve Curve;
};

// Size: 0x28
class UCameraValueInterpolator : public UObject {
};

// Size: 0x40
class UCameraVariableAsset : public UObject {
    /* 0x0028 */ bool bAutoReset;
    /* 0x0029 */ bool bIsPrivate;
    /* 0x002a */ bool bIsInput;
    /* 0x002c */ FGuid Guid;
};

// Size: 0x38
class UCameraVariableCollection : public UObject {
    /* 0x0028 */ TArray<UCameraVariableAsset*> Variables;
};

// Size: 0x18
struct FCameraVariableDefinition {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0004 */ ECameraVariableType VariableType;
    /* 0x0008 */ UScriptStruct* BlendableStructType;
    /* 0x0010 */ bool bIsPrivate;
    /* 0x0011 */ bool bIsInput;
    /* 0x0012 */ bool bAutoReset;
};

// Size: 0x4
struct FCameraVariableID {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x8
struct FCameraVariableSetterHandle {
    /* 0x0000 */ uint32_t Value;
    /* 0x0004 */ uint32_t SerialNumber;
};

// Size: 0x10
struct FCameraVariableTableAllocationInfo {
    /* 0x0000 */ TArray<FCameraVariableDefinition> VariableDefinitions;
};

// Size: 0x180
struct FCameraVectorCurve {
    /* 0x0000 */ FRichCurve Curves[3];
};

// Size: 0x68
class UClippingPlanesCameraNode : public UCameraNode {
    /* 0x0038 */ FDoubleCameraParameter NearPlane;
    /* 0x0050 */ FDoubleCameraParameter FarPlane;
};

// Size: 0xc0
class UCollisionPushCameraNode : public UCameraNode {
    /* 0x0038 */ ECollisionSafePosition SafePosition;
    /* 0x0040 */ FVector3dCameraVariableReference CustomSafePosition;
    /* 0x0050 */ FVector3dCameraParameter SafePositionOffset;
    /* 0x0078 */ ECollisionSafePositionOffsetSpace SafePositionOffsetSpace;
    /* 0x0080 */ FBooleanCameraVariableReference EnableCollision;
    /* 0x0090 */ FFloatCameraParameter CollisionSphereRadius;
    /* 0x00a0 */ uint8_t CollisionChannel;
    /* 0x00a8 */ UCameraValueInterpolator* PushInterpolator;
    /* 0x00b0 */ UCameraValueInterpolator* PullInterpolator;
    /* 0x00b8 */ bool bRunAsyncCollision;
};

// Size: 0x48
class UCombinedCameraRigsCameraNode : public UCameraNode {
    /* 0x0038 */ TArray<FCameraRigAssetReference> CameraRigReferences;
};

// Size: 0x48
class UCompositeShakeCameraNode : public UShakeCameraNode {
    /* 0x0038 */ TArray<UShakeCameraNode*> Shakes;
};

// Size: 0xe8
class UControllerGameplayCameraEvaluationComponent : public UActorComponent {
    /* 0x00d8 */ TScriptInterface<IGameplayCameraSystemHost> CameraSystemHost;
};

// Size: 0x30
class UCriticalDamperValueInterpolator : public UCameraValueInterpolator {
    /* 0x0028 */ float DampingFactor;
};

// Size: 0x28
struct FCustomCameraNodeBlendableParameter {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ ECameraVariableType ParameterType;
    /* 0x0010 */ UScriptStruct* BlendableStructType;
    /* 0x0018 */ FCameraVariableID OverrideVariableID;
    /* 0x0020 */ UCameraVariableAsset* OverrideVariable;
};

// Size: 0x20
struct FCustomCameraNodeDataParameter {
    /* 0x0000 */ FName ParameterName;
    /* 0x0008 */ ECameraContextDataType ParameterType;
    /* 0x000c */ ECameraContextDataContainerType ParameterContainerType;
    /* 0x0010 */ UObject* ParameterTypeObject;
    /* 0x0018 */ FCameraContextDataID OverrideDataID;
};

// Size: 0x28
class ICustomCameraNodeParameterProvider : public UInterface {
};

// Size: 0x20
struct FCustomCameraNodeParameters {
    /* 0x0000 */ TArray<FCustomCameraNodeBlendableParameter> BlendableParameters;
    /* 0x0010 */ TArray<FCustomCameraNodeDataParameter> DataParameters;
};

// Size: 0x70
class UDampenPositionCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter ForwardDampingFactor;
    /* 0x0048 */ FFloatCameraParameter LateralDampingFactor;
    /* 0x0058 */ FFloatCameraParameter VerticalDampingFactor;
    /* 0x0068 */ ECameraNodeSpace DampenSpace;
};

// Size: 0x68
class UDampenRotationCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter YawDampingFactor;
    /* 0x0048 */ FFloatCameraParameter PitchDampingFactor;
    /* 0x0058 */ FFloatCameraParameter RollDampingFactor;
};

// Size: 0x58
class UDefaultRootCameraNode : public URootCameraNode {
    /* 0x0038 */ UBlendStackCameraNode* BaseLayer;
    /* 0x0040 */ UBlendStackCameraNode* MainLayer;
    /* 0x0048 */ UBlendStackCameraNode* GlobalLayer;
    /* 0x0050 */ UBlendStackCameraNode* VisualLayer;
};

// Size: 0x190
class UDollyFramingCameraNode : public UBaseFramingCameraNode {
    /* 0x0170 */ FBooleanCameraParameter CanMoveLaterally;
    /* 0x0180 */ FBooleanCameraParameter CanMoveVertically;
};

// Size: 0x18
struct FDoubleCameraParameter {
    /* 0x0000 */ double Value;
    /* 0x0008 */ FCameraVariableID VariableID;
    /* 0x0010 */ UDoubleCameraVariable* Variable;
};

// Size: 0x50
struct FDoubleCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FDoubleCameraParameter Value;
};

// Size: 0x48
class UDoubleCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ double DefaultValue;
};

// Size: 0x10
struct FDoubleCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UDoubleCameraVariable* Variable;
};

// Size: 0x38
class UDoubleIIRValueInterpolator : public UCameraValueInterpolator {
    /* 0x0028 */ float PrimarySpeed;
    /* 0x002c */ float IntermediateSpeed;
    /* 0x0030 */ bool bUseFixedStep;
};

enum class EBuiltInDoubleCameraVariable {
    None = 0,
    Yaw = 1,
    Pitch = 2,
    Roll = 3,
    Zoom = 4,
    EBuiltInDoubleCameraVariable_MAX = 5,
};

enum class EBuiltInRotator3dCameraVariable {
    None = 0,
    ControlRotation = 1,
    EBuiltInRotator3dCameraVariable_MAX = 2,
};

enum class EBuiltInVector2dCameraVariable {
    None = 0,
    YawPitch = 1,
    EBuiltInVector2dCameraVariable_MAX = 2,
};

enum class ECameraAutoRotateDirection {
    Facing = 0,
    Movement = 1,
    MovementOrFacing = 2,
    ECameraAutoRotateDirection_MAX = 3,
};

enum class ECameraBlendStackType {
    IsolatedTransient = 0,
    AdditivePersistent = 1,
    ECameraBlendStackType_MAX = 2,
};

enum class ECameraBuildStatus {
    Clean = 0,
    CleanWithWarnings = 1,
    WithErrors = 2,
    Dirty = 3,
    ECameraBuildStatus_MAX = 4,
};

enum class ECameraContextDataContainerType {
    None = 0,
    Array = 1,
    ECameraContextDataContainerType_MAX = 2,
};

enum class ECameraContextDataType {
    Name = 0,
    String = 1,
    Enum = 2,
    Struct = 3,
    Object = 4,
    Class = 5,
    Count = 6,
    ECameraContextDataType_MAX = 7,
};

enum class ECameraEvaluationDataCondition {
    ActiveCameraRig = 0,
    ECameraEvaluationDataCondition_MAX = 1,
};

enum class ECameraNodeOriginPosition {
    CameraPose = 0,
    ActiveContext = 1,
    OwningContext = 2,
    Pivot = 3,
    Pawn = 4,
    ECameraNodeOriginPosition_MAX = 5,
};

enum class ECameraNodeSpace {
    CameraPose = 0,
    ActiveContext = 1,
    OwningContext = 2,
    Pivot = 3,
    Pawn = 4,
    World = 5,
    ECameraNodeSpace_MAX = 6,
};

enum class ECameraObjectInterfaceParameterType {
    Blendable = 0,
    Data = 1,
    ECameraObjectInterfaceParameterType_MAX = 2,
};

enum class ECameraRigInitialOrientation {
    None = 0,
    ContextYawPitch = 1,
    PreviousYawPitch = 2,
    PreviousAbsoluteTarget = 3,
    PreviousRelativeTarget = 4,
    ECameraRigInitialOrientation_MAX = 5,
};

enum class ECameraRigLayer {
    None = 0,
    Base = 1,
    Main = 2,
    Global = 3,
    Visual = 4,
    ECameraRigLayer_MAX = 5,
};

enum class ECameraShakeEvaluationMode {
    Inline = 0,
    VisualLayer = 1,
    ECameraShakeEvaluationMode_MAX = 2,
};

enum class ECameraTargetShape {
    Point = 0,
    AutomaticBounds = 1,
    ManualBounds = 2,
    ECameraTargetShape_MAX = 3,
};

enum class ECameraVariableSetterBlendType {
    None = 0,
    Linear = 1,
    SmoothStep = 2,
    SmootherStep = 3,
    ECameraVariableSetterBlendType_MAX = 4,
};

enum class ECameraVariableType {
    Boolean = 0,
    Integer32 = 1,
    Float = 2,
    Double = 3,
    Vector2f = 4,
    Vector2d = 5,
    Vector3f = 6,
    Vector3d = 7,
    Vector4f = 8,
    Vector4d = 9,
    Rotator3f = 10,
    Rotator3d = 11,
    Transform3f = 12,
    Transform3d = 13,
    BlendableStruct = 14,
    ECameraVariableType_MAX = 15,
};

enum class ECollisionSafePosition {
    ActiveContext = 0,
    OwningContext = 1,
    Pivot = 2,
    Pawn = 3,
    ECollisionSafePosition_MAX = 4,
};

enum class ECollisionSafePositionOffsetSpace {
    ActiveContext = 0,
    OwningContext = 1,
    Pivot = 2,
    CameraPose = 3,
    Pawn = 4,
    ECollisionSafePositionOffsetSpace_MAX = 5,
};

enum class EGameplayCameraComponentActivationMode {
    Push = 0,
    PushAndInsert = 1,
    InsertOrPush = 2,
    EGameplayCameraComponentActivationMode_MAX = 3,
};

enum class EGameplayCamerasViewRotationMode {
    None = 0,
    PreviewUpdate = 1,
    EGameplayCamerasViewRotationMode_MAX = 2,
};

enum class ESmoothCameraBlendType {
    SmoothStep = 0,
    SmootherStep = 1,
    ESmoothCameraBlendType_MAX = 2,
};

// Size: 0x70
class UEnvelopeShakeCameraNode : public UShakeCameraNode {
    /* 0x0038 */ FFloatCameraParameter EaseInTime;
    /* 0x0048 */ FFloatCameraParameter EaseOutTime;
    /* 0x0058 */ FFloatCameraParameter totalTime;
    /* 0x0068 */ UShakeCameraNode* Shake;
};

// Size: 0x48
class UFieldOfViewCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter FieldOfView;
};

// Size: 0xb0
class UFilmbackCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter SensorWidth;
    /* 0x0048 */ FFloatCameraParameter SensorHeight;
    /* 0x0058 */ FFloatCameraParameter SensorHorizontalOffset;
    /* 0x0068 */ FFloatCameraParameter SensorVerticalOffset;
    /* 0x0078 */ FFloatCameraParameter Overscan;
    /* 0x0088 */ FBooleanCameraParameter ConstrainAspectRatio;
    /* 0x0098 */ FBooleanCameraParameter OverrideAspectRatioAxisConstraint;
    /* 0x00a8 */ uint8_t AspectRatioAxisConstraint;
};

// Size: 0x10
struct FFloatCameraParameter {
    /* 0x0000 */ float Value;
    /* 0x0004 */ FCameraVariableID VariableID;
    /* 0x0008 */ UFloatCameraVariable* Variable;
};

// Size: 0x48
struct FFloatCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FFloatCameraParameter Value;
};

// Size: 0x48
class UFloatCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ float DefaultValue;
};

// Size: 0x10
struct FFloatCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UFloatCameraVariable* Variable;
};

// Size: 0x2b0
class AGameplayCameraActor : public AGameplayCameraActorBase {
    /* 0x02a8 */ UGameplayCameraComponent* CameraComponent;

    UGameplayCameraComponent* GetCameraComponent() const;
};

// Size: 0x2a8
class AGameplayCameraActorBase : public AActor {
};

// Size: 0x2c0
class UGameplayCameraComponent : public UGameplayCameraComponentBase {
    /* 0x0280 */ FCameraAssetReference CameraReference;
    /* 0x02b8 */ UCameraAsset* Camera;
};

// Size: 0x280
class UGameplayCameraComponentBase : public USceneComponent {
    /* 0x0258 */ uint8_t AutoActivateForPlayer;
    /* 0x0259 */ bool bSetControlRotationWhenViewTarget;
    /* 0x0260 */ UCineCameraComponent* OutputCameraComponent;

    void ActivateCameraForPlayerController(APlayerController* PlayerController, bool bSetAsViewTarget, EGameplayCameraComponentActivationMode ActivationMode);
    void ActivateCameraForPlayerIndex(int32_t PlayerIndex, bool bSetAsViewTarget, EGameplayCameraComponentActivationMode ActivationMode);
    void DeactivateCamera(bool bImmediately);
    FBlueprintCameraEvaluationDataRef GetConditionalResult(ECameraEvaluationDataCondition Condition) const;
    FBlueprintCameraEvaluationDataRef GetInitialResult() const;
    UCineCameraComponent* GetOutputCameraComponent() const;
};

// Size: 0x1f8
class UGameplayCameraParameterSetterComponent : public UActorComponent {
    /* 0x00b8 */ FCameraRigAssetReference CameraRigReference;
    /* 0x01d8 */ float BlendInTime;
    /* 0x01dc */ float BlendOutTime;
    /* 0x01e0 */ ECameraVariableSetterBlendType BlendType;

    void OnActorBeginOverlap(AActor* OverlappedActor, AActor* OtherActor);
    void OnActorEndOverlap(AActor* OverlappedActor, AActor* OtherActor);
    void StartParameterSetters();
    void StopParameterSetters(bool bImmediately);
};

// Size: 0x2b0
class AGameplayCameraRigActor : public AGameplayCameraActorBase {
    /* 0x02a8 */ UGameplayCameraRigComponent* CameraRigComponent;

    UGameplayCameraRigComponent* GetCameraRigComponent() const;
};

// Size: 0x3b0
class UGameplayCameraRigComponent : public UGameplayCameraComponentBase {
    /* 0x0280 */ FCameraRigAssetReference CameraRigReference;
    /* 0x03a0 */ UCameraAsset* GeneratedCameraAsset;
};

// Size: 0x2b0
class AGameplayCameraSystemActor : public AActor {
    /* 0x02a8 */ UGameplayCameraSystemComponent* CameraSystemComponent;

    UGameplayCameraSystemComponent* GetCameraSystemComponent() const;
};

// Size: 0x270
class UGameplayCameraSystemComponent : public USceneComponent {
    /* 0x0258 */ uint8_t AutoActivateForPlayer;
    /* 0x0259 */ bool bSetPlayerControllerRotation;
    /* 0x025c */ TWeakObjectPtr<APlayerController> WeakPlayerController;

    void ActivateCameraSystemForPlayerController(APlayerController* PlayerController);
    void ActivateCameraSystemForPlayerIndex(int32_t PlayerIndex);
    void DeactivateCameraSystem(AActor* NextViewTarget);
    bool IsCameraSystemActiveForPlayController(APlayerController* PlayerController) const;
    FCameraRigInstanceID StartGlobalCameraModifierRig(const UCameraRigAsset* CameraRig, int32_t OrderKey);
    FCameraRigInstanceID StartVisualCameraModifierRig(const UCameraRigAsset* CameraRig, int32_t OrderKey);
    void StopCameraModifierRig(FCameraRigInstanceID InstanceId, bool bImmediately);
};

// Size: 0x28
class IGameplayCameraSystemHost : public UInterface {
};

// Size: 0x30
struct FGameplayCamerasActivateCameraRigTask : public FGameplayCamerasStateTreeTask {
    /* 0x002e */ bool bRunOnce;
};

// Size: 0x8
struct FGameplayCamerasActivateCameraRigTaskInstanceData {
    /* 0x0000 */ UCameraRigAsset* CameraRig;
};

// Size: 0x30
struct FGameplayCamerasActivateCameraRigViaProxyTask : public FGameplayCamerasStateTreeTask {
    /* 0x002e */ bool bRunOnce;
};

// Size: 0x8
struct FGameplayCamerasActivateCameraRigViaProxyTaskInstanceData {
    /* 0x0000 */ UCameraRigProxyAsset* CameraRigProxy;
};

// Size: 0x30e0
class AGameplayCamerasPlayerCameraManager : public APlayerCameraManager {
    /* 0x27f0 */ EGameplayCamerasViewRotationMode ViewRotationMode;
    /* 0x27f4 */ bool bOverrideViewRotationMode;
    /* 0x27f8 */ APlayerCameraManager* OriginalCameraManager;

    void ReleasePlayerController();
    FCameraRigInstanceID StartGlobalCameraModifierRig(const UCameraRigAsset* CameraRig, int32_t OrderKey);
    FCameraRigInstanceID StartVisualCameraModifierRig(const UCameraRigAsset* CameraRig, int32_t OrderKey);
    void StealPlayerController(APlayerController* PlayerController);
    void StopCameraModifierRig(FCameraRigInstanceID InstanceId, bool bImmediately);
};

// Size: 0x68
class UGameplayCamerasSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bAutoBuildInPIE;
    /* 0x003c */ EGameplayCamerasViewRotationMode DefaultViewRotationMode;
    /* 0x0040 */ int32_t CombinedCameraRigNumThreshold;
    /* 0x0048 */ double DefaultIKAimingAngleTolerance;
    /* 0x0050 */ double DefaultIKAimingDistanceTolerance;
    /* 0x0058 */ uint8_t DefaultIKAimingMaxIterations;
    /* 0x0060 */ double DefaultIKAimingMinDistance;
};

// Size: 0x28
struct FGameplayCamerasStateTreeCondition : public FStateTreeConditionBase {
};

// Size: 0x28
struct FGameplayCamerasStateTreeTask : public FStateTreeTaskBase {
};

// Size: 0x100
class UGameplayControlRotationComponent : public UActorComponent {
    /* 0x00b8 */ TArray<UInputAction*> AxisActions;
    /* 0x00c8 */ float AxisActionAngularSpeedThreshold;
    /* 0x00cc */ float AxisActionMagnitudeThreshold;
    /* 0x00d0 */ uint8_t AutoActivateForPlayer;
    /* 0x00d8 */ APlayerController* PlayerController;
    /* 0x00e0 */ TScriptInterface<IGameplayCameraSystemHost> CameraSystemHost;

    void ActivateControlRotationManagementForPlayerController(APlayerController* PlayerController);
    void ActivateControlRotationManagementForPlayerIndex(int32_t PlayerIndex);
    void DeactivateControlRotationManagement();
};

// Size: 0xc0
class UGameplayTagTransitionCondition : public UCameraRigTransitionCondition {
    /* 0x0030 */ FGameplayTagQuery PreviousGameplayTagQuery;
    /* 0x0078 */ FGameplayTagQuery NextGameplayTagQuery;
};

// Size: 0x28
class IHasCameraBuildStatus : public UInterface {
};

// Size: 0x30
class UIIRValueInterpolator : public UCameraValueInterpolator {
    /* 0x0028 */ float Speed;
    /* 0x002c */ bool bUseFixedStep;
};

// Size: 0x38
class UInput1DCameraNode : public UCameraNode {
};

// Size: 0x38
class UInput2DCameraNode : public UCameraNode {
};

// Size: 0x100
class UInputAxisBinding2DCameraNode : public UCameraRigInput2DSlot {
    /* 0x00b0 */ TArray<UInputAction*> AxisActions;
    /* 0x00c0 */ FBooleanCameraParameter RevertAxisX;
    /* 0x00d0 */ FBooleanCameraParameter RevertAxisY;
    /* 0x00e0 */ FVector2dCameraParameter Multiplier;
};

// Size: 0x10
struct FInteger32CameraParameter {
    /* 0x0000 */ int32_t Value;
    /* 0x0004 */ FCameraVariableID VariableID;
    /* 0x0008 */ UInteger32CameraVariable* Variable;
};

// Size: 0x48
struct FInteger32CameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FInteger32CameraParameter Value;
};

// Size: 0x48
class UInteger32CameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ int32_t DefaultValue;
};

// Size: 0x10
struct FInteger32CameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UInteger32CameraVariable* Variable;
};

// Size: 0x40
class UIsCameraRigTransitionCondition : public UCameraRigTransitionCondition {
    /* 0x0030 */ UCameraRigAsset* PreviousCameraRig;
    /* 0x0038 */ UCameraRigAsset* NextCameraRig;
};

// Size: 0x40
class ULensCalibrationCameraNode : public UCameraNode {
    /* 0x0038 */ ULensFile* LensFile;
};

// Size: 0x78
class ULensParametersCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter FocalLength;
    /* 0x0048 */ FFloatCameraParameter FocusDistance;
    /* 0x0058 */ FFloatCameraParameter Aperture;
    /* 0x0068 */ FBooleanCameraParameter EnablePhysicalCamera;
};

// Size: 0x40
class ULinearBlendCameraNode : public USimpleFixedTimeBlendCameraNode {
};

// Size: 0x50
class ULocationRotationBlendCameraNode : public UBlendCameraNode {
    /* 0x0038 */ USimpleBlendCameraNode* LocationBlend;
    /* 0x0040 */ USimpleBlendCameraNode* RotationBlend;
    /* 0x0048 */ USimpleBlendCameraNode* OtherBlend;
};

// Size: 0x58
class UMovieSceneCameraFramingZonePropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x570
class UMovieSceneCameraFramingZoneSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneDoubleChannel LeftMarginCurve;
    /* 0x0228 */ FMovieSceneDoubleChannel TopMarginCurve;
    /* 0x0340 */ FMovieSceneDoubleChannel RightMarginCurve;
    /* 0x0458 */ FMovieSceneDoubleChannel BottomMarginCurve;
};

// Size: 0x140
class UMovieSceneCameraFramingZoneTrack : public UMovieScenePropertyTrack {
};

// Size: 0x30
class UMovieSceneCameraParameterDecoration : public UObject {
};

// Size: 0x50
class UMovieSceneCameraParameterInstantiator : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x30
class UObjectTreeGraphComment : public UObject {
};

// Size: 0x28
class IObjectTreeGraphObject : public UInterface {
};

// Size: 0x28
class IObjectTreeGraphRootObject : public UInterface {
};

// Size: 0x80
class UOcclusionMaterialCameraNode : public UCameraNode {
    /* 0x0038 */ UMaterialInterface* OcclusionTransparencyMaterial;
    /* 0x0040 */ FFloatCameraParameter OcclusionSphereRadius;
    /* 0x0050 */ uint8_t OcclusionChannel;
    /* 0x0051 */ ECameraNodeOriginPosition OcclusionTargetPosition;
    /* 0x0052 */ ECameraNodeSpace OcclusionTargetOffsetSpace;
    /* 0x0058 */ FVector3dCameraParameter OcclusionTargetOffset;
};

// Size: 0x90
class UOffsetCameraNode : public UCameraNode {
    /* 0x0038 */ FVector3dCameraParameter TranslationOffset;
    /* 0x0060 */ FRotator3dCameraParameter RotationOffset;
    /* 0x0088 */ ECameraNodeSpace OffsetSpace;
};

// Size: 0x40
class UOrbitBlendCameraNode : public UBlendCameraNode {
    /* 0x0038 */ USimpleBlendCameraNode* DrivingBlend;
};

// Size: 0x58
class UOrthographicCameraNode : public UCameraNode {
    /* 0x0038 */ FBooleanCameraParameter EnableOrthographicMode;
    /* 0x0048 */ FFloatCameraParameter OrthographicWidth;
};

// Size: 0x190
class UPanningFramingCameraNode : public UBaseFramingCameraNode {
    /* 0x0170 */ FBooleanCameraParameter CanPanLaterally;
    /* 0x0180 */ FBooleanCameraParameter CanPanVertically;
};

// Size: 0x8
struct FPerlinNoiseData {
    /* 0x0000 */ float Amplitude;
    /* 0x0004 */ float Frequency;
};

// Size: 0x80
class UPerlinNoiseLocationShakeCameraNode : public UShakeCameraNode {
    /* 0x0038 */ FFloatCameraParameter AmplitudeMultiplier;
    /* 0x0048 */ FFloatCameraParameter FrequencyMultiplier;
    /* 0x0058 */ FInteger32CameraParameter Octaves;
    /* 0x0068 */ FPerlinNoiseData X;
    /* 0x0070 */ FPerlinNoiseData Y;
    /* 0x0078 */ FPerlinNoiseData Z;
};

// Size: 0x80
class UPerlinNoiseRotationShakeCameraNode : public UShakeCameraNode {
    /* 0x0038 */ FFloatCameraParameter AmplitudeMultiplier;
    /* 0x0048 */ FFloatCameraParameter FrequencyMultiplier;
    /* 0x0058 */ FInteger32CameraParameter Octaves;
    /* 0x0068 */ FPerlinNoiseData Yaw;
    /* 0x0070 */ FPerlinNoiseData Pitch;
    /* 0x0078 */ FPerlinNoiseData Roll;
};

// Size: 0x38
class UPopBlendCameraNode : public UBlendCameraNode {
};

// Size: 0x28
class UPopValueInterpolator : public UCameraValueInterpolator {
};

// Size: 0x7a0
class UPostProcessCameraNode : public UCameraNode {
    /* 0x0040 */ FPostProcessSettings PostProcessSettings;
};

// Size: 0x40
class UPriorityQueueCameraDirector : public UCameraDirector {
};

// Size: 0x38
class URootCameraNode : public UCameraNode {
};

// Size: 0x28
struct FRotator3dCameraParameter {
    /* 0x0000 */ FRotator Value;
    /* 0x0018 */ FCameraVariableID VariableID;
    /* 0x0020 */ URotator3dCameraVariable* Variable;
};

// Size: 0x60
struct FRotator3dCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FRotator3dCameraParameter Value;
};

// Size: 0x58
class URotator3dCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FRotator3d DefaultValue;
};

// Size: 0x10
struct FRotator3dCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ URotator3dCameraVariable* Variable;
};

// Size: 0x18
struct FRotator3fCameraParameter {
    /* 0x0000 */ FRotator3f Value;
    /* 0x000c */ FCameraVariableID VariableID;
    /* 0x0010 */ URotator3fCameraVariable* Variable;
};

// Size: 0x50
struct FRotator3fCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FRotator3fCameraParameter Value;
};

// Size: 0x50
class URotator3fCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FRotator3f DefaultValue;
};

// Size: 0x10
struct FRotator3fCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ URotator3fCameraVariable* Variable;
};

// Size: 0x68
class USetLocationCameraNode : public UCameraNode {
    /* 0x0038 */ FVector3dCameraParameter Location;
    /* 0x0060 */ ECameraNodeSpace OffsetSpace;
};

// Size: 0x68
class USetRotationCameraNode : public UCameraNode {
    /* 0x0038 */ FRotator3dCameraParameter Rotation;
    /* 0x0060 */ ECameraNodeSpace OffsetSpace;
};

// Size: 0x38
class UShakeCameraNode : public UCameraNode {
};

// Size: 0x38
class USimpleBlendCameraNode : public UBlendCameraNode {
};

// Size: 0x40
class USimpleFixedTimeBlendCameraNode : public USimpleBlendCameraNode {
    /* 0x0038 */ float BlendTime;
};

// Size: 0x48
class USingleCameraDirector : public UCameraDirector {
    /* 0x0040 */ UCameraRigAsset* CameraRig;
};

// Size: 0x48
class USmoothBlendCameraNode : public USimpleFixedTimeBlendCameraNode {
    /* 0x0040 */ ESmoothCameraBlendType BlendType;
};

// Size: 0xc8
class USplineFieldOfViewCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter SplineInput;
    /* 0x0048 */ FCameraSingleCurve FieldOfViewSpline;
};

// Size: 0x350
class USplineOffsetCameraNode : public UCameraNode {
    /* 0x0038 */ FFloatCameraParameter SplineInput;
    /* 0x0048 */ FCameraVectorCurve TranslationOffsetSpline;
    /* 0x01c8 */ FCameraRotatorCurve RotationOffsetSpline;
    /* 0x0348 */ ECameraNodeSpace OffsetSpace;
};

// Size: 0x4d8
class USplineOrbitCameraNode : public UCameraNode {
    /* 0x0038 */ FCameraVectorCurve LocationOffsetSpline;
    /* 0x01b8 */ FCameraVectorCurve TargetOffsetSpline;
    /* 0x0338 */ FCameraRotatorCurve RotationOffsetSpline;
    /* 0x04b8 */ FFloatCameraParameter LocationOffsetMultiplier;
    /* 0x04c8 */ ECameraNodeSpace TargetOffsetSpace;
    /* 0x04d0 */ UInput2DCameraNode* InputSlot;
};

// Size: 0x50
struct FSplineOrbitControlPoint {
    /* 0x0000 */ FVector3d LocationOffset;
    /* 0x0018 */ FVector3d TargetOffset;
    /* 0x0030 */ FRotator3d RotationOffset;
    /* 0x0048 */ float PitchAngle;
};

// Size: 0x68
class UStateTreeCameraDirector : public UCameraDirector {
    /* 0x0040 */ FStateTreeReference StateTreeReference;
};

// Size: 0x50
class UTargetRayCastCameraNode : public UCameraNode {
    /* 0x0038 */ uint8_t TraceChannel;
    /* 0x0040 */ FBooleanCameraParameter AutoFocus;
};

// Size: 0x70
struct FTransform3dCameraParameter {
    /* 0x0000 */ FTransform Value;
    /* 0x0060 */ FCameraVariableID VariableID;
    /* 0x0068 */ UTransform3dCameraVariable* Variable;
};

// Size: 0xb0
struct FTransform3dCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0040 */ FTransform3dCameraParameter Value;
};

// Size: 0xa0
class UTransform3dCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FTransform3d DefaultValue;
};

// Size: 0x10
struct FTransform3dCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UTransform3dCameraVariable* Variable;
};

// Size: 0x40
struct FTransform3fCameraParameter {
    /* 0x0000 */ FTransform3f Value;
    /* 0x0030 */ FCameraVariableID VariableID;
    /* 0x0038 */ UTransform3fCameraVariable* Variable;
};

// Size: 0x80
struct FTransform3fCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0040 */ FTransform3fCameraParameter Value;
};

// Size: 0x70
class UTransform3fCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FTransform3f DefaultValue;
};

// Size: 0x10
struct FTransform3fCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UTransform3fCameraVariable* Variable;
};

// Size: 0x78
class UUpdateTrackerCameraNode : public UCameraNode {
    /* 0x0038 */ FDoubleCameraParameter DoubleParameter;
    /* 0x0050 */ FVector3dCameraParameter VectorParameter;
};

// Size: 0x20
struct FVector2dCameraParameter {
    /* 0x0000 */ FVector2D Value;
    /* 0x0010 */ FCameraVariableID VariableID;
    /* 0x0018 */ UVector2dCameraVariable* Variable;
};

// Size: 0x58
struct FVector2dCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FVector2dCameraParameter Value;
};

// Size: 0x50
class UVector2dCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector2D DefaultValue;
};

// Size: 0x10
struct FVector2dCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector2dCameraVariable* Variable;
};

// Size: 0x18
struct FVector2fCameraParameter {
    /* 0x0000 */ FVector2f Value;
    /* 0x0008 */ FCameraVariableID VariableID;
    /* 0x0010 */ UVector2fCameraVariable* Variable;
};

// Size: 0x50
struct FVector2fCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FVector2fCameraParameter Value;
};

// Size: 0x48
class UVector2fCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector2f DefaultValue;
};

// Size: 0x10
struct FVector2fCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector2fCameraVariable* Variable;
};

// Size: 0x28
struct FVector3dCameraParameter {
    /* 0x0000 */ FVector Value;
    /* 0x0018 */ FCameraVariableID VariableID;
    /* 0x0020 */ UVector3dCameraVariable* Variable;
};

// Size: 0x60
struct FVector3dCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FVector3dCameraParameter Value;
};

// Size: 0x58
class UVector3dCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector3d DefaultValue;
};

// Size: 0x10
struct FVector3dCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector3dCameraVariable* Variable;
};

// Size: 0x18
struct FVector3fCameraParameter {
    /* 0x0000 */ FVector3f Value;
    /* 0x000c */ FCameraVariableID VariableID;
    /* 0x0010 */ UVector3fCameraVariable* Variable;
};

// Size: 0x50
struct FVector3fCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0038 */ FVector3fCameraParameter Value;
};

// Size: 0x50
class UVector3fCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector3f DefaultValue;
};

// Size: 0x10
struct FVector3fCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector3fCameraVariable* Variable;
};

// Size: 0x30
struct FVector4dCameraParameter {
    /* 0x0000 */ FVector4 Value;
    /* 0x0020 */ FCameraVariableID VariableID;
    /* 0x0028 */ UVector4dCameraVariable* Variable;
};

// Size: 0x70
struct FVector4dCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0040 */ FVector4dCameraParameter Value;
};

// Size: 0x60
class UVector4dCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector4d DefaultValue;
};

// Size: 0x10
struct FVector4dCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector4dCameraVariable* Variable;
};

// Size: 0x20
struct FVector4fCameraParameter {
    /* 0x0000 */ FVector4f Value;
    /* 0x0010 */ FCameraVariableID VariableID;
    /* 0x0018 */ UVector4fCameraVariable* Variable;
};

// Size: 0x60
struct FVector4fCameraRigParameterOverride : public FCameraRigParameterOverrideBase {
    /* 0x0040 */ FVector4fCameraParameter Value;
};

// Size: 0x50
class UVector4fCameraVariable : public UCameraVariableAsset {
    /* 0x0040 */ FVector4f DefaultValue;
};

// Size: 0x10
struct FVector4fCameraVariableReference {
    /* 0x0000 */ FCameraVariableID VariableID;
    /* 0x0008 */ UVector4fCameraVariable* Variable;
};

// Size: 0x48
class UViewTargetTransitionParamsBlendCameraNode : public USimpleBlendCameraNode {
    /* 0x0038 */ FViewTargetTransitionParams TransitionParams;
};

// Size: 0x28
class UBlueprintGameplayTagLibrary : public UBlueprintFunctionLibrary {

    static void AddGameplayTag(FGameplayTagContainer& TagContainer, FGameplayTag Tag);
    static void AppendGameplayTagContainers(FGameplayTagContainer& InOutTagContainer, const FGameplayTagContainer& InTagContainer);
    static void BreakGameplayTagContainer(const FGameplayTagContainer& GameplayTagContainer, TArray<FGameplayTag>& GameplayTags);
    static TScriptInterface<IGameplayTagAssetInterface> Conv_ObjectToGameplayTagAssetInterface(UObject* InObject);
    static bool DoesContainerMatchTagQuery(const FGameplayTagContainer& TagContainer, const FGameplayTagQuery& TagQuery);
    static bool DoesTagAssetInterfaceHaveTag(TScriptInterface<IGameplayTagAssetInterface> TagContainerInterface, FGameplayTag Tag);
    static bool EqualEqual_GameplayTag(FGameplayTag A, FGameplayTag B);
    static bool EqualEqual_GameplayTagContainer(const FGameplayTagContainer& A, const FGameplayTagContainer& B);
    static FGameplayTagContainer Filter(const FGameplayTagContainer& TagContainer, const FGameplayTagContainer& OtherContainer, bool bExactMatch);
    static void GetAllActorsOfClassMatchingTagQuery(UObject* WorldContextObject, UClass* ActorClass, const FGameplayTagQuery& GameplayTagQuery, TArray<AActor*>& OutActors);
    static FString GetDebugStringFromGameplayTag(FGameplayTag GameplayTag);
    static FString GetDebugStringFromGameplayTagContainer(const FGameplayTagContainer& TagContainer);
    static int32_t GetNumGameplayTagsInContainer(const FGameplayTagContainer& TagContainer);
    static FGameplayTagContainer GetOwnedGameplayTags(TScriptInterface<IGameplayTagAssetInterface> TagContainerInterface);
    static FName GetTagName(const FGameplayTag& GameplayTag);
    static bool HasAllMatchingGameplayTags(TScriptInterface<IGameplayTagAssetInterface> TagContainerInterface, const FGameplayTagContainer& OtherContainer);
    static bool HasAllTags(const FGameplayTagContainer& TagContainer, const FGameplayTagContainer& OtherContainer, bool bExactMatch);
    static bool HasAnyTags(const FGameplayTagContainer& TagContainer, const FGameplayTagContainer& OtherContainer, bool bExactMatch);
    static bool HasTag(const FGameplayTagContainer& TagContainer, FGameplayTag Tag, bool bExactMatch);
    static bool IsGameplayTagValid(FGameplayTag GameplayTag);
    static bool IsTagQueryEmpty(const FGameplayTagQuery& TagQuery);
    static FGameplayTagContainer MakeGameplayTagContainerFromArray(const TArray<FGameplayTag>& GameplayTags);
    static FGameplayTagContainer MakeGameplayTagContainerFromTag(FGameplayTag SingleTag);
    static FGameplayTagQuery MakeGameplayTagQuery(FGameplayTagQuery TagQuery);
    static FGameplayTagQuery MakeGameplayTagQuery_MatchAllTags(const FGameplayTagContainer& InTags);
    static FGameplayTagQuery MakeGameplayTagQuery_MatchAnyTags(const FGameplayTagContainer& InTags);
    static FGameplayTagQuery MakeGameplayTagQuery_MatchNoTags(const FGameplayTagContainer& InTags);
    static FGameplayTag MakeLiteralGameplayTag(FGameplayTag Value);
    static FGameplayTagContainer MakeLiteralGameplayTagContainer(FGameplayTagContainer Value);
    static bool MatchesAnyTags(FGameplayTag TagOne, const FGameplayTagContainer& OtherContainer, bool bExactMatch);
    static bool MatchesTag(FGameplayTag TagOne, FGameplayTag TagTwo, bool bExactMatch);
    static bool NotEqual_GameplayTag(FGameplayTag A, FGameplayTag B);
    static bool NotEqual_GameplayTagContainer(const FGameplayTagContainer& A, const FGameplayTagContainer& B);
    static bool NotEqual_TagContainerTagContainer(FGameplayTagContainer A, FString B);
    static bool NotEqual_TagTag(FGameplayTag A, FString B);
    static bool RemoveGameplayTag(FGameplayTagContainer& TagContainer, FGameplayTag Tag);
};

enum class EGameplayContainerMatchType {
    Any = 0,
    All = 1,
    EGameplayContainerMatchType_MAX = 2,
};

enum class EGameplayTagQueryExprType {
    Undefined = 0,
    AnyTagsMatch = 1,
    AllTagsMatch = 2,
    NoTagsMatch = 3,
    AnyExprMatch = 4,
    AllExprMatch = 5,
    NoExprMatch = 6,
    EGameplayTagQueryExprType_MAX = 7,
};

enum class EGameplayTagSelectionType {
    None = 0,
    NonRestrictedOnly = 1,
    RestrictedOnly = 2,
    All = 3,
    EGameplayTagSelectionType_MAX = 4,
};

enum class EGameplayTagSourceType {
    Native = 0,
    DefaultTagList = 1,
    TagList = 2,
    RestrictedTagList = 3,
    DataTable = 4,
    Invalid = 5,
    EGameplayTagSourceType_MAX = 6,
};

// Size: 0x98
class UEditableGameplayTagQuery : public UObject {
    /* 0x0028 */ FString UserDescription;
    /* 0x0048 */ UEditableGameplayTagQueryExpression* RootExpression;
    /* 0x0050 */ FGameplayTagQuery TagQueryExportText_Helper;
};

// Size: 0x28
class UEditableGameplayTagQueryExpression : public UObject {
};

// Size: 0x38
class UEditableGameplayTagQueryExpression_AllExprMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ TArray<UEditableGameplayTagQueryExpression*> Expressions;
};

// Size: 0x48
class UEditableGameplayTagQueryExpression_AllTagsMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ FGameplayTagContainer Tags;
};

// Size: 0x38
class UEditableGameplayTagQueryExpression_AnyExprMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ TArray<UEditableGameplayTagQueryExpression*> Expressions;
};

// Size: 0x48
class UEditableGameplayTagQueryExpression_AnyTagsMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ FGameplayTagContainer Tags;
};

// Size: 0x38
class UEditableGameplayTagQueryExpression_NoExprMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ TArray<UEditableGameplayTagQueryExpression*> Expressions;
};

// Size: 0x48
class UEditableGameplayTagQueryExpression_NoTagsMatch : public UEditableGameplayTagQueryExpression {
    /* 0x0028 */ FGameplayTagContainer Tags;
};

// Size: 0x8
struct FGameplayTag {
    /* 0x0000 */ FName TagName;
};

// Size: 0x28
class IGameplayTagAssetInterface : public UInterface {

    FGameplayTagContainer BP_GetOwnedGameplayTags() const;
    bool HasAllMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const;
    bool HasAnyMatchingGameplayTags(const FGameplayTagContainer& TagContainer) const;
    bool HasMatchingGameplayTag(FGameplayTag TagToCheck) const;
};

// Size: 0x20
struct FGameplayTagCategoryRemap {
    /* 0x0000 */ FString BaseCategory;
    /* 0x0010 */ TArray<FString> RemapCategories;
};

// Size: 0x20
struct FGameplayTagContainer {
    /* 0x0000 */ TArray<FGameplayTag> GameplayTags;
    /* 0x0010 */ TArray<FGameplayTag> ParentTags;
};

// Size: 0x10
struct FGameplayTagContainerNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FGameplayTagContainerNetSerializerSerializationHelper {
    /* 0x0000 */ TArray<FGameplayTag> GameplayTags;
};

// Size: 0x1
struct FGameplayTagCreationWidgetHelper {
};

// Size: 0x10
struct FGameplayTagNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x50
struct FGameplayTagNode {
};

// Size: 0x48
struct FGameplayTagQuery {
    /* 0x0000 */ int32_t TokenStreamVersion;
    /* 0x0008 */ TArray<FGameplayTag> TagDictionary;
    /* 0x0018 */ TArray<uint8_t> QueryTokenStream;
    /* 0x0028 */ FString UserDescription;
    /* 0x0038 */ FString AutoDescription;
};

// Size: 0x10
struct FGameplayTagRedirect {
    /* 0x0000 */ FName OldTagName;
    /* 0x0008 */ FName NewTagName;
};

// Size: 0x20
struct FGameplayTagSource {
    /* 0x0000 */ FName SourceName;
    /* 0x0008 */ EGameplayTagSourceType SourceType;
    /* 0x0010 */ UGameplayTagsList* SourceTagList;
    /* 0x0018 */ URestrictedGameplayTagsList* SourceRestrictedTagList;
};

// Size: 0x20
struct FGameplayTagTableRow : public FTableRowBase {
    /* 0x0008 */ FName Tag;
    /* 0x0010 */ FString DevComment;
};

// Size: 0x50
class UGameplayTagsDeveloperSettings : public UDeveloperSettings {
    /* 0x0038 */ FString DeveloperConfigName;
    /* 0x0048 */ FName FavoriteTagSource;
};

// Size: 0x58
class UGameplayTagsList : public UObject {
    /* 0x0028 */ FString ConfigFileName;
    /* 0x0038 */ TArray<FGameplayTagRedirect> GameplayTagRedirects;
    /* 0x0048 */ TArray<FGameplayTagTableRow> GameplayTagList;
};

// Size: 0x2a0
class UGameplayTagsManager : public UObject {
    /* 0x0188 */ TMap<FName, FGameplayTagSource> TagSources;
    /* 0x0290 */ TArray<UDataTable*> GameplayTagTables;
};

// Size: 0xb8
class UGameplayTagsSettings : public UGameplayTagsList {
    /* 0x0058 */ bool ImportTagsFromConfig;
    /* 0x0059 */ bool WarnOnInvalidTags;
    /* 0x005a */ bool ClearInvalidTags;
    /* 0x005b */ bool AllowEditorTagUnloading;
    /* 0x005c */ bool AllowGameTagUnloading;
    /* 0x005d */ bool FastReplication;
    /* 0x005e */ bool bDynamicReplication;
    /* 0x0060 */ FString InvalidTagCharacters;
    /* 0x0070 */ TArray<FGameplayTagCategoryRemap> CategoryRemapping;
    /* 0x0080 */ TArray<FSoftObjectPath> GameplayTagTableList;
    /* 0x0090 */ TArray<FName> CommonlyReplicatedTags;
    /* 0x00a0 */ int32_t NumBitsForContainerSize;
    /* 0x00a4 */ int32_t NetIndexFirstBitSegment;
    /* 0x00a8 */ TArray<FRestrictedConfigInfo> RestrictedConfigFiles;
};

// Size: 0x20
struct FRestrictedConfigInfo {
    /* 0x0000 */ FString RestrictedConfigName;
    /* 0x0010 */ TArray<FString> Owners;
};

// Size: 0x28
struct FRestrictedGameplayTagTableRow : public FGameplayTagTableRow {
    /* 0x0020 */ bool bAllowNonRestrictedChildren;
};

// Size: 0x48
class URestrictedGameplayTagsList : public UObject {
    /* 0x0028 */ FString ConfigFileName;
    /* 0x0038 */ TArray<FRestrictedGameplayTagTableRow> RestrictedGameplayTagList;
};

enum class EGameplayTaskRunResult {
    Error = 0,
    Failed = 1,
    Success_Paused = 2,
    Success_Active = 3,
    Success_Finished = 4,
    EGameplayTaskRunResult_MAX = 5,
};

enum class EGameplayTaskState {
    Uninitialized = 0,
    AwaitingActivation = 1,
    Paused = 2,
    Active = 3,
    Finished = 4,
    EGameplayTaskState_MAX = 5,
};

enum class ETaskResourceOverlapPolicy {
    StartOnTop = 0,
    StartAtEnd = 1,
    RequestCancelAndStartOnTop = 2,
    RequestCancelAndStartAtEnd = 3,
    ETaskResourceOverlapPolicy_MAX = 4,
};

// Size: 0x2
struct FGameplayResourceSet {
};

// Size: 0x68
class UGameplayTask : public UObject {
    /* 0x0030 */ FName InstanceName;
    /* 0x003a */ ETaskResourceOverlapPolicy ResourceOverlapPolicy;
    /* 0x0060 */ UGameplayTask* ChildTask;

    void EndTask();
    void GenericGameplayTaskDelegate__DelegateSignature();
    void ReadyForActivation();
};

// Size: 0x28
class IGameplayTaskOwnerInterface : public UInterface {
};

// Size: 0x38
class UGameplayTaskResource : public UObject {
    /* 0x0028 */ int32_t ManualResourceID;
    /* 0x002c */ int8_t AutoResourceID;
    /* 0x0030 */ bool bManuallySetID;
};

// Size: 0x68
class UGameplayTask_ClaimResource : public UGameplayTask {

    static UGameplayTask_ClaimResource* ClaimResource(TScriptInterface<IGameplayTaskOwnerInterface> InTaskOwner, UClass* ResourceClass, const uint8_t Priority, const FName TaskInstanceName);
    static UGameplayTask_ClaimResource* ClaimResources(TScriptInterface<IGameplayTaskOwnerInterface> InTaskOwner, TArray<UClass*> ResourceClasses, const uint8_t Priority, const FName TaskInstanceName);
};

// Size: 0xc0
class UGameplayTask_SpawnActor : public UGameplayTask {
    /* 0x0068 */ FMulticastInlineDelegate success;
    /* 0x0078 */ FMulticastInlineDelegate DidNotSpawn;
    /* 0x00b8 */ UClass* ClassToSpawn;

    bool BeginSpawningActor(UObject* WorldContextObject, AActor*& SpawnedActor);
    void FinishSpawningActor(UObject* WorldContextObject, AActor* SpawnedActor);
    static UGameplayTask_SpawnActor* SpawnActor(TScriptInterface<IGameplayTaskOwnerInterface> TaskOwner, FVector SpawnLocation, FRotator SpawnRotation, UClass* Class, bool bSpawnOnlyOnAuthority);
};

// Size: 0xa0
class UGameplayTask_TimeLimitedExecution : public UGameplayTask {
    /* 0x0068 */ FMulticastInlineDelegate OnFinished;
    /* 0x0078 */ FMulticastInlineDelegate OnTimeExpired;

    void TaskFinishDelegate__DelegateSignature();
};

// Size: 0x88
class UGameplayTask_WaitDelay : public UGameplayTask {
    /* 0x0068 */ FMulticastInlineDelegate OnFinish;

    void TaskDelayDelegate__DelegateSignature();
    static UGameplayTask_WaitDelay* TaskWaitDelay(TScriptInterface<IGameplayTaskOwnerInterface> TaskOwner, float Time, const uint8_t Priority);
};

// Size: 0x130
class UGameplayTasksComponent : public UActorComponent {
    /* 0x00d0 */ TArray<UGameplayTask*> TaskPriorityQueue;
    /* 0x00f0 */ TArray<UGameplayTask*> TickingTasks;
    /* 0x0100 */ TArray<UGameplayTask*> KnownTasks;
    /* 0x0110 */ FMulticastInlineDelegate OnClaimedResourcesChange;
    /* 0x0120 */ TArray<UGameplayTask*> SimulatedTasks;

    static EGameplayTaskRunResult K2_RunGameplayTask(TScriptInterface<IGameplayTaskOwnerInterface> TaskOwner, UGameplayTask* Task, uint8_t Priority, TArray<UClass*> AdditionalRequiredResources, TArray<UClass*> AdditionalClaimedResources);
    void OnRep_SimulatedTasks(const TArray<UGameplayTask*>& PreviousSimulatedTasks);
};

// Size: 0x98
class UGeometryCache : public UObject {
    /* 0x0030 */ TArray<UMaterialInterface*> Materials;
    /* 0x0040 */ TArray<FName> MaterialSlotNames;
    /* 0x0050 */ TArray<UGeometryCacheTrack*> Tracks;
    /* 0x0060 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0088 */ int32_t StartFrame;
    /* 0x008c */ int32_t EndFrame;
    /* 0x0090 */ uint64_t Hash;
};

// Size: 0x2b0
class AGeometryCacheActor : public AActor {
    /* 0x02a8 */ UGeometryCacheComponent* GeometryCacheComponent;

    UGeometryCacheComponent* GetGeometryCacheComponent() const;
};

// Size: 0x38
class UGeometryCacheCodecBase : public UObject {
    /* 0x0028 */ TArray<int32_t> TopologyRanges;
};

// Size: 0x40
class UGeometryCacheCodecRaw : public UGeometryCacheCodecBase {
    /* 0x0038 */ int32_t DummyProperty;
};

// Size: 0x40
class UGeometryCacheCodecV1 : public UGeometryCacheCodecBase {
};

// Size: 0x5f0
class UGeometryCacheComponent : public UMeshComponent {
    /* 0x0568 */ UGeometryCache* GeometryCache;
    /* 0x0570 */ bool bRunning;
    /* 0x0571 */ bool bLooping;
    /* 0x0572 */ bool bExtrapolateFrames;
    /* 0x0574 */ float StartTimeOffset;
    /* 0x0578 */ float PlaybackSpeed;
    /* 0x057c */ float MotionVectorScale;
    /* 0x0580 */ int32_t NumTracks;
    /* 0x0584 */ float ElapsedTime;
    /* 0x05d4 */ float Duration;
    /* 0x05d8 */ bool bManualTick;
    /* 0x05d9 */ bool bOverrideWireframeColor;
    /* 0x05dc */ FLinearColor WireframeOverrideColor;

    float GetAnimationTime() const;
    float GetDuration() const;
    float GetElapsedTime() const;
    float GetMotionVectorScale() const;
    int32_t GetNumberOfFrames() const;
    int32_t GetNumberOfTracks() const;
    bool GetOverrideWireframeColor() const;
    float GetPlaybackDirection() const;
    float GetPlaybackSpeed() const;
    float GetStartTimeOffset() const;
    FLinearColor GetWireframeOverrideColor() const;
    bool IsExtrapolatingFrames() const;
    bool IsLooping() const;
    bool IsPlaying() const;
    bool IsPlayingReversed() const;
    void Pause();
    void Play();
    void PlayFromStart();
    void PlayReversed();
    void PlayReversedFromEnd();
    void SetExtrapolateFrames(const bool bNewExtrapolating);
    bool SetGeometryCache(UGeometryCache* NewGeomCache);
    void SetLooping(const bool bNewLooping);
    void SetMotionVectorScale(const float NewMotionVectorScale);
    void SetOverrideWireframeColor(bool bOverride);
    void SetPlaybackSpeed(const float NewPlaybackSpeed);
    void SetStartTimeOffset(const float NewStartTimeOffset);
    void SetWireframeOverrideColor(const FLinearColor Color);
    void Stop();
    void TickAtThisTime(const float Time, bool bInIsRunning, bool bInBackwards, bool bInIsLooping);
};

// Size: 0xc
struct FGeometryCacheMeshBatchInfo {
};

// Size: 0xd8
struct FGeometryCacheMeshData {
};

// Size: 0x58
class UGeometryCacheTrack : public UObject {
    /* 0x0028 */ float Duration;
};

// Size: 0xd0
class UGeometryCacheTrackStreamable : public UGeometryCacheTrack {
    /* 0x0058 */ UGeometryCacheCodecBase* Codec;
    /* 0x00c0 */ float StartSampleTime;
};

// Size: 0x80
class UGeometryCacheTrack_FlipbookAnimation : public UGeometryCacheTrack {
    /* 0x0058 */ uint32_t NumMeshSamples;

    void AddMeshSample(const FGeometryCacheMeshData& MeshData, const float SampleTime);
};

// Size: 0x130
class UGeometryCacheTrack_TransformAnimation : public UGeometryCacheTrack {

    void SetMesh(const FGeometryCacheMeshData& NewMeshData);
};

// Size: 0x130
class UGeometryCacheTrack_TransformGroupAnimation : public UGeometryCacheTrack {

    void SetMesh(const FGeometryCacheMeshData& NewMeshData);
};

// Size: 0x9
struct FGeometryCacheVertexInfo {
};

// Size: 0x10
struct FNiagaraGeometryCacheMICOverride {
    /* 0x0000 */ UMaterialInterface* OriginalMaterial;
    /* 0x0008 */ UMaterialInstanceConstant* ReplacementMaterial;
};

// Size: 0x48
struct FNiagaraGeometryCacheReference {
    /* 0x0000 */ UGeometryCache* GeometryCache;
    /* 0x0008 */ FNiagaraUserParameterBinding GeometryCacheUserParamBinding;
    /* 0x0028 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x0038 */ TArray<FNiagaraGeometryCacheMICOverride> MICOverrideMaterials;
};

// Size: 0x2e0
class UNiagaraGeometryCacheRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ TArray<FNiagaraGeometryCacheReference> GeometryCaches;
    /* 0x00c8 */ ENiagaraRendererSourceDataMode SourceMode;
    /* 0x00c9 */ bool bIsLooping;
    /* 0x00cc */ uint32_t ComponentCountLimit;
    /* 0x00d0 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x0108 */ FNiagaraVariableAttributeBinding RotationBinding;
    /* 0x0140 */ FNiagaraVariableAttributeBinding ScaleBinding;
    /* 0x0178 */ FNiagaraVariableAttributeBinding ElapsedTimeBinding;
    /* 0x01b0 */ FNiagaraVariableAttributeBinding EnabledBinding;
    /* 0x01e8 */ FNiagaraVariableAttributeBinding ArrayIndexBinding;
    /* 0x0220 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x0258 */ int32_t RendererVisibility;
    /* 0x025c */ bool bAssignComponentsOnParticleID;
    /* 0x0260 */ FNiagaraRendererMaterialParameters MaterialParameters;
};

// Size: 0xc0
struct FTrackRenderData {
};

// Size: 0x48
struct FMovieSceneGeometryCacheParams {
    /* 0x0000 */ UGeometryCache* GeometryCacheAsset;
    /* 0x0008 */ FFrameNumber FirstLoopStartFrameOffset;
    /* 0x000c */ FFrameNumber StartFrameOffset;
    /* 0x0010 */ FFrameNumber EndFrameOffset;
    /* 0x0014 */ float PlayRate;
    /* 0x0018 */ bool bReverse;
    /* 0x001c */ float StartOffset;
    /* 0x0020 */ float EndOffset;
    /* 0x0028 */ FSoftObjectPath GeometryCache;
};

// Size: 0x150
class UMovieSceneGeometryCacheSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneGeometryCacheParams Params;
};

// Size: 0x70
struct FMovieSceneGeometryCacheSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneGeometryCacheSectionTemplateParameters Params;
};

// Size: 0x50
struct FMovieSceneGeometryCacheSectionTemplateParameters : public FMovieSceneGeometryCacheParams {
    /* 0x0048 */ FFrameNumber SectionStartTime;
    /* 0x004c */ FFrameNumber SectionEndTime;
};

// Size: 0x128
class UMovieSceneGeometryCacheTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> AnimationSections;
};

// Size: 0x38
struct FChaosBreakingEventData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Velocity;
    /* 0x0030 */ float Mass;
};

// Size: 0x18
struct FChaosBreakingEventRequestSettings {
    /* 0x0000 */ int32_t MaxNumberOfResults;
    /* 0x0004 */ float MinRadius;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinMass;
    /* 0x0010 */ float MaxDistance;
    /* 0x0014 */ EChaosBreakingSortMethod SortMethod;
};

// Size: 0x80
struct FChaosCollisionEventData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Normal;
    /* 0x0030 */ FVector Velocity1;
    /* 0x0048 */ FVector Velocity2;
    /* 0x0060 */ float Mass1;
    /* 0x0064 */ float Mass2;
    /* 0x0068 */ FVector Impulse;
};

// Size: 0x18
struct FChaosCollisionEventRequestSettings {
    /* 0x0000 */ int32_t MaxNumberResults;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinImpulse;
    /* 0x0010 */ float MaxDistance;
    /* 0x0014 */ EChaosCollisionSortMethod SortMethod;
};

// Size: 0x4f0
class UChaosDestructionListener : public USceneComponent {
    /* 0x0240 */ bool bIsCollisionEventListeningEnabled;
    /* 0x0240 */ bool bIsBreakingEventListeningEnabled;
    /* 0x0240 */ bool bIsTrailingEventListeningEnabled;
    /* 0x0240 */ bool bIsRemovalEventListeningEnabled;
    /* 0x0244 */ FChaosCollisionEventRequestSettings CollisionEventRequestSettings;
    /* 0x025c */ FChaosBreakingEventRequestSettings BreakingEventRequestSettings;
    /* 0x0274 */ FChaosTrailingEventRequestSettings TrailingEventRequestSettings;
    /* 0x028c */ FChaosRemovalEventRequestSettings RemovalEventRequestSettings;
    /* 0x02a0 */ TSet<AChaosSolverActor*> ChaosSolverActors;
    /* 0x02f0 */ TSet<AGeometryCollectionActor*> GeometryCollectionActors;
    /* 0x0340 */ FMulticastInlineDelegate OnCollisionEvents;
    /* 0x0350 */ FMulticastInlineDelegate OnBreakingEvents;
    /* 0x0360 */ FMulticastInlineDelegate OnTrailingEvents;
    /* 0x0370 */ FMulticastInlineDelegate OnRemovalEvents;

    void AddChaosSolverActor(AChaosSolverActor* ChaosSolverActor);
    void AddGeometryCollectionActor(AGeometryCollectionActor* GeometryCollectionActor);
    bool IsEventListening() const;
    void RemoveChaosSolverActor(AChaosSolverActor* ChaosSolverActor);
    void RemoveGeometryCollectionActor(AGeometryCollectionActor* GeometryCollectionActor);
    void SetBreakingEventEnabled(bool bIsEnabled);
    void SetBreakingEventRequestSettings(const FChaosBreakingEventRequestSettings& InSettings);
    void SetCollisionEventEnabled(bool bIsEnabled);
    void SetCollisionEventRequestSettings(const FChaosCollisionEventRequestSettings& InSettings);
    void SetRemovalEventEnabled(bool bIsEnabled);
    void SetRemovalEventRequestSettings(const FChaosRemovalEventRequestSettings& InSettings);
    void SetTrailingEventEnabled(bool bIsEnabled);
    void SetTrailingEventRequestSettings(const FChaosTrailingEventRequestSettings& InSettings);
    void SortBreakingEvents(TArray<FChaosBreakingEventData>& BreakingEvents, EChaosBreakingSortMethod SortMethod);
    void SortCollisionEvents(TArray<FChaosCollisionEventData>& CollisionEvents, EChaosCollisionSortMethod SortMethod);
    void SortRemovalEvents(TArray<FChaosRemovalEventData>& RemovalEvents, EChaosRemovalSortMethod SortMethod);
    void SortTrailingEvents(TArray<FChaosTrailingEventData>& TrailingEvents, EChaosTrailingSortMethod SortMethod);
};

// Size: 0x20
struct FChaosRemovalEventData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ float Mass;
    /* 0x001c */ int32_t ParticleIndex;
};

// Size: 0x10
struct FChaosRemovalEventRequestSettings {
    /* 0x0000 */ int32_t MaxNumberOfResults;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MaxDistance;
    /* 0x000c */ EChaosRemovalSortMethod SortMethod;
};

// Size: 0x50
struct FChaosTrailingEventData {
    /* 0x0000 */ FVector Location;
    /* 0x0018 */ FVector Velocity;
    /* 0x0030 */ FVector AngularVelocity;
    /* 0x0048 */ float Mass;
    /* 0x004c */ int32_t ParticleIndex;
};

// Size: 0x18
struct FChaosTrailingEventRequestSettings {
    /* 0x0000 */ int32_t MaxNumberOfResults;
    /* 0x0004 */ float MinMass;
    /* 0x0008 */ float MinSpeed;
    /* 0x000c */ float MinAngularSpeed;
    /* 0x0010 */ float MaxDistance;
    /* 0x0014 */ EChaosTrailingSortMethod SortMethod;
};

enum class EChaosBreakingSortMethod {
    SortNone = 0,
    SortByHighestMass = 1,
    SortByHighestSpeed = 2,
    SortByNearestFirst = 3,
    Count = 4,
    EChaosBreakingSortMethod_MAX = 5,
};

enum class EChaosCollisionSortMethod {
    SortNone = 0,
    SortByHighestMass = 1,
    SortByHighestSpeed = 2,
    SortByHighestImpulse = 3,
    SortByNearestFirst = 4,
    Count = 5,
    EChaosCollisionSortMethod_MAX = 6,
};

enum class EChaosRemovalSortMethod {
    SortNone = 0,
    SortByHighestMass = 1,
    SortByNearestFirst = 2,
    Count = 3,
    EChaosRemovalSortMethod_MAX = 4,
};

enum class EChaosTrailingSortMethod {
    SortNone = 0,
    SortByHighestMass = 1,
    SortByHighestSpeed = 2,
    SortByNearestFirst = 3,
    Count = 4,
    EChaosTrailingSortMethod_MAX = 5,
};

enum class ECollectionAttributeEnum {
    Chaos_Active = 0,
    Chaos_DynamicState = 1,
    Chaos_CollisionGroup = 2,
    Chaos_Max = 3,
};

enum class ECollectionGroupEnum {
    Chaos_Traansform = 0,
    Chaos_Max = 1,
};

enum class EGeometryCollectionDebugDrawActorHideGeometry {
    HideNone = 0,
    HideWithCollision = 1,
    HideSelected = 2,
    HideWholeCollection = 3,
    HideAll = 4,
    EGeometryCollectionDebugDrawActorHideGeometry_MAX = 5,
};

// Size: 0x50
struct FGeomComponentCacheParameters {
    /* 0x0000 */ EGeometryCollectionCacheType CacheMode;
    /* 0x0008 */ UGeometryCollectionCache* TargetCache;
    /* 0x0010 */ float ReverseCacheBeginTime;
    /* 0x0014 */ bool SaveCollisionData;
    /* 0x0015 */ bool DoGenerateCollisionData;
    /* 0x0018 */ int32_t CollisionDataSizeMax;
    /* 0x001c */ bool DoCollisionDataSpatialHash;
    /* 0x0020 */ float CollisionDataSpatialHashRadius;
    /* 0x0024 */ int32_t MaxCollisionPerCell;
    /* 0x0028 */ bool SaveBreakingData;
    /* 0x0029 */ bool DoGenerateBreakingData;
    /* 0x002c */ int32_t BreakingDataSizeMax;
    /* 0x0030 */ bool DoBreakingDataSpatialHash;
    /* 0x0034 */ float BreakingDataSpatialHashRadius;
    /* 0x0038 */ int32_t MaxBreakingPerCell;
    /* 0x003c */ bool SaveTrailingData;
    /* 0x003d */ bool DoGenerateTrailingData;
    /* 0x0040 */ int32_t TrailingDataSizeMax;
    /* 0x0044 */ float TrailingMinSpeedThreshold;
    /* 0x0048 */ float TrailingMinVolumeThreshold;
};

// Size: 0x280
class UGeometryCollection : public UObject {
    /* 0x0060 */ bool EnableClustering;
    /* 0x0064 */ int32_t ClusterGroupIndex;
    /* 0x0068 */ int32_t MaxClusterLevel;
    /* 0x006c */ EDamageModelTypeEnum DamageModel;
    /* 0x0070 */ TArray<float> DamageThreshold;
    /* 0x0080 */ bool bUseSizeSpecificDamageThreshold;
    /* 0x0081 */ bool bUseMaterialDamageModifiers;
    /* 0x0082 */ bool PerClusterOnlyDamageThreshold;
    /* 0x0084 */ FGeometryCollectionDamagePropagationData DamagePropagationData;
    /* 0x0090 */ EClusterConnectionTypeEnum ClusterConnectionType;
    /* 0x0094 */ float ConnectionGraphBoundsFilteringMargin;
    /* 0x0098 */ TArray<UMaterialInterface*> Materials;
    /* 0x00a8 */ TArray<FGeometryCollectionEmbeddedExemplar> EmbeddedGeometryExemplar;
    /* 0x00b8 */ bool bUseFullPrecisionUVs;
    /* 0x00b9 */ bool bStripOnCook;
    /* 0x00ba */ bool bStripRenderDataOnCook;
    /* 0x00c0 */ UClass* CustomRendererType;
    /* 0x00c8 */ FGeometryCollectionProxyMeshData RootProxyData;
    /* 0x00e8 */ TArray<FGeometryCollectionAutoInstanceMesh> AutoInstanceMeshes;
    /* 0x00f8 */ bool EnableNanite;
    /* 0x00f9 */ bool bEnableNaniteFallback;
    /* 0x00fa */ bool bConvertVertexColorsToSRGB;
    /* 0x0100 */ UPhysicalMaterial* PhysicsMaterial;
    /* 0x0108 */ bool bDensityFromPhysicsMaterial;
    /* 0x010c */ float CachedDensityFromPhysicsMaterialInGCm3;
    /* 0x0110 */ bool bMassAsDensity;
    /* 0x0114 */ float Mass;
    /* 0x0118 */ float MinimumMassClamp;
    /* 0x011c */ bool bImportCollisionFromSource;
    /* 0x011d */ bool bOptimizeConvexes;
    /* 0x011e */ bool bScaleOnRemoval;
    /* 0x011f */ bool bRemoveOnMaxSleep;
    /* 0x0120 */ bool bAutomaticCrumblePartialClusters;
    /* 0x0128 */ FVector2D MaximumSleepTime;
    /* 0x0138 */ FVector2D RemovalDuration;
    /* 0x0148 */ bool bSlowMovingAsSleeping;
    /* 0x014c */ float SlowMovingVelocityThreshold;
    /* 0x0150 */ TArray<FGeometryCollectionSizeSpecificData> SizeSpecificData;
    /* 0x0160 */ bool EnableRemovePiecesOnFracture;
    /* 0x0168 */ TArray<UMaterialInterface*> RemoveOnFractureMaterials;
    /* 0x0178 */ TMap<FString, FString> Overrides;
    /* 0x01c8 */ FDataflowInstance DataflowInstance;
    /* 0x0208 */ FGuid PersistentGuid;
    /* 0x0218 */ FGuid StateGuid;
    /* 0x0228 */ int32_t RootIndex;
    /* 0x0230 */ TArray<int32_t> BreadthFirstTransformIndices;
    /* 0x0240 */ TArray<int32_t> AutoInstanceTransformRemapIndices;
    /* 0x0250 */ int32_t BoneSelectedMaterialIndex;
    /* 0x0268 */ TArray<UAssetUserData*> AssetUserData;

    UDataflow* GetDataflowAsset() const;
    void SetConvertVertexColorsToSRGB(bool bValue);
    void SetDataflowAsset(UDataflow* InDataflowAsset);
    void SetEnableNanite(bool bValue);
};

// Size: 0x2b8
class AGeometryCollectionActor : public AActor {
    /* 0x02a8 */ UGeometryCollectionComponent* GeometryCollectionComponent;
    /* 0x02b0 */ UGeometryCollectionDebugDrawComponent* GeometryCollectionDebugDrawComponent;

    bool RaycastSingle(FVector Start, FVector End, FHitResult& OutHit) const;
};

// Size: 0x30
struct FGeometryCollectionAutoInstanceMesh {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ TArray<UMaterialInterface*> Materials;
    /* 0x0018 */ int32_t NumInstances;
    /* 0x0020 */ TArray<float> CustomData;
};

// Size: 0x28
class UGeometryCollectionBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void SetCustomInstanceDataByIndex(UGeometryCollectionComponent* GeometryCollectionComponent, int32_t CustomDataIndex, float CustomDataValue);
    static void SetCustomInstanceDataByName(UGeometryCollectionComponent* GeometryCollectionComponent, FName CustomDataName, float CustomDataValue);
    static void SetISMPoolCustomInstanceData(UGeometryCollectionComponent* GeometryCollectionComponent, int32_t CustomDataIndex, float CustomDataValue);
};

// Size: 0x50
class UGeometryCollectionCache : public UObject {
    /* 0x0028 */ FRecordedTransformTrack RecordedData;
    /* 0x0038 */ UGeometryCollection* SupportedCollection;
    /* 0x0040 */ FGuid CompatibleCollectionState;
};

// Size: 0x8
struct FGeometryCollectionCollisionParticleData {
    /* 0x0000 */ float CollisionParticlesFraction;
    /* 0x0004 */ int32_t MaximumCollisionParticles;
};

// Size: 0x24
struct FGeometryCollectionCollisionTypeData {
    /* 0x0000 */ ECollisionTypeEnum CollisionType;
    /* 0x0001 */ EImplicitTypeEnum ImplicitType;
    /* 0x0004 */ FGeometryCollectionLevelSetData LevelSet;
    /* 0x0014 */ FGeometryCollectionCollisionParticleData CollisionParticles;
    /* 0x001c */ float CollisionObjectReductionPercentage;
    /* 0x0020 */ float CollisionMarginFraction;
};

// Size: 0xa10
class UGeometryCollectionComponent : public UMeshComponent {
    /* 0x0570 */ AChaosSolverActor* ChaosSolverActor;
    /* 0x0578 */ UGeometryCollection* RestCollection;
    /* 0x0580 */ TArray<AFieldSystemActor*> InitializationFields;
    /* 0x0590 */ bool Simulating;
    /* 0x0592 */ EObjectStateTypeEnum ObjectType;
    /* 0x0594 */ int32_t GravityGroupIndex;
    /* 0x0598 */ int32_t OneWayInteractionLevel;
    /* 0x059c */ bool bDensityFromPhysicsMaterial;
    /* 0x059d */ bool bForceMotionBlur;
    /* 0x059e */ bool EnableClustering;
    /* 0x05a0 */ int32_t ClusterGroupIndex;
    /* 0x05a4 */ int32_t MaxClusterLevel;
    /* 0x05a8 */ int32_t MaxSimulatedLevel;
    /* 0x05ac */ EDamageModelTypeEnum DamageModel;
    /* 0x05b0 */ TArray<float> DamageThreshold;
    /* 0x05c0 */ bool bUseSizeSpecificDamageThreshold;
    /* 0x05c1 */ bool bUseMaterialDamageModifiers;
    /* 0x05c4 */ FGeometryCollectionDamagePropagationData DamagePropagationData;
    /* 0x05d0 */ bool bEnableDamageFromCollision;
    /* 0x05d1 */ bool bAllowRemovalOnSleep;
    /* 0x05d2 */ bool bAllowRemovalOnBreak;
    /* 0x05d3 */ bool bForceUpdateActiveTransforms;
    /* 0x05d4 */ EClusterConnectionTypeEnum ClusterConnectionType;
    /* 0x05d8 */ int32_t CollisionGroup;
    /* 0x05dc */ float CollisionSampleFraction;
    /* 0x05e0 */ float LinearEtherDrag;
    /* 0x05e8 */ UChaosPhysicalMaterial* PhysicalMaterial;
    /* 0x05f0 */ EInitialVelocityTypeEnum InitialVelocityType;
    /* 0x05f8 */ FVector InitialLinearVelocity;
    /* 0x0610 */ FVector InitialAngularVelocity;
    /* 0x0628 */ UPhysicalMaterial* PhysicalMaterialOverride;
    /* 0x0630 */ FGeomComponentCacheParameters CacheParameters;
    /* 0x0680 */ TArray<FTransform> RestTransforms;
    /* 0x0690 */ FMulticastInlineDelegate NotifyGeometryCollectionPhysicsStateChange;
    /* 0x06a0 */ FMulticastInlineDelegate NotifyGeometryCollectionPhysicsLoadingStateChange;
    /* 0x06c8 */ FMulticastInlineDelegate OnChaosBreakEvent;
    /* 0x06d8 */ FMulticastInlineDelegate OnChaosRemovalEvent;
    /* 0x06e8 */ FMulticastInlineDelegate OnChaosCrumblingEvent;
    /* 0x0740 */ float DesiredCacheTime;
    /* 0x0744 */ bool CachePlayback;
    /* 0x0748 */ FMulticastInlineDelegate OnChaosPhysicsCollision;
    /* 0x0758 */ bool bNotifyBreaks;
    /* 0x0759 */ bool bNotifyCollisions;
    /* 0x075a */ bool bNotifyTrailing;
    /* 0x075b */ bool bNotifyRemovals;
    /* 0x075c */ bool bNotifyCrumblings;
    /* 0x075d */ bool bCrumblingEventIncludesChildren;
    /* 0x075e */ bool bNotifyGlobalBreaks;
    /* 0x075f */ bool bNotifyGlobalCollisions;
    /* 0x0760 */ bool bNotifyGlobalRemovals;
    /* 0x0761 */ bool bNotifyGlobalCrumblings;
    /* 0x0762 */ bool bGlobalCrumblingEventIncludesChildren;
    /* 0x0763 */ bool bStoreVelocities;
    /* 0x0764 */ bool bIsCurrentlyNavigationRelevant;
    /* 0x0765 */ bool bShowBoneColors;
    /* 0x0766 */ bool bUpdateComponentTransformToRootBone;
    /* 0x0767 */ bool bUseRootProxyForNavigation;
    /* 0x0768 */ bool bUpdateNavigationInTick;
    /* 0x076a */ bool bEnableReplication;
    /* 0x076b */ bool bEnableAbandonAfterLevel;
    /* 0x076c */ FName AbandonedCollisionProfileName;
    /* 0x0778 */ AISMPoolActor* ISMPool;
    /* 0x0780 */ UClass* CustomRendererType;
    /* 0x0788 */ bool bOverrideCustomRenderer;
    /* 0x0789 */ bool bAutoAssignISMPool;
    /* 0x078b */ bool bUseStaticMeshCollisionForTraces;
    /* 0x078c */ int32_t ReplicationAbandonClusterLevel;
    /* 0x0790 */ TScriptInterface<IGeometryCollectionExternalRenderInterface> CustomRenderer;
    /* 0x07a0 */ TArray<FName> CollisionProfilePerLevel;
    /* 0x07c0 */ int32_t ReplicationAbandonAfterLevel;
    /* 0x07c4 */ int32_t ReplicationMaxPositionAndVelocityCorrectionLevel;
    /* 0x07c8 */ FGeometryCollectionRepData RepData;
    /* 0x0800 */ FGeometryCollectionRepStateData RepStateData;
    /* 0x0840 */ FGeometryCollectionRepDynamicData RepDynamicData;
    /* 0x0970 */ UBodySetup* DummyBodySetup;
    /* 0x0978 */ UChaosGameplayEventDispatcher* EventDispatcher;
    /* 0x0980 */ TArray<UInstancedStaticMeshComponent*> EmbeddedGeometryComponents;
    /* 0x09a4 */ float AngularEtherDrag;

    void ApplyAngularVelocity(int32_t ItemIndex, const FVector& AngularVelocity);
    void ApplyAssetDefaults();
    void ApplyBreakingAngularVelocity(int32_t ItemIndex, const FVector& AngularVelocity);
    void ApplyBreakingLinearVelocity(int32_t ItemIndex, const FVector& LinearVelocity);
    void ApplyExternalStrain(int32_t ItemIndex, const FVector& Location, float Radius, int32_t PropagationDepth, float PropagationFactor, float Strain);
    void ApplyInternalStrain(int32_t ItemIndex, const FVector& Location, float Radius, int32_t PropagationDepth, float PropagationFactor, float Strain);
    void ApplyKinematicField(float Radius, FVector position);
    void ApplyLinearVelocity(int32_t ItemIndex, const FVector& LinearVelocity);
    void ApplyPhysicsField(bool Enabled, EGeometryCollectionPhysicsTypeEnum Target, UFieldSystemMetaData* MetaData, UFieldNodeBase* Field);
    void CrumbleActiveClusters();
    void CrumbleCluster(int32_t ItemIndex);
    void EnableRootProxyForCustomRenderer(bool bEnable);
    void ForceBrokenForCustomRenderer(bool bForceBroken);
    TArray<float> GetDamageThreshold() const;
    FString GetDebugInfo();
    int32_t GetInitialLevel(int32_t ItemIndex);
    TArray<FTransform> GetInitialLocalRestTransforms() const;
    FBox GetLocalBounds() const;
    TArray<FTransform> GetLocalRestTransforms(bool bInitialTransforms) const;
    void GetMassAndExtents(int32_t ItemIndex, float& OutMass, FBox& OutExtents);
    FTransform GetRootCurrentTransform() const;
    int32_t GetRootIndex() const;
    FTransform GetRootInitialTransform() const;
    AChaosSolverActor* GetSolverActor() const;
    bool GetUseStaticMeshCollisionForTraces() const;
    bool IsRootBroken() const;
    void NotifyGeometryCollectionPhysicsLoadingStateChange__DelegateSignature(UGeometryCollectionComponent* FracturedComponent);
    void NotifyGeometryCollectionPhysicsStateChange__DelegateSignature(UGeometryCollectionComponent* FracturedComponent);
    void OnRep_RepData();
    void OnRep_RepDynamicData();
    void OnRep_RepStateData();
    void ReceivePhysicsCollision(const FChaosPhysicsCollisionInfo& CollisionInfo);
    void RemoveAllAnchors();
    void SetAbandonedParticleCollisionProfileName(FName CollisionProfile);
    void SetAnchoredByBox(FBox WorldSpaceBox, bool bAnchored, int32_t MaxLevel);
    void SetAnchoredByIndex(int32_t Index, bool bAnchored);
    void SetAnchoredByTransformedBox(FBox Box, FTransform Transform, bool bAnchored, int32_t MaxLevel);
    void SetDamageModel(EDamageModelTypeEnum InDamageModel);
    void SetDamagePropagationData(const FGeometryCollectionDamagePropagationData& InDamagePropagationData);
    void SetDamageThreshold(const TArray<float>& InDamageThreshold);
    void SetDensityFromPhysicsMaterial(bool bInDensityFromPhysicsMaterial);
    void SetEnableDamageFromCollision(bool bValue);
    void SetGravityGroupIndex(int32_t InGravityGroupIndex);
    void SetLocalRestTransforms(const TArray<FTransform>& Transforms, bool bOnlyLeaves);
    void SetNotifyBreaks(bool bNewNotifyBreaks);
    void SetNotifyCrumblings(bool bNewNotifyCrumblings, bool bNewCrumblingEventIncludesChildren);
    void SetNotifyGlobalBreaks(bool bNewNotifyGlobalBreaks);
    void SetNotifyGlobalCollision(bool bNewNotifyGlobalCollisions);
    void SetNotifyGlobalCrumblings(bool bNewNotifyGlobalCrumblings, bool bGlobalNewCrumblingEventIncludesChildren);
    void SetNotifyGlobalRemovals(bool bNewNotifyGlobalRemovals);
    void SetNotifyRemovals(bool bNewNotifyRemovals);
    void SetOneWayInteractionLevel(int32_t InOneWayInteractionLevel);
    void SetPerLevelCollisionProfileNames(const TArray<FName>& ProfileNames);
    void SetPerParticleCollisionProfileName(const TArray<int32_t>& BoneIds, FName ProfileName);
    void SetRestCollection(const UGeometryCollection* RestCollectionIn, bool bApplyAssetDefaults);
    void SetRootProxyComponentSpaceTransform(int32_t Index, const FTransform& RootProxyTransform);
    void SetSolverActor(AChaosSolverActor* InSolverActor);
    void SetUseMaterialDamageModifiers(bool bInUseMaterialDamageModifiers);
    void SetUseStaticMeshCollisionForTraces(bool bInUseStaticMeshCollisionForTraces);
};

// Size: 0x28
class IGeometryCollectionCustomDataInterface : public UInterface {
};

// Size: 0xc
struct FGeometryCollectionDamagePropagationData {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float BreakDamagePropagationFactor;
    /* 0x0008 */ float ShockDamagePropagationFactor;
};

// Size: 0x368
class AGeometryCollectionDebugDrawActor : public AActor {
    /* 0x02a8 */ FGeometryCollectionDebugDrawWarningMessage WarningMessage;
    /* 0x02b0 */ FGeometryCollectionDebugDrawActorSelectedRigidBody SelectedRigidBody;
    /* 0x02c8 */ bool bDebugDrawWholeCollection;
    /* 0x02c9 */ bool bDebugDrawHierarchy;
    /* 0x02ca */ bool bDebugDrawClustering;
    /* 0x02cb */ EGeometryCollectionDebugDrawActorHideGeometry HideGeometry;
    /* 0x02cc */ bool bShowRigidBodyId;
    /* 0x02cd */ bool bShowRigidBodyCollision;
    /* 0x02ce */ bool bCollisionAtOrigin;
    /* 0x02cf */ bool bShowRigidBodyTransform;
    /* 0x02d0 */ bool bShowRigidBodyInertia;
    /* 0x02d1 */ bool bShowRigidBodyVelocity;
    /* 0x02d2 */ bool bShowRigidBodyForce;
    /* 0x02d3 */ bool bShowRigidBodyInfos;
    /* 0x02d4 */ bool bShowTransformIndex;
    /* 0x02d5 */ bool bShowTransform;
    /* 0x02d6 */ bool bShowParent;
    /* 0x02d7 */ bool bShowLevel;
    /* 0x02d8 */ bool bShowConnectivityEdges;
    /* 0x02d9 */ bool bShowGeometryIndex;
    /* 0x02da */ bool bShowGeometryTransform;
    /* 0x02db */ bool bShowBoundingBox;
    /* 0x02dc */ bool bShowFaces;
    /* 0x02dd */ bool bShowFaceIndices;
    /* 0x02de */ bool bShowFaceNormals;
    /* 0x02df */ bool bShowSingleFace;
    /* 0x02e0 */ int32_t SingleFaceIndex;
    /* 0x02e4 */ bool bShowVertices;
    /* 0x02e5 */ bool bShowVertexIndices;
    /* 0x02e6 */ bool bShowVertexNormals;
    /* 0x02e7 */ bool bUseActiveVisualization;
    /* 0x02e8 */ float PointThickness;
    /* 0x02ec */ float LineThickness;
    /* 0x02f0 */ bool bTextShadow;
    /* 0x02f4 */ float TextScale;
    /* 0x02f8 */ float NormalScale;
    /* 0x02fc */ float AxisScale;
    /* 0x0300 */ float ArrowScale;
    /* 0x0304 */ FColor RigidBodyIdColor;
    /* 0x0308 */ float RigidBodyTransformScale;
    /* 0x030c */ FColor RigidBodyCollisionColor;
    /* 0x0310 */ FColor RigidBodyInertiaColor;
    /* 0x0314 */ FColor RigidBodyVelocityColor;
    /* 0x0318 */ FColor RigidBodyForceColor;
    /* 0x031c */ FColor RigidBodyInfoColor;
    /* 0x0320 */ FColor TransformIndexColor;
    /* 0x0324 */ float TransformScale;
    /* 0x0328 */ FColor LevelColor;
    /* 0x032c */ FColor ParentColor;
    /* 0x0330 */ float ConnectivityEdgeThickness;
    /* 0x0334 */ FColor GeometryIndexColor;
    /* 0x0338 */ float GeometryTransformScale;
    /* 0x033c */ FColor BoundingBoxColor;
    /* 0x0340 */ FColor FaceColor;
    /* 0x0344 */ FColor FaceIndexColor;
    /* 0x0348 */ FColor FaceNormalColor;
    /* 0x034c */ FColor SingleFaceColor;
    /* 0x0350 */ FColor VertexColor;
    /* 0x0354 */ FColor VertexIndexColor;
    /* 0x0358 */ FColor VertexNormalColor;
    /* 0x0360 */ UBillboardComponent* SpriteComponent;
};

// Size: 0x18
struct FGeometryCollectionDebugDrawActorSelectedRigidBody {
    /* 0x0000 */ int32_t ID;
    /* 0x0008 */ AChaosSolverActor* Solver;
    /* 0x0010 */ AGeometryCollectionActor* GeometryCollection;
};

// Size: 0xd0
class UGeometryCollectionDebugDrawComponent : public UActorComponent {
    /* 0x00b8 */ AGeometryCollectionDebugDrawActor* GeometryCollectionDebugDrawActor;
    /* 0x00c0 */ AGeometryCollectionRenderLevelSetActor* GeometryCollectionRenderLevelSetActor;
};

// Size: 0x1
struct FGeometryCollectionDebugDrawWarningMessage {
};

// Size: 0x30
struct FGeometryCollectionEmbeddedExemplar {
    /* 0x0000 */ FSoftObjectPath StaticMeshExemplar;
    /* 0x0020 */ float StartCullDistance;
    /* 0x0024 */ float EndCullDistance;
    /* 0x0028 */ int32_t InstanceCount;
};

// Size: 0x28
class IGeometryCollectionExternalRenderInterface : public UInterface {
};

// Size: 0x2b8
class AGeometryCollectionISMPoolActor : public AActor {
    /* 0x02a8 */ UGeometryCollectionISMPoolComponent* ISMPoolComp;
    /* 0x02b0 */ UGeometryCollectionISMPoolDebugDrawComponent* ISMPoolDebugDrawComp;
};

// Size: 0x370
class UGeometryCollectionISMPoolComponent : public USceneComponent {
};

// Size: 0x5a0
class UGeometryCollectionISMPoolDebugDrawComponent : public UDebugDrawComponent {
    /* 0x0580 */ bool bShowGlobalStats;
    /* 0x0581 */ bool bShowStats;
    /* 0x0582 */ bool bShowBounds;
    /* 0x0588 */ UInstancedStaticMeshComponent* SelectedComponent;
};

// Size: 0xe0
class UGeometryCollectionISMPoolRenderer : public UObject {
    /* 0x0030 */ UISMPoolComponent* CachedISMPoolComponent;
    /* 0x0038 */ UISMPoolComponent* LocalISMPoolComponent;
};

// Size: 0x80
class UGeometryCollectionISMPoolSubSystem : public UWorldSubsystem {

    void OnActorEndPlay(AActor* InSource, uint8_t Reason);
};

// Size: 0x10
struct FGeometryCollectionLevelSetData {
    /* 0x0000 */ int32_t MinLevelSetResolution;
    /* 0x0004 */ int32_t MaxLevelSetResolution;
    /* 0x0008 */ int32_t MinClusterLevelSetResolution;
    /* 0x000c */ int32_t MaxClusterLevelSetResolution;
};

// Size: 0x20
struct FGeometryCollectionProxyMeshData {
    /* 0x0000 */ TArray<UStaticMesh*> ProxyMeshes;
    /* 0x0010 */ TArray<FTransform3f> MeshTransforms;
};

// Size: 0x3a0
class AGeometryCollectionRenderLevelSetActor : public AActor {
    /* 0x02a8 */ UVolumeTexture* TargetVolumeTexture;
    /* 0x02b0 */ UMaterial* RayMarchMaterial;
    /* 0x02b8 */ float SurfaceTolerance;
    /* 0x02bc */ float Isovalue;
    /* 0x02c0 */ bool Enabled;
    /* 0x02c1 */ bool RenderVolumeBoundingBox;
};

// Size: 0x10
struct FGeometryCollectionRenderResourceSizeInfo {
    /* 0x0000 */ uint64_t MeshResourcesSize;
    /* 0x0008 */ uint64_t NaniteResourcesSize;
};

// Size: 0x38
struct FGeometryCollectionRepData {
};

// Size: 0x18
struct FGeometryCollectionRepDynamicData {
};

// Size: 0x40
struct FGeometryCollectionRepStateData {
};

// Size: 0x48
class UGeometryCollectionRootProxyRenderer : public UObject {
    /* 0x0030 */ TArray<UStaticMeshComponent*> StaticMeshComponents;
};

// Size: 0x20
struct FGeometryCollectionSizeSpecificData {
    /* 0x0000 */ float MaxSize;
    /* 0x0008 */ TArray<FGeometryCollectionCollisionTypeData> CollisionShapes;
    /* 0x0018 */ int32_t DamageThreshold;
};

// Size: 0xb0
struct FGeometryCollectionSource {
    /* 0x0000 */ FSoftObjectPath SourceGeometryObject;
    /* 0x0020 */ FTransform LocalTransform;
    /* 0x0080 */ TArray<UMaterialInterface*> SourceMaterial;
    /* 0x0090 */ TArray<float> InstanceCustomData;
    /* 0x00a0 */ bool bAddInternalMaterials;
    /* 0x00a1 */ bool bSplitComponents;
    /* 0x00a2 */ bool bSetInternalFromMaterialIndex;
};

// Size: 0x5f0
class UBaseDynamicMeshComponent : public UMeshComponent {
    /* 0x0588 */ bool bExplicitShowWireframe;
    /* 0x058c */ FLinearColor WireframeColor;
    /* 0x059c */ EDynamicMeshComponentColorOverrideMode ColorMode;
    /* 0x05a0 */ FColor ConstantColor;
    /* 0x05a4 */ EDynamicMeshVertexColorTransformMode ColorSpaceMode;
    /* 0x05a5 */ bool bEnableFlatShading;
    /* 0x05a6 */ bool bEnableViewModeOverrides;
    /* 0x05a8 */ UMaterialInterface* OverrideRenderMaterial;
    /* 0x05b0 */ UMaterialInterface* SecondaryRenderMaterial;
    /* 0x05c0 */ UMaterialInterface* WireframeMaterialOverride;
    /* 0x05c8 */ UMaterialInterface* SecondaryWireframeMaterialOverride;
    /* 0x05d0 */ bool bEnableRayTracing;
    /* 0x05d1 */ EDynamicMeshDrawPath DrawPath;
    /* 0x05d2 */ EDynamicMeshComponentDistanceFieldMode DistanceFieldMode;
    /* 0x05d8 */ TArray<UMaterialInterface*> BaseMaterials;

    void ClearOverrideRenderMaterial();
    void ClearOverrideSecondaryWireframeRenderMaterial();
    void ClearOverrideWireframeRenderMaterial();
    void ClearSecondaryRenderMaterial();
    EDynamicMeshComponentColorOverrideMode GetColorOverrideMode() const;
    FColor GetConstantOverrideColor() const;
    EDynamicMeshComponentDistanceFieldMode GetDistanceFieldMode() const;
    UDynamicMesh* GetDynamicMesh();
    bool GetEnableRaytracing() const;
    bool GetEnableWireframeRenderPass() const;
    bool GetFlatShadingEnabled() const;
    EDynamicMeshDrawPath GetMeshDrawPath() const;
    UMaterialInterface* GetOverrideRenderMaterial(int32_t MaterialIndex) const;
    UMaterialInterface* GetOverrideSecondaryWireframeRenderMaterial() const;
    UMaterialInterface* GetOverrideWireframeRenderMaterial() const;
    bool GetSecondaryBuffersVisibility() const;
    UMaterialInterface* GetSecondaryRenderMaterial() const;
    bool GetShadowsEnabled() const;
    EDynamicMeshVertexColorTransformMode GetVertexColorSpaceTransformMode() const;
    bool GetViewModeOverridesEnabled() const;
    bool HasOverrideRenderMaterial(int32_t K) const;
    void SetColorOverrideMode(EDynamicMeshComponentColorOverrideMode NewMode);
    void SetConstantOverrideColor(FColor NewColor);
    void SetDistanceFieldMode(EDynamicMeshComponentDistanceFieldMode NewDistFieldMode);
    void SetEnableFlatShading(bool bEnable);
    void SetEnableRaytracing(bool bSetEnabled);
    void SetEnableWireframeRenderPass(bool bEnable);
    void SetMeshDrawPath(EDynamicMeshDrawPath NewDrawPath);
    void SetOverrideRenderMaterial(UMaterialInterface* Material);
    void SetOverrideSecondaryWireframeRenderMaterial(UMaterialInterface* Material);
    void SetOverrideWireframeRenderMaterial(UMaterialInterface* Material);
    void SetSecondaryBuffersVisibility(bool bSetVisible);
    void SetSecondaryRenderMaterial(UMaterialInterface* Material);
    void SetShadowsEnabled(bool bEnabled);
    void SetVertexColorSpaceTransformMode(EDynamicMeshVertexColorTransformMode NewMode);
    void SetViewModeOverridesEnabled(bool bEnabled);
};

// Size: 0xb0
class UDynamicMesh : public UObject {
    /* 0x0070 */ FMulticastInlineDelegate MeshModifiedBPEvent;
    /* 0x00a0 */ UDynamicMeshGenerator* MeshGenerator;
    /* 0x00a8 */ bool bEnableMeshGenerator;

    int32_t GetTriangleCount() const;
    bool IsEmpty() const;
    UDynamicMesh* Reset();
    UDynamicMesh* ResetToCube();
};

// Size: 0x2c0
class ADynamicMeshActor : public AActor {
    /* 0x02a8 */ UDynamicMeshComponent* DynamicMeshComponent;
    /* 0x02b0 */ bool bEnableComputeMeshPool;
    /* 0x02b8 */ UDynamicMeshPool* DynamicMeshPool;

    UDynamicMesh* AllocateComputeMesh();
    void FreeAllComputeMeshes();
    UDynamicMeshPool* GetComputeMeshPool();
    UDynamicMeshComponent* GetDynamicMeshComponent() const;
    void ReleaseAllComputeMeshes();
    bool ReleaseComputeMesh(UDynamicMesh* Mesh);
};

// Size: 0x20
struct FDynamicMeshChangeInfo {
    /* 0x0000 */ EDynamicMeshChangeType Type;
    /* 0x0001 */ EDynamicMeshAttributeChangeFlags Flags;
    /* 0x0002 */ bool bIsRevertChange;
};

// Size: 0x910
class UDynamicMeshComponent : public UBaseDynamicMeshComponent {
    /* 0x05f0 */ UDynamicMesh* MeshObject;
    /* 0x0651 */ bool bAllowsGeometrySelection;
    /* 0x0720 */ EDynamicMeshComponentTangentsMode TangentsType;
    /* 0x0810 */ uint8_t CollisionType;
    /* 0x0811 */ bool bUseAsyncCooking;
    /* 0x0812 */ bool bEnableComplexCollision;
    /* 0x0813 */ bool bDeferCollisionUpdates;
    /* 0x0814 */ bool bDisableMeshUVHitResults;
    /* 0x0818 */ UBodySetup* MeshBodySetup;
    /* 0x0858 */ FKAggregateGeom AggGeom;
    /* 0x08f8 */ TArray<UBodySetup*> AsyncBodySetupQueue;

    bool AllowsGeometrySelection() const;
    void ConfigureMaterialSet(const TArray<UMaterialInterface*>& NewMaterialSet, bool bDeleteExtraSlots);
    void EnableComplexAsSimpleCollision();
    EDynamicMeshComponentTangentsMode GetTangentsType() const;
    EDynamicMeshComponentTangentsMode GetTangentsTypePure() const;
    void NotifyMeshModified();
    void NotifyMeshVertexAttributesModified(bool bPositions, bool bNormals, bool bUVs, bool bColors);
    void SetAllowsGeometrySelection(bool bInAllowsGeometrySelection);
    void SetComplexAsSimpleCollisionEnabled(bool bEnabled, bool bImmediateUpdate);
    void SetDeferredCollisionUpdatesEnabled(bool bEnabled, bool bImmediateUpdate);
    void SetDynamicMesh(UDynamicMesh* NewMesh);
    void SetTangentsType(EDynamicMeshComponentTangentsMode NewTangentsType);
    void UpdateCollision(bool bOnlyIfPending);
    bool ValidateMaterialSlots(bool bCreateIfMissing, bool bDeleteExtraSlots);
};

// Size: 0x28
class UDynamicMeshGenerator : public UObject {
};

// Size: 0x48
class UDynamicMeshPool : public UObject {
    /* 0x0028 */ TArray<UDynamicMesh*> CachedMeshes;
    /* 0x0038 */ TArray<UDynamicMesh*> AllCreatedMeshes;

    void FreeAllMeshes();
    UDynamicMesh* RequestMesh();
    void ReturnAllMeshes();
    void ReturnMesh(UDynamicMesh* Mesh);
};

// Size: 0x28
class UDynamicMeshProcessorBlueprint : public UObject {

    void ProcessDynamicMesh(UDynamicMesh* TargetMesh, bool& bFailed);
};

enum class EDynamicMeshAttributeChangeFlags {
    Unknown = 0,
    MeshTopology = 1,
    VertexPositions = 2,
    NormalsTangents = 4,
    VertexColors = 8,
    UVs = 16,
    TriangleGroups = 32,
    EDynamicMeshAttributeChangeFlags_MAX = 33,
};

enum class EDynamicMeshChangeType {
    GeneralEdit = 0,
    MeshChange = 1,
    MeshReplacementChange = 2,
    MeshVertexChange = 3,
    DeformationEdit = 4,
    AttributeEdit = 5,
    EDynamicMeshChangeType_MAX = 6,
};

enum class EDynamicMeshComponentColorOverrideMode {
    None = 0,
    VertexColors = 1,
    Polygroups = 2,
    Constant = 3,
    EDynamicMeshComponentColorOverrideMode_MAX = 4,
};

enum class EDynamicMeshComponentDistanceFieldMode {
    NoDistanceField = 0,
    AsyncCPUDistanceField = 1,
    EDynamicMeshComponentDistanceFieldMode_MAX = 2,
};

enum class EDynamicMeshComponentRenderUpdateMode {
    NoUpdate = 0,
    FullUpdate = 1,
    FastUpdate = 2,
    EDynamicMeshComponentRenderUpdateMode_MAX = 3,
};

enum class EDynamicMeshComponentTangentsMode {
    NoTangents = 0,
    AutoCalculated = 1,
    ExternallyProvided = 2,
    Default = 255,
    EDynamicMeshComponentTangentsMode_MAX = 256,
};

enum class EDynamicMeshDrawPath {
    DynamicDraw = 0,
    StaticDraw = 1,
    EDynamicMeshDrawPath_MAX = 2,
};

enum class EDynamicMeshVertexColorTransformMode {
    NoTransform = 0,
    LinearToSRGB = 1,
    SRGBToLinear = 2,
    EDynamicMeshVertexColorTransformMode_MAX = 3,
};

// Size: 0x28
class IMeshCommandChangeTarget : public UInterface {
};

// Size: 0x28
class IMeshReplacementCommandChangeTarget : public UInterface {
};

// Size: 0x28
class IMeshVertexCommandChangeTarget : public UInterface {
};

// Size: 0xc8
class UDataflowGroomContent : public UDataflowSkeletalContent {
    /* 0x00c0 */ UGroomBindingAsset* BindingAsset;
};

enum class EFollicleMaskChannel {
    R = 0,
    G = 1,
    B = 2,
    A = 3,
    EFollicleMaskChannel_MAX = 4,
};

enum class EGroomBasisType {
    NoBasis = 0,
    BezierBasis = 1,
    BsplineBasis = 2,
    CatmullromBasis = 3,
    HermiteBasis = 4,
    PowerBasis = 5,
    EGroomBasisType_MAX = 6,
};

enum class EGroomBindingAssetBuildResult {
    Succeeded = 0,
    Failed = 1,
    EGroomBindingAssetBuildResult_MAX = 2,
};

enum class EGroomBindingAsyncProperties {
    None = 0,
    GroomBindingType = 1,
    Groom = 2,
    SourceSkeletalMesh = 4,
    SourceMeshRequestedLOD = 8,
    SourceMeshUsedLOD = 16,
    TargetSkeletalMesh = 32,
    TargetMeshRequestedMinLOD = 64,
    TargetMeshUsedMinLOD = 128,
    SourceGeometryCache = 256,
    TargetGeometryCache = 512,
    NumInterpolationPoints = 1024,
    MatchingSection = 2048,
    GroupInfos = 4096,
    HairGroupResources = 8192,
    HairGroupPlatformData = 16384,
    TargetBindingAttribute = 32768,
    All = -1,
    EGroomBindingAsyncProperties_MAX = 32769,
};

enum class EGroomBindingMeshType {
    SkeletalMesh = 0,
    GeometryCache = 1,
    EGroomBindingMeshType_MAX = 2,
};

enum class EGroomBindingType {
    NoneBinding = 0,
    Rigid = 1,
    Skinning = 2,
    EGroomBindingType_MAX = 3,
};

enum class EGroomCacheAttributes {
    None = 0,
    Position = 1,
    Width = 2,
    Color = 4,
    PositionWidth = 3,
    PositionColor = 5,
    WidthColor = 5,
    PositionWidthColor = 7,
    EGroomCacheAttributes_MAX = 8,
};

enum class EGroomCacheImportType {
    None = 0,
    Strands = 1,
    Guides = 2,
    All = 3,
    EGroomCacheImportType_MAX = 4,
};

enum class EGroomCacheType {
    None = 0,
    Strands = 1,
    Guides = 2,
    EGroomCacheType_MAX = 3,
};

enum class EGroomCurveType {
    Cubic = 0,
    Linear = 1,
    VariableOrder = 2,
    EGroomCurveType_MAX = 3,
};

enum class EGroomGeometryType {
    Strands = 0,
    Cards = 1,
    Meshes = 2,
    EGroomGeometryType_MAX = 3,
};

enum class EGroomGuideType {
    Imported = 0,
    Generated = 1,
    Rigged = 2,
    EGroomGuideType_MAX = 3,
};

enum class EGroomInterpolationQuality {
    Low = 0,
    Medium = 1,
    High = 2,
    Unknown = 3,
    EGroomInterpolationQuality_MAX = 4,
};

enum class EGroomInterpolationType {
    None = 0,
    RigidTransform = 2,
    OffsetTransform = 4,
    SmoothTransform = 8,
    EGroomInterpolationType_MAX = 9,
};

enum class EGroomInterpolationWeight {
    Parametric = 0,
    Root = 1,
    Index = 2,
    Unknown = 3,
    EGroomInterpolationWeight_MAX = 4,
};

enum class EGroomLODMode {
    Default = 0,
    Manual = 1,
    Auto = 2,
    EGroomLODMode_MAX = 3,
};

enum class EGroomNiagaraSolvers {
    None = 0,
    CosseratRods = 2,
    AngularSprings = 4,
    CustomSolver = 8,
    EGroomNiagaraSolvers_MAX = 9,
};

enum class EGroomOverrideType {
    Auto = 0,
    Enable = 1,
    Disable = 2,
    EGroomOverrideType_MAX = 3,
};

enum class EGroomStrandsSize {
    None = 0,
    Size2 = 2,
    Size4 = 4,
    Size8 = 8,
    Size16 = 16,
    Size32 = 32,
    EGroomStrandsSize_MAX = 33,
};

enum class EHairAtlasTextureType {
    Depth = 0,
    Tangent = 1,
    Attribute = 2,
    Coverage = 3,
    AuxilaryData = 4,
    Material = 5,
    EHairAtlasTextureType_MAX = 6,
};

enum class EHairCardsGuideType {
    Generated = 0,
    GuideBased = 1,
    EHairCardsGuideType_MAX = 2,
};

enum class EHairCardsSourceType {
    Procedural = 0,
    Imported = 1,
    EHairCardsSourceType_MAX = 2,
};

enum class EHairInterpolationQuality {
    Low = 0,
    Medium = 1,
    High = 2,
    Unknown = 3,
    EHairInterpolationQuality_MAX = 4,
};

enum class EHairInterpolationWeight {
    Parametric = 0,
    Root = 1,
    Index = 2,
    Distance = 3,
    Unknown = 4,
    EHairInterpolationWeight_MAX = 5,
};

enum class EHairTextureLayout {
    Layout0 = 0,
    Layout1 = 1,
    Layout2 = 2,
    Layout3 = 3,
    EHairTextureLayout_MAX = 4,
};

enum class EStrandsTexturesMeshType {
    Static = 0,
    Skeletal = 1,
    EStrandsTexturesMeshType_MAX = 2,
};

enum class EStrandsTexturesTraceType {
    TraceInside = 0,
    TraceOuside = 1,
    TraceBidirectional = 2,
    EStrandsTexturesTraceType_MAX = 3,
};

// Size: 0x10
struct FFollicleMaskOptions {
    /* 0x0000 */ UGroomAsset* Groom;
    /* 0x0008 */ EFollicleMaskChannel Channel;
};

// Size: 0x10
struct FGoomBindingGroupInfo {
    /* 0x0000 */ int32_t RenRootCount;
    /* 0x0004 */ int32_t RenLODCount;
    /* 0x0008 */ int32_t SimRootCount;
    /* 0x000c */ int32_t SimLODCount;
};

// Size: 0x2b0
class AGroomActor : public AActor {
    /* 0x02a8 */ UGroomComponent* GroomComponent;
};

// Size: 0x20
struct FGroomAnimationInfo {
    /* 0x0000 */ uint32_t NumFrames;
    /* 0x0004 */ float SecondsPerFrame;
    /* 0x0008 */ float Duration;
    /* 0x000c */ float StartTime;
    /* 0x0010 */ float EndTime;
    /* 0x0014 */ int32_t StartFrame;
    /* 0x0018 */ int32_t EndFrame;
    /* 0x001c */ EGroomCacheAttributes Attributes;
};

// Size: 0x190
class UGroomAsset : public UObject {
    /* 0x0050 */ EGroomLODMode LODMode;
    /* 0x0054 */ float AutoLODBias;
    /* 0x0058 */ FGroomDataflowSettings DataflowSettings;
    /* 0x00a0 */ TArray<FHairGroupInfoWithVisibility> HairGroupsInfo;
    /* 0x00b0 */ TArray<FHairGroupsRendering> HairGroupsRendering;
    /* 0x00c0 */ TArray<FHairGroupsPhysics> HairGroupsPhysics;
    /* 0x00d0 */ TArray<FHairGroupsInterpolation> HairGroupsInterpolation;
    /* 0x00e0 */ TArray<FHairGroupsLOD> HairGroupsLOD;
    /* 0x00f0 */ TArray<FHairGroupsCardsSourceDescription> HairGroupsCards;
    /* 0x0100 */ TArray<FHairGroupsMeshesSourceDescription> HairGroupsMeshes;
    /* 0x0110 */ TArray<FHairGroupsMaterial> HairGroupsMaterials;
    /* 0x0120 */ bool EnableGlobalInterpolation;
    /* 0x0121 */ bool EnableSimulationCache;
    /* 0x0122 */ EGroomInterpolationType HairInterpolationType;
    /* 0x0128 */ USkeletalMesh* RiggedSkeletalMesh;
    /* 0x0130 */ TArray<int32_t> DeformedGroupSections;
    /* 0x0140 */ FPerPlatformInt MinLOD;
    /* 0x0144 */ FPerPlatformBool DisableBelowMinLodStripping;
    /* 0x0148 */ TArray<float> EffectiveLODBias;
    /* 0x0178 */ TArray<UAssetUserData*> AssetUserData;

    TArray<int32_t> GetDeformedGroupSections();
    bool GetEnableGlobalInterpolation() const;
    bool GetEnableSimulationCache() const;
    TArray<FHairGroupsCardsSourceDescription> GetHairGroupsCards();
    TArray<FHairGroupsInterpolation> GetHairGroupsInterpolation();
    TArray<FHairGroupsLOD> GetHairGroupsLOD();
    TArray<FHairGroupsMaterial> GetHairGroupsMaterials();
    TArray<FHairGroupsMeshesSourceDescription> GetHairGroupsMeshes();
    TArray<FHairGroupsPhysics> GetHairGroupsPhysics();
    TArray<FHairGroupsRendering> GetHairGroupsRendering();
    EGroomInterpolationType GetHairInterpolationType() const;
    USkeletalMesh* GetRiggedSkeletalMesh() const;
    void SetDeformedGroupSections(const TArray<int32_t>& In);
    void SetEnableGlobalInterpolation(bool In);
    void SetEnableSimulationCache(bool In);
    void SetHairGroupsCards(const TArray<FHairGroupsCardsSourceDescription>& In);
    void SetHairGroupsInterpolation(const TArray<FHairGroupsInterpolation>& In);
    void SetHairGroupsLOD(const TArray<FHairGroupsLOD>& In);
    void SetHairGroupsMaterials(const TArray<FHairGroupsMaterial>& In);
    void SetHairGroupsMeshes(const TArray<FHairGroupsMeshesSourceDescription>& In);
    void SetHairGroupsPhysics(const TArray<FHairGroupsPhysics>& In);
    void SetHairGroupsRendering(const TArray<FHairGroupsRendering>& In);
    void SetHairInterpolationType(EGroomInterpolationType In);
    void SetRiggedSkeletalMesh(USkeletalMesh* In);
};

// Size: 0x38
class UGroomAssetImportData : public UAssetImportData {
    /* 0x0028 */ UGroomImportOptions* ImportOptions;
    /* 0x0030 */ UGroomCreateStrandsTexturesOptions* HairStrandsTexturesOptions;
};

// Size: 0xf0
class UGroomBindingAsset : public UObject {
    /* 0x0030 */ EGroomBindingMeshType GroomBindingType;
    /* 0x0038 */ UGroomAsset* Groom;
    /* 0x0040 */ USkeletalMesh* SourceSkeletalMesh;
    /* 0x0048 */ int32_t SourceMeshRequestedLOD;
    /* 0x004c */ int32_t SourceMeshUsedLOD;
    /* 0x0050 */ USkeletalMesh* TargetSkeletalMesh;
    /* 0x0058 */ int32_t TargetMeshRequestedMinLOD;
    /* 0x005c */ int32_t TargetMeshUsedMinLOD;
    /* 0x0060 */ UGeometryCache* SourceGeometryCache;
    /* 0x0068 */ UGeometryCache* TargetGeometryCache;
    /* 0x0070 */ int32_t NumInterpolationPoints;
    /* 0x0074 */ int32_t MatchingSection;
    /* 0x0078 */ FName TargetBindingAttribute;
    /* 0x0080 */ TArray<FGoomBindingGroupInfo> GroupInfos;

    void Build(FDelegate CompletionDelegate);
    UGroomAsset* GetGroom() const;
    EGroomBindingMeshType GetGroomBindingType() const;
    TArray<FGoomBindingGroupInfo> GetGroupInfos() const;
    int32_t GetMatchingSection() const;
    int32_t GetNumInterpolationPoints() const;
    UGeometryCache* GetSourceGeometryCache() const;
    int32_t GetSourceMeshRequestedLOD() const;
    int32_t GetSourceMeshUsedLOD() const;
    USkeletalMesh* GetSourceSkeletalMesh() const;
    FName GetTargetBindingAttribute() const;
    UGeometryCache* GetTargetGeometryCache() const;
    int32_t GetTargetMeshRequestedMinLOD() const;
    int32_t GetTargetMeshUsedMinLOD() const;
    USkeletalMesh* GetTargetSkeletalMesh() const;
    void SetGroom(UGroomAsset* InGroom);
    void SetGroomBindingType(EGroomBindingMeshType InGroomBindingType);
    void SetGroupInfos(const TArray<FGoomBindingGroupInfo>& InGroupInfos);
    void SetMatchingSection(int32_t InMatchingSection);
    void SetNumInterpolationPoints(int32_t InNumInterpolationPoints);
    void SetSourceGeometryCache(UGeometryCache* InGeometryCache);
    void SetSourceMeshRequestedLOD(int32_t InSourceMeshRequestedLOD);
    void SetSourceMeshUsedLOD(int32_t InSourceMeshUsedLOD);
    void SetSourceSkeletalMesh(USkeletalMesh* InSkeletalMesh);
    void SetTargetBindingAttribute(FName InAttributeName);
    void SetTargetGeometryCache(UGeometryCache* InGeometryCache);
    void SetTargetMeshRequestedMinLOD(int32_t InTargetMeshRequestedMinLOD);
    void SetTargetMeshUsedMinLOD(int32_t InTargetMeshUsedMinLOD);
    void SetTargetSkeletalMesh(USkeletalMesh* InSkeletalMesh);
};

// Size: 0x38
class UGroomBindingAssetList : public UObject {
    /* 0x0028 */ TArray<UGroomBindingAsset*> Bindings;
};

// Size: 0x28
class UGroomBlueprintLibrary : public UBlueprintFunctionLibrary {

    static UGroomBindingAsset* CreateNewGeometryCacheGroomBindingAsset(UGroomAsset* GroomAsset, UGeometryCache* GeometryCache, int32_t NumInterpolationPoints, UGeometryCache* SourceGeometryCacheForTransfer, int32_t MatchingSection);
    static UGroomBindingAsset* CreateNewGeometryCacheGroomBindingAssetWithPath(FString DesiredPackagePath, UGroomAsset* GroomAsset, UGeometryCache* GeometryCache, int32_t NumInterpolationPoints, UGeometryCache* SourceGeometryCacheForTransfer, int32_t MatchingSection);
    static UGroomBindingAsset* CreateNewGroomBindingAsset(UGroomAsset* InGroomAsset, USkeletalMesh* InSkeletalMesh, int32_t InNumInterpolationPoints, USkeletalMesh* InSourceSkeletalMeshForTransfer, int32_t InMatchingSection);
    static UGroomBindingAsset* CreateNewGroomBindingAssetWithPath(FString InDesiredPackagePath, UGroomAsset* InGroomAsset, USkeletalMesh* InSkeletalMesh, int32_t InNumInterpolationPoints, USkeletalMesh* InSourceSkeletalMeshForTransfer, int32_t InMatchingSection);
    static bool IsHairStrandsSupportedInWorld(const UObject* WorldContextObject);
};

// Size: 0xc
struct FGroomBuildSettings {
    /* 0x0000 */ bool bOverrideGuides;
    /* 0x0004 */ float HairToGuideDensity;
    /* 0x0008 */ EGroomInterpolationQuality InterpolationQuality;
    /* 0x0009 */ EGroomInterpolationWeight InterpolationDistance;
    /* 0x000a */ bool bRandomizeGuide;
    /* 0x000b */ bool bUseUniqueGuide;
};

// Size: 0x90
class UGroomCache : public UObject {
    /* 0x0048 */ TArray<UAssetUserData*> AssetUserData;
    /* 0x0058 */ FGroomCacheInfo GroomCacheInfo;
};

// Size: 0x90
class UGroomCacheImportData : public UAssetImportData {
    /* 0x0028 */ FGroomCacheImportSettings Settings;
};

// Size: 0x90
class UGroomCacheImportOptions : public UObject {
    /* 0x0028 */ FGroomCacheImportSettings ImportSettings;
};

// Size: 0x68
struct FGroomCacheImportSettings {
    /* 0x0000 */ bool bImportGroomCache;
    /* 0x0001 */ EGroomCacheImportType ImportType;
    /* 0x0004 */ int32_t FrameStart;
    /* 0x0008 */ int32_t FrameEnd;
    /* 0x000c */ bool bSkipEmptyFrames;
    /* 0x000d */ bool bImportGroomAsset;
    /* 0x0010 */ FSoftObjectPath GroomAsset;
    /* 0x0030 */ bool bOverrideConversionSettings;
    /* 0x0038 */ FGroomConversionSettings ConversionSettings;
};

// Size: 0x28
struct FGroomCacheInfo {
    /* 0x0000 */ int32_t Version;
    /* 0x0004 */ EGroomCacheType Type;
    /* 0x0008 */ FGroomAnimationInfo AnimationInfo;
};

// Size: 0x7c0
class UGroomComponent : public UMeshComponent {
    /* 0x0578 */ UGroomAsset* GroomAsset;
    /* 0x0580 */ UGroomCache* GroomCache;
    /* 0x0588 */ TArray<UNiagaraComponent*> NiagaraComponents;
    /* 0x0598 */ USkeletalMesh* SourceSkeletalMesh;
    /* 0x05a0 */ UGroomBindingAsset* BindingAsset;
    /* 0x05a8 */ UPhysicsAsset* PhysicsAsset;
    /* 0x05c0 */ FHairSimulationSettings SimulationSettings;
    /* 0x0650 */ UMeshDeformer* MeshDeformer;
    /* 0x0658 */ UMeshDeformerInstance* MeshDeformerInstance;
    /* 0x0660 */ UMeshDeformerInstanceSettings* MeshDeformerInstanceSettings;
    /* 0x0668 */ UMaterialInterface* Strands_DebugMaterial;
    /* 0x0670 */ UMaterialInterface* Strands_DefaultMaterial;
    /* 0x0678 */ UMaterialInterface* Cards_DefaultMaterial;
    /* 0x0680 */ UMaterialInterface* Meshes_DefaultMaterial;
    /* 0x0688 */ UNiagaraSystem* AngularSpringsSystem;
    /* 0x0690 */ UNiagaraSystem* CosseratRodsSystem;
    /* 0x0698 */ FString AttachmentName;
    /* 0x0730 */ TArray<FHairGroupDesc> GroomGroupsDesc;
    /* 0x0740 */ bool bUseCards;
    /* 0x0741 */ bool bRunning;
    /* 0x0742 */ bool bLooping;
    /* 0x0743 */ bool bManualTick;
    /* 0x0744 */ float ElapsedTime;

    void AddCollisionComponent(USkeletalMeshComponent* SkeletalMeshComponent);
    bool GetIsHairLengthScaleEnabled();
    UNiagaraComponent* GetNiagaraComponent(const int32_t GroupIndex);
    void ResetCollisionComponents();
    void ResetSimulation();
    void SetBindingAsset(UGroomBindingAsset* InBinding);
    void SetEnableSimulation(bool bInEnableSimulation);
    void SetGroomAsset(UGroomAsset* Asset);
    void SetGroomCache(UGroomCache* InGroomCache);
    void SetHairLengthScale(float Scale);
    void SetHairLengthScaleEnable(bool bEnable);
    void SetMeshDeformer(UMeshDeformer* InMeshDeformer);
    void SetPhysicsAsset(UPhysicsAsset* InPhysicsAsset);
};

// Size: 0x30
struct FGroomConversionSettings {
    /* 0x0000 */ FVector Rotation;
    /* 0x0018 */ FVector Scale;
};

// Size: 0x68
class UGroomCreateBindingOptions : public UObject {
    /* 0x0028 */ TWeakObjectPtr<UGroomAsset> GroomAsset;
    /* 0x0030 */ EGroomBindingMeshType GroomBindingType;
    /* 0x0038 */ USkeletalMesh* SourceSkeletalMesh;
    /* 0x0040 */ USkeletalMesh* TargetSkeletalMesh;
    /* 0x0048 */ UGeometryCache* SourceGeometryCache;
    /* 0x0050 */ UGeometryCache* TargetGeometryCache;
    /* 0x0058 */ int32_t NumInterpolationPoints;
    /* 0x005c */ int32_t MatchingSection;
    /* 0x0060 */ FName TargetBindingAttribute;
};

// Size: 0x40
class UGroomCreateFollicleMaskOptions : public UObject {
    /* 0x0028 */ int32_t Resolution;
    /* 0x002c */ int32_t RootRadius;
    /* 0x0030 */ TArray<FFollicleMaskOptions> Grooms;
};

// Size: 0x88
class UGroomCreateStrandsTexturesOptions : public UObject {
    /* 0x0028 */ EHairTextureLayout Layout;
    /* 0x002c */ int32_t Resolution;
    /* 0x0030 */ EStrandsTexturesTraceType TraceType;
    /* 0x0034 */ float TraceDistance;
    /* 0x0038 */ EStrandsTexturesMeshType MeshType;
    /* 0x0040 */ UStaticMesh* StaticMesh;
    /* 0x0048 */ USkeletalMesh* SkeletalMesh;
    /* 0x0050 */ int32_t LODIndex;
    /* 0x0054 */ int32_t SectionIndex;
    /* 0x0058 */ int32_t UVChannelIndex;
    /* 0x0060 */ TArray<int32_t> GroupIndex;
    /* 0x0070 */ int32_t Dilation;
    /* 0x0078 */ TArray<UTexture2D*> GeneratedTextures;
};

// Size: 0x48
struct FGroomDataflowSettings {
    /* 0x0000 */ UDataflow* DataflowAsset;
    /* 0x0008 */ FString DataflowTerminal;
    /* 0x0018 */ TArray<USkeletalMesh*> SkeletalMeshes;
    /* 0x0028 */ TArray<int32_t> MeshLODs;
};

// Size: 0x4c
struct FGroomHairGroupPreview {
    /* 0x0000 */ int32_t GroupIndex;
    /* 0x0004 */ FName GroupName;
    /* 0x000c */ int32_t GroupID;
    /* 0x0010 */ int32_t CurveCount;
    /* 0x0014 */ int32_t GuideCount;
    /* 0x0018 */ uint32_t Attributes;
    /* 0x001c */ uint32_t AttributeFlags;
    /* 0x0020 */ uint32_t Flags;
    /* 0x0024 */ FHairGroupsInterpolation InterpolationSettings;
};

// Size: 0x78
class UGroomHairGroupsMapping : public UObject {
    /* 0x0028 */ TArray<FName> OldGroupNames;
    /* 0x0038 */ TArray<FName> NewGroupNames;
    /* 0x0048 */ TArray<int32_t> OldToNewGroupIndexMapping;
    /* 0x0058 */ TArray<int32_t> NewToOldGroupIndexMapping;
};

// Size: 0x38
class UGroomHairGroupsPreview : public UObject {
    /* 0x0028 */ TArray<FGroomHairGroupPreview> Groups;
};

// Size: 0x68
class UGroomImportOptions : public UObject {
    /* 0x0028 */ FGroomConversionSettings ConversionSettings;
    /* 0x0058 */ TArray<FHairGroupsInterpolation> InterpolationSettings;
};

// Size: 0x30
class UGroomPluginSettings : public UObject {
    /* 0x0028 */ float GroomCacheLookAheadBuffer;
};

// Size: 0x2
struct FHairAdvancedRenderingSettings {
    /* 0x0000 */ bool bUseStableRasterization;
    /* 0x0001 */ bool bScatterSceneLighting;
};

// Size: 0x98
struct FHairBendConstraint {
    /* 0x0000 */ bool SolveBend;
    /* 0x0001 */ bool ProjectBend;
    /* 0x0004 */ float BendDamping;
    /* 0x0008 */ float BendStiffness;
    /* 0x0010 */ FRuntimeFloatCurve BendScale;
};

// Size: 0x28
class UHairCardGenerationSettings : public UObject {
};

// Size: 0xa8
struct FHairCollisionConstraint {
    /* 0x0000 */ bool SolveCollision;
    /* 0x0001 */ bool ProjectCollision;
    /* 0x0004 */ float StaticFriction;
    /* 0x0008 */ float KineticFriction;
    /* 0x000c */ float StrandsViscosity;
    /* 0x0010 */ FIntVector GridDimension;
    /* 0x001c */ float collisionRadius;
    /* 0x0020 */ FRuntimeFloatCurve RadiusScale;
};

// Size: 0x8
struct FHairDecimationSettings {
    /* 0x0000 */ float CurveDecimation;
    /* 0x0004 */ float VertexDecimation;
};

// Size: 0xc
struct FHairDeformationSettings {
    /* 0x0000 */ bool bEnableRigging;
    /* 0x0004 */ int32_t NumCurves;
    /* 0x0008 */ int32_t NumPoints;
};

// Size: 0x38
struct FHairExternalForces {
    /* 0x0000 */ FVector GravityVector;
    /* 0x0018 */ float AirDrag;
    /* 0x0020 */ FVector AirVelocity;
};

// Size: 0x10
struct FHairGeometrySettings {
    /* 0x0000 */ float HairWidth;
    /* 0x0004 */ bool HairWidth_Override;
    /* 0x0008 */ float HairRootScale;
    /* 0x000c */ float HairTipScale;
};

// Size: 0x8
struct FHairGroupCardsInfo {
    /* 0x0000 */ int32_t NumCards;
    /* 0x0004 */ int32_t NumCardVertices;
};

// Size: 0x50
struct FHairGroupCardsTextures {
    /* 0x0000 */ EHairTextureLayout Layout;
    /* 0x0008 */ TArray<UTexture2D*> Textures;
    /* 0x0018 */ UTexture2D* DepthTexture;
    /* 0x0020 */ UTexture2D* CoverageTexture;
    /* 0x0028 */ UTexture2D* TangentTexture;
    /* 0x0030 */ UTexture2D* AttributeTexture;
    /* 0x0038 */ UTexture2D* AuxilaryDataTexture;
    /* 0x0040 */ UTexture2D* MaterialTexture;
};

// Size: 0x40
struct FHairGroupDesc {
    /* 0x0000 */ float HairLength;
    /* 0x0004 */ float HairWidth;
    /* 0x0008 */ bool HairWidth_Override;
    /* 0x000c */ float HairRootScale;
    /* 0x0010 */ bool HairRootScale_Override;
    /* 0x0014 */ float HairTipScale;
    /* 0x0018 */ bool HairTipScale_Override;
    /* 0x001c */ float HairShadowDensity;
    /* 0x0020 */ bool HairShadowDensity_Override;
    /* 0x0024 */ float HairRaytracingRadiusScale;
    /* 0x0028 */ bool HairRaytracingRadiusScale_Override;
    /* 0x0029 */ bool bUseHairRaytracingGeometry;
    /* 0x002a */ bool bUseHairRaytracingGeometry_Override;
    /* 0x002c */ float LODBias;
    /* 0x0030 */ bool bUseStableRasterization;
    /* 0x0031 */ bool bUseStableRasterization_Override;
    /* 0x0032 */ bool bScatterSceneLighting;
    /* 0x0033 */ bool bScatterSceneLighting_Override;
    /* 0x0034 */ bool bSupportVoxelization;
    /* 0x0035 */ bool bSupportVoxelization_Override;
    /* 0x0038 */ float HairLengthScale;
    /* 0x003c */ bool HairLengthScale_Override;
};

// Size: 0x38
struct FHairGroupInfo {
    /* 0x0000 */ int32_t GroupIndex;
    /* 0x0004 */ int32_t GroupID;
    /* 0x0008 */ FName GroupName;
    /* 0x0010 */ int32_t NumCurves;
    /* 0x0014 */ int32_t NumGuides;
    /* 0x0018 */ int32_t NumCurveVertices;
    /* 0x001c */ int32_t NumGuideVertices;
    /* 0x0020 */ float MaxCurveLength;
    /* 0x0024 */ uint32_t Flags;
    /* 0x0028 */ TArray<FHairGroupLODInfo> LODInfos;
};

// Size: 0x40
struct FHairGroupInfoWithVisibility : public FHairGroupInfo {
    /* 0x0038 */ bool bIsVisible;
};

// Size: 0x8
struct FHairGroupLODInfo {
    /* 0x0000 */ int32_t NumPoints;
    /* 0x0004 */ int32_t NumCurves;
};

// Size: 0xa0
struct FHairGroupsCardsSourceDescription {
    /* 0x0000 */ UMaterialInterface* Material;
    /* 0x0008 */ FName MaterialSlotName;
    /* 0x0010 */ EHairCardsSourceType SourceType;
    /* 0x0018 */ UStaticMesh* ProceduralMesh;
    /* 0x0020 */ bool bInvertUV;
    /* 0x0021 */ EHairCardsGuideType GuideType;
    /* 0x0028 */ UStaticMesh* ImportedMesh;
    /* 0x0030 */ FHairGroupCardsTextures Textures;
    /* 0x0080 */ int32_t GroupIndex;
    /* 0x0084 */ int32_t LODIndex;
    /* 0x0088 */ FHairGroupCardsInfo CardsInfo;
    /* 0x0090 */ FString ImportedMeshKey;
};

// Size: 0x28
struct FHairGroupsInterpolation {
    /* 0x0000 */ FHairDecimationSettings DecimationSettings;
    /* 0x0008 */ FHairInterpolationSettings InterpolationSettings;
    /* 0x001c */ FHairDeformationSettings RiggingSettings;
};

// Size: 0x18
struct FHairGroupsLOD {
    /* 0x0000 */ float AutoLODBias;
    /* 0x0008 */ TArray<FHairLODSettings> LODs;
};

// Size: 0x10
struct FHairGroupsMaterial {
    /* 0x0000 */ UMaterialInterface* Material;
    /* 0x0008 */ FName SlotName;
};

// Size: 0x80
struct FHairGroupsMeshesSourceDescription {
    /* 0x0000 */ UMaterialInterface* Material;
    /* 0x0008 */ FName MaterialSlotName;
    /* 0x0010 */ UStaticMesh* ImportedMesh;
    /* 0x0018 */ FHairGroupCardsTextures Textures;
    /* 0x0068 */ int32_t GroupIndex;
    /* 0x006c */ int32_t LODIndex;
    /* 0x0070 */ FString ImportedMeshKey;
};

// Size: 0x2e8
struct FHairGroupsPhysics {
    /* 0x0000 */ FHairSolverSettings SolverSettings;
    /* 0x0040 */ FHairExternalForces ExternalForces;
    /* 0x0078 */ FHairMaterialConstraints MaterialConstraints;
    /* 0x0250 */ FHairStrandsParameters StrandsParameters;
};

// Size: 0x30
struct FHairGroupsRendering {
    /* 0x0000 */ FName MaterialSlotName;
    /* 0x0008 */ UMaterialInterface* Material;
    /* 0x0010 */ FHairGeometrySettings GeometrySettings;
    /* 0x0020 */ FHairShadowSettings ShadowSettings;
    /* 0x002c */ FHairAdvancedRenderingSettings AdvancedSettings;
};

// Size: 0x14
struct FHairInterpolationSettings {
    /* 0x0000 */ EGroomGuideType GuideType;
    /* 0x0001 */ bool bOverrideGuides;
    /* 0x0004 */ float HairToGuideDensity;
    /* 0x0008 */ int32_t RiggedGuideNumCurves;
    /* 0x000c */ int32_t RiggedGuideNumPoints;
    /* 0x0010 */ EHairInterpolationQuality InterpolationQuality;
    /* 0x0011 */ EHairInterpolationWeight InterpolationDistance;
    /* 0x0012 */ bool bRandomizeGuide;
    /* 0x0013 */ bool bUseUniqueGuide;
};

// Size: 0x1c
struct FHairLODSettings {
    /* 0x0000 */ float CurveDecimation;
    /* 0x0004 */ float VertexDecimation;
    /* 0x0008 */ float AngularThreshold;
    /* 0x000c */ float ScreenSize;
    /* 0x0010 */ float ThicknessScale;
    /* 0x0014 */ bool bVisible;
    /* 0x0015 */ EGroomGeometryType GeometryType;
    /* 0x0016 */ EGroomBindingType BindingType;
    /* 0x0017 */ EGroomOverrideType Simulation;
    /* 0x0018 */ EGroomOverrideType GlobalInterpolation;
};

// Size: 0x1d8
struct FHairMaterialConstraints {
    /* 0x0000 */ FHairBendConstraint BendConstraint;
    /* 0x0098 */ FHairStretchConstraint StretchConstraint;
    /* 0x0130 */ FHairCollisionConstraint CollisionConstraint;
};

// Size: 0xc
struct FHairShadowSettings {
    /* 0x0000 */ float HairShadowDensity;
    /* 0x0004 */ float HairRaytracingRadiusScale;
    /* 0x0008 */ bool bUseHairRaytracingGeometry;
    /* 0x0009 */ bool bVoxelize;
};

// Size: 0x20
struct FHairSimulationConstraints {
    /* 0x0000 */ float BendDamping;
    /* 0x0004 */ float BendStiffness;
    /* 0x0008 */ float StretchDamping;
    /* 0x000c */ float StretchStiffness;
    /* 0x0010 */ float StaticFriction;
    /* 0x0014 */ float KineticFriction;
    /* 0x0018 */ float StrandsViscosity;
    /* 0x001c */ float collisionRadius;
};

// Size: 0x38
struct FHairSimulationForces {
    /* 0x0000 */ FVector GravityVector;
    /* 0x0018 */ float AirDrag;
    /* 0x0020 */ FVector AirVelocity;
};

// Size: 0x90
struct FHairSimulationSettings {
    /* 0x0000 */ bool bOverrideSettings;
    /* 0x0008 */ FHairSimulationSetup SimulationSetup;
    /* 0x0030 */ FHairSimulationSolver SolverSettings;
    /* 0x0038 */ FHairSimulationForces ExternalForces;
    /* 0x0070 */ FHairSimulationConstraints MaterialConstraints;
};

// Size: 0x28
struct FHairSimulationSetup {
    /* 0x0000 */ bool bResetSimulation;
    /* 0x0001 */ bool bDebugSimulation;
    /* 0x0002 */ bool bLocalSimulation;
    /* 0x0004 */ float LinearVelocityScale;
    /* 0x0008 */ float AngularVelocityScale;
    /* 0x0010 */ FString LocalBone;
    /* 0x0020 */ float TeleportDistance;
};

// Size: 0x1
struct FHairSimulationSolver {
    /* 0x0000 */ bool bEnableSimulation;
};

// Size: 0x40
struct FHairSolverSettings {
    /* 0x0000 */ bool bEnableDeformation;
    /* 0x0001 */ bool EnableSimulation;
    /* 0x0002 */ EGroomNiagaraSolvers NiagaraSolver;
    /* 0x0008 */ TSoftObjectPtr<UNiagaraSystem> CustomSystem;
    /* 0x0030 */ float GravityPreloading;
    /* 0x0034 */ int32_t SubSteps;
    /* 0x0038 */ int32_t IterationCount;
    /* 0x003c */ bool bForceVisible;
};

// Size: 0x98
struct FHairStrandsParameters {
    /* 0x0000 */ EGroomStrandsSize StrandsSize;
    /* 0x0004 */ float StrandsDensity;
    /* 0x0008 */ float StrandsSmoothing;
    /* 0x000c */ float StrandsThickness;
    /* 0x0010 */ FRuntimeFloatCurve ThicknessScale;
};

// Size: 0x98
struct FHairStretchConstraint {
    /* 0x0000 */ bool SolveStretch;
    /* 0x0001 */ bool ProjectStretch;
    /* 0x0004 */ float StretchDamping;
    /* 0x0008 */ float StretchStiffness;
    /* 0x0010 */ FRuntimeFloatCurve StretchScale;
};

// Size: 0x20
struct FMovieSceneGroomCacheParams {
    /* 0x0000 */ UGroomCache* GroomCache;
    /* 0x0008 */ FFrameNumber FirstLoopStartFrameOffset;
    /* 0x000c */ FFrameNumber StartFrameOffset;
    /* 0x0010 */ FFrameNumber EndFrameOffset;
    /* 0x0014 */ float PlayRate;
    /* 0x0018 */ bool bReverse;
};

// Size: 0x128
class UMovieSceneGroomCacheSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneGroomCacheParams Params;
};

// Size: 0x48
struct FMovieSceneGroomCacheSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneGroomCacheSectionTemplateParameters Params;
};

// Size: 0x28
struct FMovieSceneGroomCacheSectionTemplateParameters : public FMovieSceneGroomCacheParams {
    /* 0x0020 */ FFrameNumber SectionStartTime;
    /* 0x0024 */ FFrameNumber SectionEndTime;
};

// Size: 0x128
class UMovieSceneGroomCacheTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> AnimationSections;
};

// Size: 0x58
class UNiagaraDataInterfaceHairStrands : public UNiagaraDataInterface {
    /* 0x0040 */ UGroomAsset* DefaultSource;
    /* 0x0048 */ AActor* SourceActor;
};

// Size: 0x48
class UNiagaraDataInterfacePressureGrid : public UNiagaraDataInterfaceVelocityGrid {
};

// Size: 0x48
class UNiagaraDataInterfaceVelocityGrid : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ FIntVector GridSize;
};

enum class EOptimusGroomAttributeTypes {
    None = 0,
    Bool = 1,
    Int = 2,
    IntVector2 = 3,
    IntVector3 = 4,
    IntVector4 = 5,
    Uint = 6,
    Float = 7,
    Vector2 = 8,
    Vector3 = 9,
    Vector4 = 10,
    LinearColor = 11,
    Quat = 12,
    Rotator = 13,
    Transform = 14,
    Matrix3x4 = 15,
    EOptimusGroomAttributeTypes_MAX = 16,
};

enum class EOptimusGroomExecDomain {
    None = 0,
    ControlPoint = 1,
    Curve = 2,
    StrandsEdges = 3,
    StrandsObjects = 4,
    GuidesPoints = 5,
    GuidesCurves = 6,
    GuidesEdges = 7,
    GuidesObjects = 8,
    EOptimusGroomExecDomain_MAX = 9,
};

// Size: 0x28
class UOptimusGroomAssetComponentSource : public UOptimusComponentSource {
};

// Size: 0x48
class UOptimusGroomAttributeReadDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FName GroomAttributeName;
    /* 0x0030 */ EOptimusGroomExecDomain GroomAttributeGroup;
    /* 0x0031 */ EOptimusGroomAttributeTypes GroomAttributeType;
};

// Size: 0x40
class UOptimusGroomAttributeReadDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
    /* 0x0030 */ FName GroomAttributeName;
    /* 0x0038 */ EOptimusGroomExecDomain GroomAttributeGroup;
    /* 0x0039 */ EOptimusGroomAttributeTypes GroomAttributeType;
};

// Size: 0x38
class UOptimusGroomExecDataInterface : public UOptimusComputeDataInterface {
    /* 0x0030 */ EOptimusGroomExecDomain Domain;
};

// Size: 0x38
class UOptimusGroomExecDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
    /* 0x0030 */ EOptimusGroomExecDomain Domain;
};

// Size: 0x28
class UOptimusGroomGuidesReadDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusGroomGuidesReadDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
};

// Size: 0x28
class UOptimusGroomGuidesWriteDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x38
class UOptimusGroomGuidesWriteDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
};

// Size: 0x28
class UOptimusGroomMeshesReadDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusGroomMeshesReadDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
};

// Size: 0x28
class UOptimusGroomSolverComponentSource : public UOptimusComponentSource {
};

// Size: 0x30
class UOptimusGroomSolverReadDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FName ResetSimulationTrigger;
};

// Size: 0x50
class UOptimusGroomSolverReadDataProvider : public UComputeDataProvider {
    /* 0x0030 */ UGroomSolverComponent* SolverComponent;
    /* 0x0038 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x28
class UOptimusGroomStrandsReadDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusGroomStrandsReadDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
};

// Size: 0x28
class UOptimusGroomStrandsWriteDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x38
class UOptimusGroomStrandsWriteDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UMeshComponent* MeshComponent;
};

// Size: 0x348
struct FAddSolverDeformerDataflowNode : public FDataflowSimulationNode {
    /* 0x0280 */ TArray<FDataflowSimulationProperty> PhysicsSolvers;
    /* 0x0290 */ FDataflowSimulationTime SimulationTime;
    /* 0x02a0 */ UOptimusDeformer* MeshDeformer;
    /* 0x02a8 */ TArray<FDataflowNumericTypes> DeformerNumericInputs;
    /* 0x02b8 */ TArray<FDataflowVectorTypes> DeformerVectorInputs;
    /* 0x02c8 */ TArray<FDataflowStringTypes> DeformerStringInputs;
    /* 0x02d8 */ TArray<FDataflowBoolTypes> DeformerBoolInputs;
    /* 0x02e8 */ TArray<FDataflowTransformTypes> DeformerTransformInputs;
    /* 0x02f8 */ TArray<FDataflowNumericArrayTypes> DeformerNumericArrays;
    /* 0x0308 */ TArray<FDataflowVectorArrayTypes> DeformerVectorArrays;
    /* 0x0318 */ TArray<FDataflowStringArrayTypes> DeformerStringArrays;
    /* 0x0328 */ TArray<FDataflowBoolArrayTypes> DeformerBoolArrays;
    /* 0x0338 */ TArray<FDataflowTransformArrayTypes> DeformerTransformArrays;
};

// Size: 0x138
struct FDataflowGroomSolverProxy : public FDataflowPhysicsSolverProxy {
};

// Size: 0x7d0
class UGroomSolverComponent : public UMeshComponent {
    /* 0x0570 */ FGroomSolverSettings SolverSettings;
    /* 0x05d8 */ FDataflowSimulationAsset SimulationAsset;
    /* 0x0630 */ TSet<UGroomComponent*> GroomComponents;
    /* 0x0680 */ UMeshDeformer* MeshDeformer;
    /* 0x0688 */ UMeshDeformerInstance* DeformerInstance;
    /* 0x0690 */ UMeshDeformerInstanceSettings* DeformerSettings;

    void AddGroomComponent(UGroomComponent* GroomComponent);
    void RemoveGroomComponent(UGroomComponent* GroomComponent);
    void ResetGroomComponents();
    void SetDeformerSolver(UMeshDeformer* DeformerSolver);
};

// Size: 0x68
struct FGroomSolverSettings {
    /* 0x0000 */ int32_t NumSubSteps;
    /* 0x0004 */ int32_t NumSolverIterations;
    /* 0x0008 */ float SimulationFrameRate;
    /* 0x000c */ float MaxLODDistance;
    /* 0x0010 */ float MinLODDistance;
};

enum class EHMDTrackingOrigin {
    View = 0,
    LocalFloor = 1,
    Local = 2,
    Stage = 3,
    CustomOpenXR = 4,
    EHMDTrackingOrigin_MAX = 5,
};

enum class EHMDWornState {
    Unknown = 0,
    Worn = 1,
    NotWorn = 2,
    EHMDWornState_MAX = 3,
};

enum class EHandKeypoint {
    Palm = 0,
    Wrist = 1,
    ThumbMetacarpal = 2,
    ThumbProximal = 3,
    ThumbDistal = 4,
    ThumbTip = 5,
    IndexMetacarpal = 6,
    IndexProximal = 7,
    IndexIntermediate = 8,
    IndexDistal = 9,
    IndexTip = 10,
    MiddleMetacarpal = 11,
    MiddleProximal = 12,
    MiddleIntermediate = 13,
    MiddleDistal = 14,
    MiddleTip = 15,
    RingMetacarpal = 16,
    RingProximal = 17,
    RingIntermediate = 18,
    RingDistal = 19,
    RingTip = 20,
    LittleMetacarpal = 21,
    LittleProximal = 22,
    LittleIntermediate = 23,
    LittleDistal = 24,
    LittleTip = 25,
    EHandKeypoint_MAX = 26,
};

enum class EOrientPositionSelector {
    Orientation = 0,
    Position = 1,
    OrientationAndPosition = 2,
    EOrientPositionSelector_MAX = 3,
};

enum class ESpectatorScreenMode {
    Disabled = 0,
    SingleEyeLetterboxed = 1,
    Undistorted = 2,
    Distorted = 3,
    SingleEye = 4,
    SingleEyeCroppedToFill = 5,
    Texture = 6,
    TexturePlusEye = 7,
    ESpectatorScreenMode_MAX = 8,
};

enum class ETrackingStatus {
    NotTracked = 0,
    InertialOnly = 1,
    Tracked = 2,
    ETrackingStatus_MAX = 3,
};

enum class EXRControllerPoseType {
    Aim = 0,
    Grip = 1,
    Palm = 2,
    EXRControllerPoseType_MAX = 3,
};

enum class EXRDeviceConnectionResult {
    NoTrackingSystem = 0,
    FeatureNotSupported = 1,
    NoValidViewport = 2,
    MiscFailure = 3,
    Success = 4,
    EXRDeviceConnectionResult_MAX = 5,
};

enum class EXRSpaceType {
    UnrealWorldSpace = 0,
    XRTrackingSpace = 1,
    EXRSpaceType_MAX = 2,
};

enum class EXRSystemFlags {
    NoFlags = 0,
    IsAR = 1,
    IsTablet = 2,
    IsHeadMounted = 4,
    SupportsHandTracking = 8,
    EXRSystemFlags_MAX = 9,
};

enum class EXRTrackedDeviceType {
    HeadMountedDisplay = 0,
    Controller = 1,
    TrackingReference = 2,
    Tracker = 3,
    Other = 4,
    Invalid = 254,
    Any = 255,
    EXRTrackedDeviceType_MAX = 256,
};

enum class EXRVisualType {
    Controller = 0,
    Hand = 1,
    EXRVisualType_MAX = 2,
};

// Size: 0x28
class UHandKeypointConversion : public UBlueprintFunctionLibrary {

    static int32_t Conv_HandKeypointToInt32(EHandKeypoint Input);
};

// Size: 0x660
class UMotionControllerComponent : public UPrimitiveComponent {
    /* 0x0520 */ int32_t PlayerIndex;
    /* 0x0524 */ FName MotionSource;
    /* 0x052c */ bool bDisableLowLatencyUpdate;
    /* 0x0530 */ ETrackingStatus CurrentTrackingStatus;

    bool GetAngularVelocity(FRotator& OutAngularVelocity) const;
    FVector GetHandJointPosition(int32_t jointIndex, bool& bValueFound);
    bool GetLinearAcceleration(FVector& OutLinearAcceleration) const;
    bool GetLinearVelocity(FVector& OutLinearVelocity) const;
    float GetParameterValue(FName InName, bool& bValueFound);
    EControllerHand GetTrackingSource() const;
    bool IsTracked() const;
    void OnMotionControllerUpdated();
    void SetAssociatedPlayerIndex(const int32_t NewPlayer);
    void SetTrackingMotionSource(const FName NewSource);
    void SetTrackingSource(const EControllerHand NewSource);
};

// Size: 0xc
struct FXRDeviceId {
    /* 0x0000 */ FName SystemName;
    /* 0x0008 */ int32_t DeviceID;
};

// Size: 0x60
struct FXRHMDData {
    /* 0x0000 */ bool bValid;
    /* 0x0004 */ FName DeviceName;
    /* 0x000c */ FGuid ApplicationInstanceID;
    /* 0x001c */ ETrackingStatus TrackingStatus;
    /* 0x0020 */ FVector position;
    /* 0x0040 */ FQuat Rotation;
};

// Size: 0x50
struct FXRHandTrackingState {
    /* 0x0000 */ bool bValid;
    /* 0x0004 */ FName DeviceName;
    /* 0x000c */ FGuid ApplicationInstanceID;
    /* 0x001c */ EXRSpaceType XRSpaceType;
    /* 0x001d */ EControllerHand Hand;
    /* 0x001e */ ETrackingStatus TrackingStatus;
    /* 0x0020 */ TArray<FVector> HandKeyLocations;
    /* 0x0030 */ TArray<FQuat> HandKeyRotations;
    /* 0x0040 */ TArray<float> HandKeyRadii;
};

// Size: 0x120
struct FXRMotionControllerData {
    /* 0x0000 */ bool bValid;
    /* 0x0004 */ FName DeviceName;
    /* 0x000c */ FGuid ApplicationInstanceID;
    /* 0x001c */ EXRVisualType DeviceVisualType;
    /* 0x001d */ EControllerHand HandIndex;
    /* 0x001e */ ETrackingStatus TrackingStatus;
    /* 0x0020 */ FVector GripPosition;
    /* 0x0040 */ FQuat GripRotation;
    /* 0x0060 */ FVector AimPosition;
    /* 0x0080 */ FQuat AimRotation;
    /* 0x00a0 */ FVector PalmPosition;
    /* 0x00c0 */ FQuat PalmRotation;
    /* 0x00e0 */ TArray<FVector> HandKeyPositions;
    /* 0x00f0 */ TArray<FQuat> HandKeyRotations;
    /* 0x0100 */ TArray<float> HandKeyRadii;
    /* 0x0110 */ bool bIsGrasped;
};

// Size: 0xa0
struct FXRMotionControllerState {
    /* 0x0000 */ bool bValid;
    /* 0x0004 */ FName DeviceName;
    /* 0x000c */ FGuid ApplicationInstanceID;
    /* 0x001c */ EXRSpaceType XRSpaceType;
    /* 0x001d */ EControllerHand Hand;
    /* 0x001e */ ETrackingStatus TrackingStatus;
    /* 0x001f */ EXRControllerPoseType XRControllerPoseType;
    /* 0x0020 */ FVector ControllerLocation;
    /* 0x0040 */ FQuat ControllerRotation;
    /* 0x0060 */ FVector GripUnrealSpaceLocation;
    /* 0x0080 */ FQuat GripUnrealSpaceRotation;
};

enum class EHttpReplayResult {
    Success = 0,
    FailedJsonParse = 1,
    DataUnavailable = 2,
    InvalidHttpResponse = 3,
    CompressionFailed = 4,
    DecompressionFailed = 5,
    InvalidPayload = 6,
    Unknown = 7,
    EHttpReplayResult_MAX = 8,
};

// Size: 0x308
struct FAnimNode_IKRig : public FAnimNode_CustomProperty {
    /* 0x0058 */ FPoseLink Source;
    /* 0x0068 */ UIKRigDefinition* RigDefinitionAsset;
    /* 0x0070 */ TArray<FIKRigGoal> goals;
    /* 0x0080 */ bool bStartFromRefPose;
    /* 0x0081 */ EAnimAlphaInputType AlphaInputType;
    /* 0x0082 */ bool bAlphaBoolEnabled;
    /* 0x0084 */ float Alpha;
    /* 0x0088 */ FInputScaleBias AlphaScaleBias;
    /* 0x0090 */ FInputAlphaBoolBlend AlphaBoolBlend;
    /* 0x00d8 */ FName AlphaCurveName;
    /* 0x00e0 */ FInputScaleBiasClamp AlphaScaleBiasClamp;
    /* 0x0238 */ TArray<UActorComponent*> GoalCreators;
};

// Size: 0x3d8
struct FAnimNode_RetargetPoseFromMesh : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink Source;
    /* 0x0020 */ ERetargetSourceMode RetargetFrom;
    /* 0x0024 */ TWeakObjectPtr<USkeletalMeshComponent> SourceMeshComponent;
    /* 0x0030 */ UIKRetargeter* IKRetargeterAsset;
    /* 0x0038 */ FRetargetProfile CustomRetargetProfile;
    /* 0x0160 */ int32_t LODThreshold;
    /* 0x0164 */ int32_t LODThresholdForIK;
    /* 0x0168 */ bool bSuppressWarnings;
    /* 0x0169 */ bool bUseAttachedParent;
};

// Size: 0x30
struct FBoneChain {
    /* 0x0000 */ FName ChainName;
    /* 0x0008 */ FBoneReference StartBone;
    /* 0x0018 */ FBoneReference EndBone;
    /* 0x0028 */ FName IKGoalName;
};

// Size: 0x48
class UCurveRemapOp : public URetargetOpBase {
    /* 0x0030 */ TArray<FCurveRemapPair> CurvesToRemap;
    /* 0x0040 */ bool bCopyAllSourceCurves;
};

// Size: 0x10
struct FCurveRemapPair {
    /* 0x0000 */ FName SourceCurve;
    /* 0x0008 */ FName TargetCurve;
};

enum class EAutoMapChainType {
    Exact = 0,
    Fuzzy = 1,
    Clear = 2,
    EAutoMapChainType_MAX = 3,
};

enum class EBasicAxis {
    X = 0,
    Y = 1,
    Z = 2,
    NegX = 3,
    NegY = 4,
    NegZ = 5,
    EBasicAxis_MAX = 6,
};

enum class ECopyOpSettingsContext {
    PreInitialize = 0,
    Runtime = 1,
    ECopyOpSettingsContext_MAX = 2,
};

enum class EFKChainRotationMode {
    Interpolated = 0,
    OneToOne = 1,
    OneToOneReversed = 2,
    MatchChain = 3,
    MatchScaledChain = 4,
    None = 5,
    EFKChainRotationMode_MAX = 6,
};

enum class EFKChainTranslationMode {
    None = 0,
    GloballyScaled = 1,
    Absolute = 2,
    StretchBoneLengthUniformly = 3,
    StretchBoneLengthNonUniformly = 4,
    EFKChainTranslationMode_MAX = 5,
};

enum class EIKRigGoalSpace {
    Component = 0,
    Additive = 1,
    World = 2,
    EIKRigGoalSpace_MAX = 3,
};

enum class EIKRigGoalTransformSource {
    Manual = 0,
    Bone = 1,
    ActorComponent = 2,
    EIKRigGoalTransformSource_MAX = 3,
};

enum class EPinBoneRotationMode {
    CopyGlobalRotation = 0,
    MaintainOffsetFromBoneToCopyFrom = 1,
    EPinBoneRotationMode_MAX = 2,
};

enum class EPinBoneTranslationMode {
    CopyGlobalPosition = 0,
    CopyLocalPosition = 1,
    CopyLocalPositionRelativeOffset = 2,
    CopyLocalPositionRelativeScaled = 3,
    CopyGlobalPositionAndMaintainOffset = 4,
    EPinBoneTranslationMode_MAX = 5,
};

enum class EPinBoneType {
    FullTransform = 0,
    TranslateOnly = 1,
    RotateOnly = 2,
    ScaleOnly = 3,
    EPinBoneType_MAX = 4,
};

enum class ERetargetRotationMode {
    Interpolated = 0,
    OneToOne = 1,
    OneToOneReversed = 2,
    MatchChain = 3,
    MatchScaledChain = 4,
    None = 5,
    ERetargetRotationMode_MAX = 6,
};

enum class ERetargetSourceMode {
    ParentSkeletalMeshComponent = 0,
    CustomSkeletalMeshComponent = 1,
    SourcePosePin = 2,
    ERetargetSourceMode_MAX = 3,
};

enum class ERetargetSourceOrTarget {
    Source = 0,
    Target = 1,
    ERetargetSourceOrTarget_MAX = 2,
};

enum class ERetargetTranslationMode {
    None = 0,
    GloballyScaled = 1,
    Absolute = 2,
    StretchBoneLengthUniformly = 3,
    StretchBoneLengthNonUniformly = 4,
    ERetargetTranslationMode_MAX = 5,
};

enum class ERootMotionHeightSource {
    CopyHeightFromSource = 0,
    SnapToGround = 1,
    ERootMotionHeightSource_MAX = 2,
};

enum class ERootMotionSource {
    CopyFromSourceRoot = 0,
    GenerateFromTargetPelvis = 1,
    ERootMotionSource_MAX = 2,
};

enum class EWarpingDirectionSource {
    Goals = 0,
    Chain = 1,
    RootBone = 2,
    EWarpingDirectionSource_MAX = 3,
};

// Size: 0x10
struct FGoalBone {
};

// Size: 0x28
class IIKGoalCreatorInterface : public UInterface {

    void AddIKGoals(TMap<FName, FIKRigGoal>& OutGoals);
};

// Size: 0x30
class UIKRetargetAdditivePoseController : public UIKRetargetOpControllerBase {

    FIKRetargetAdditivePoseOpSettings GetSettings();
    void SetSettings(FIKRetargetAdditivePoseOpSettings InSettings);
};

// Size: 0x48
struct FIKRetargetAdditivePoseOp : public FIKRetargetOpBase {
    /* 0x0028 */ FIKRetargetAdditivePoseOpSettings Settings;
};

// Size: 0x20
struct FIKRetargetAdditivePoseOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ FName PoseToApply;
    /* 0x0018 */ float Alpha;
};

// Size: 0x30
class UIKRetargetAlignPoleVectorController : public UIKRetargetOpControllerBase {

    FIKRetargetAlignPoleVectorOpSettings GetSettings();
    void SetSettings(FIKRetargetAlignPoleVectorOpSettings InSettings);
};

// Size: 0x78
struct FIKRetargetAlignPoleVectorOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetAlignPoleVectorOpSettings Settings;
    /* 0x0048 */ FRetargetChainMapping ChainMapping;
};

// Size: 0x28
struct FIKRetargetAlignPoleVectorOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ UIKRigDefinition* IKRigAsset;
    /* 0x0018 */ TArray<FRetargetPoleVectorSettings> ChainsToAlign;
};

// Size: 0x30
class UIKRetargetCopyBasePoseController : public UIKRetargetOpControllerBase {

    FIKRetargetCopyBasePoseOpSettings GetSettings();
    void SetSettings(FIKRetargetCopyBasePoseOpSettings InSettings);
};

// Size: 0x40
struct FIKRetargetCopyBasePoseOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetCopyBasePoseOpSettings Settings;
};

// Size: 0x20
struct FIKRetargetCopyBasePoseOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ bool bCopyBasePose;
    /* 0x0014 */ FName CopyBasePoseRoot;
};

// Size: 0x30
class UIKRetargetCurveRemapController : public UIKRetargetOpControllerBase {

    FIKRetargetCurveRemapOpSettings GetSettings();
    void SetSettings(FIKRetargetCurveRemapOpSettings InSettings);
};

// Size: 0x68
struct FIKRetargetCurveRemapOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetCurveRemapOpSettings Settings;
};

// Size: 0x28
struct FIKRetargetCurveRemapOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ bool bCopyAllSourceCurves;
    /* 0x0011 */ bool bRemapCurves;
    /* 0x0018 */ TArray<FCurveRemapPair> CurvesToRemap;
};

// Size: 0x30
class UIKRetargetFKChainsController : public UIKRetargetOpControllerBase {

    FIKRetargetFKChainsOpSettings GetSettings();
    void SetSettings(FIKRetargetFKChainsOpSettings InSettings);
};

// Size: 0xb0
struct FIKRetargetFKChainsOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetFKChainsOpSettings Settings;
    /* 0x0060 */ FRetargetChainMapping ChainMapping;
};

// Size: 0x40
struct FIKRetargetFKChainsOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ UIKRigDefinition* IKRigAsset;
    /* 0x0018 */ TArray<FRetargetFKChainSettings> ChainsToRetarget;
    /* 0x0028 */ bool bDrawChainLines;
    /* 0x0029 */ bool bDrawSingleBoneChains;
    /* 0x0030 */ double ChainDrawThickness;
    /* 0x0038 */ double ChainDrawSize;
};

// Size: 0x60
class UIKRetargetGlobalSettings : public UObject {
    /* 0x0028 */ FRetargetGlobalSettings Settings;
};

// Size: 0x30
class UIKRetargetIKChainsController : public UIKRetargetOpControllerBase {

    FIKRetargetIKChainsOpSettings GetSettings();
    void SetSettings(FIKRetargetIKChainsOpSettings InSettings);
};

// Size: 0x68
struct FIKRetargetIKChainsOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetIKChainsOpSettings Settings;
};

// Size: 0x38
struct FIKRetargetIKChainsOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ TArray<FRetargetIKChainSettings> ChainsToRetarget;
    /* 0x0020 */ bool bDrawFinalGoals;
    /* 0x0021 */ bool bDrawSourceLocations;
    /* 0x0028 */ double GoalDrawSize;
    /* 0x0030 */ double GoalDrawThickness;
};

// Size: 0x20
struct FIKRetargetOpBase {
    /* 0x0008 */ bool bIsEnabled;
    /* 0x000c */ FName Name;
    /* 0x0014 */ FName ParentOpName;
};

// Size: 0x30
class UIKRetargetOpControllerBase : public UObject {
};

// Size: 0x10
struct FIKRetargetOpSettingsBase {
};

// Size: 0x30
class UIKRetargetPelvisMotionController : public UIKRetargetOpControllerBase {

    FIKRetargetPelvisMotionOpSettings GetSettings();
    FName GetSourcePelvisBone();
    FName GetTargetPelvisBone();
    void SetSettings(FIKRetargetPelvisMotionOpSettings InSettings);
    void SetSourcePelvisBone(const FName InSourcePelvisBone);
    void SetTargetPelvisBone(const FName InTargetPelvisBone);
};

// Size: 0x240
struct FIKRetargetPelvisMotionOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetPelvisMotionOpSettings Settings;
};

// Size: 0xc8
struct FIKRetargetPelvisMotionOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ FBoneReference SourcePelvisBone;
    /* 0x0020 */ FBoneReference TargetPelvisBone;
    /* 0x0030 */ double RotationAlpha;
    /* 0x0038 */ FRotator RotationOffset;
    /* 0x0050 */ double TranslationAlpha;
    /* 0x0058 */ FVector TranslationOffset;
    /* 0x0070 */ double BlendToSourceTranslation;
    /* 0x0078 */ FVector BlendToSourceTranslationWeights;
    /* 0x0090 */ double ScaleHorizontal;
    /* 0x0098 */ double ScaleVertical;
    /* 0x00a0 */ double AffectIKHorizontal;
    /* 0x00a8 */ double AffectIKVertical;
    /* 0x00b0 */ bool bEnableDebugDraw;
    /* 0x00b8 */ double DebugDrawSize;
    /* 0x00c0 */ double DebugDrawThickness;
};

// Size: 0x30
class UIKRetargetPinBoneController : public UIKRetargetOpControllerBase {

    void ClearAllBonePairs();
    TMap<FName, FName> GetAllBonePairs();
    FIKRetargetPinBoneOpSettings GetSettings();
    void SetBonePair(const FName InBoneToCopyFrom, const FName InBoneToCopyTo);
    void SetSettings(FIKRetargetPinBoneOpSettings InSettings);
};

// Size: 0x120
struct FIKRetargetPinBoneOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetPinBoneOpSettings Settings;
};

// Size: 0xf0
struct FIKRetargetPinBoneOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ TArray<FPinBoneData> BonesToPin;
    /* 0x0020 */ ERetargetSourceOrTarget SkeletonToCopyFrom;
    /* 0x0021 */ bool bCopyTranslation;
    /* 0x0022 */ EPinBoneTranslationMode TranslationMode;
    /* 0x0023 */ bool bCopyRotation;
    /* 0x0024 */ EPinBoneRotationMode RotationMode;
    /* 0x0025 */ bool bCopyScale;
    /* 0x0026 */ bool bPropagateToChildren;
    /* 0x0030 */ FTransform GlobalOffset;
    /* 0x0090 */ FTransform LocalOffset;
};

// Size: 0x70
struct FIKRetargetPose {
    /* 0x0000 */ FVector RootTranslationOffset;
    /* 0x0018 */ TMap<FName, FQuat> BoneRotationOffsets;
};

// Size: 0x2d8
class UIKRetargetProcessor : public UObject {
};

// Size: 0x30
class UIKRetargetRootMotionController : public UIKRetargetOpControllerBase {

    FIKRetargetRootMotionOpSettings GetSettings();
    FName GetSourceRootBone();
    FName GetTargetPelvisBone();
    FName GetTargetRootBone();
    void SetSettings(FIKRetargetRootMotionOpSettings InSettings);
    void SetSourceRootBone(const FName InSourceRootBone);
    void SetTargetPelvisBone(const FName InTargetPelvisBone);
    void SetTargetRootBone(const FName InTargetRootBone);
};

// Size: 0x280
struct FIKRetargetRootMotionOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetRootMotionOpSettings Settings;
};

// Size: 0xc0
struct FIKRetargetRootMotionOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ FBoneReference SourceRoot;
    /* 0x0020 */ FBoneReference TargetRoot;
    /* 0x0030 */ ERootMotionSource RootMotionSource;
    /* 0x0034 */ FBoneReference TargetPelvis;
    /* 0x0044 */ bool bRotateWithPelvis;
    /* 0x0045 */ ERootMotionHeightSource RootHeightSource;
    /* 0x0050 */ FTransform GlobalOffset;
    /* 0x00b0 */ bool bMaintainOffsetFromPelvis;
    /* 0x00b1 */ bool bPropagateToNonRetargetedChildren;
};

// Size: 0x30
class UIKRetargetRunIKRigController : public UIKRetargetOpControllerBase {

    FIKRetargetRunIKRigOpSettings GetSettings();
    void SetSettings(FIKRetargetRunIKRigOpSettings InSettings);
};

// Size: 0x1a8
struct FIKRetargetRunIKRigOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetRunIKRigOpSettings Settings;
    /* 0x0060 */ FRetargetChainMapping ChainMapping;
};

// Size: 0x40
struct FIKRetargetRunIKRigOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ UIKRigDefinition* IKRigAsset;
    /* 0x0018 */ TArray<FName> ExcludedGoals;
    /* 0x0028 */ bool bDrawGoals;
    /* 0x0029 */ bool bDrawGoalBoneLocations;
    /* 0x0030 */ double GoalDrawSize;
    /* 0x0038 */ double GoalDrawThickness;
};

// Size: 0x30
class UIKRetargetScaleSourceController : public UIKRetargetOpControllerBase {

    FIKRetargetScaleSourceOpSettings GetSettings();
    void SetSettings(FIKRetargetScaleSourceOpSettings InSettings);
};

// Size: 0x38
struct FIKRetargetScaleSourceOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetScaleSourceOpSettings Settings;
};

// Size: 0x18
struct FIKRetargetScaleSourceOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ double SourceScaleFactor;
};

// Size: 0x30
class UIKRetargetSpeedPlantingController : public UIKRetargetOpControllerBase {

    FIKRetargetSpeedPlantingOpSettings GetSettings();
    void SetSettings(FIKRetargetSpeedPlantingOpSettings InSettings);
};

// Size: 0x70
struct FIKRetargetSpeedPlantingOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetSpeedPlantingOpSettings Settings;
};

// Size: 0x38
struct FIKRetargetSpeedPlantingOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ TArray<FRetargetSpeedPlantingSettings> ChainsToSpeedPlant;
    /* 0x0020 */ double SpeedThreshold;
    /* 0x0028 */ double Stiffness;
    /* 0x0030 */ double CriticalDamping;
};

// Size: 0x30
class UIKRetargetStrideWarpingController : public UIKRetargetOpControllerBase {

    FIKRetargetStrideWarpingOpSettings GetSettings();
    void SetSettings(FIKRetargetStrideWarpingOpSettings InSettings);
};

// Size: 0x98
struct FIKRetargetStrideWarpingOp : public FIKRetargetOpBase {
    /* 0x0020 */ FIKRetargetStrideWarpingOpSettings Settings;
};

// Size: 0x60
struct FIKRetargetStrideWarpingOpSettings : public FIKRetargetOpSettingsBase {
    /* 0x0010 */ TArray<FRetargetStrideWarpChainSettings> ChainSettings;
    /* 0x0020 */ EWarpingDirectionSource DirectionSource;
    /* 0x0024 */ EBasicAxis ForwardDirection;
    /* 0x0028 */ FName DirectionChain;
    /* 0x0030 */ double WarpForwards;
    /* 0x0038 */ double SidewaysOffset;
    /* 0x0040 */ double WarpSplay;
    /* 0x0048 */ bool bEnableDebugDraw;
    /* 0x0050 */ double DebugDrawSize;
    /* 0x0058 */ double DebugDrawThickness;
};

// Size: 0x208
class UIKRetargeter : public UObject {
    /* 0x0028 */ int32_t Version;
    /* 0x0030 */ UIKRigDefinition* SourceIKRigAsset;
    /* 0x0038 */ UIKRigDefinition* TargetIKRigAsset;
    /* 0x0040 */ TArray<FInstancedStruct> RetargetOps;
    /* 0x0050 */ TMap<FName, FRetargetProfile> Profiles;
    /* 0x00a0 */ FName CurrentProfile;
    /* 0x00a8 */ TMap<FName, FIKRetargetPose> SourceRetargetPoses;
    /* 0x00f8 */ TMap<FName, FIKRetargetPose> TargetRetargetPoses;
    /* 0x0148 */ FName CurrentSourceRetargetPose;
    /* 0x0150 */ FName CurrentTargetRetargetPose;
    /* 0x0158 */ bool bRetargetRoot;
    /* 0x0159 */ bool bRetargetFK;
    /* 0x015a */ bool bRetargetIK;
    /* 0x015c */ float TargetActorOffset;
    /* 0x0160 */ float TargetActorScale;
    /* 0x0168 */ TMap<FName, FIKRetargetPose> RetargetPoses;
    /* 0x01b8 */ FName CurrentRetargetPose;
    /* 0x01c0 */ FRetargetChainMapping ChainMap;
    /* 0x01e0 */ TArray<URetargetChainSettings*> ChainSettings;
    /* 0x01f0 */ URetargetRootSettings* RootSettings;
    /* 0x01f8 */ UIKRetargetGlobalSettings* GlobalSettings;
    /* 0x0200 */ URetargetOpStack* OpStack;

    static FTargetChainSettings GetChainSettingsFromRetargetAsset(const UIKRetargeter* RetargetAsset, const FName TargetChainName, const FName OptionalProfileName);
    static FTargetChainSettings GetChainSettingsFromRetargetProfile(FRetargetProfile& RetargetProfile, const FName TargetChainName);
    static FTargetChainSettings GetChainUsingGoalFromRetargetAsset(const UIKRetargeter* RetargetAsset, const FName IKGoalName);
    static void GetGlobalSettingsFromRetargetAsset(const UIKRetargeter* RetargetAsset, const FName OptionalProfileName, FRetargetGlobalSettings& OutSettings);
    static FRetargetGlobalSettings GetGlobalSettingsFromRetargetProfile(FRetargetProfile& RetargetProfile);
    static void GetRootSettingsFromRetargetAsset(const UIKRetargeter* RetargetAsset, const FName OptionalProfileName, FTargetRootSettings& OutSettings);
    static FTargetRootSettings GetRootSettingsFromRetargetProfile(FRetargetProfile& RetargetProfile);
    bool HasSourceIKRig() const;
    bool HasTargetIKRig() const;
    static void SetChainFKSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FTargetChainFKSettings& FKSettings, const FName TargetChainName);
    static void SetChainIKSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FTargetChainIKSettings& IKSettings, const FName TargetChainName);
    static void SetChainSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FTargetChainSettings& ChainSettings, const FName TargetChainName);
    static void SetChainSpeedPlantSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FTargetChainSpeedPlantSettings& SpeedPlantSettings, const FName TargetChainName);
    static void SetGlobalSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FRetargetGlobalSettings& GlobalSettings);
    static void SetRootSettingsInRetargetProfile(FRetargetProfile& RetargetProfile, const FTargetRootSettings& RootSettings);
};

// Size: 0x30
class UIKRigBodyMoverController : public UIKRigSolverControllerBase {

    FIKRigBodyMoverGoalSettings GetGoalSettings(const FName InGoalName);
    FIKRigBodyMoverSettings GetSolverSettings();
    void SetGoalSettings(const FName InGoalName, FIKRigBodyMoverGoalSettings InSettings);
    void SetSolverSettings(FIKRigBodyMoverSettings InSettings);
};

// Size: 0x20
struct FIKRigBodyMoverGoalSettings : public FIKRigGoalSettingsBase {
    /* 0x0010 */ FName BoneName;
    /* 0x0018 */ float InfluenceMultiplier;
};

// Size: 0x40
struct FIKRigBodyMoverSettings : public FIKRigSolverSettingsBase {
    /* 0x0008 */ FName StartBone;
    /* 0x0010 */ float PositionAlpha;
    /* 0x0014 */ float PositionPositiveX;
    /* 0x0018 */ float PositionNegativeX;
    /* 0x001c */ float PositionPositiveY;
    /* 0x0020 */ float PositionNegativeY;
    /* 0x0024 */ float PositionPositiveZ;
    /* 0x0028 */ float PositionNegativeZ;
    /* 0x002c */ float RotationAlpha;
    /* 0x0030 */ float RotateXAlpha;
    /* 0x0034 */ float RotateYAlpha;
    /* 0x0038 */ float RotateZAlpha;
};

// Size: 0x68
struct FIKRigBodyMoverSolver : public FIKRigSolverBase {
    /* 0x0010 */ FIKRigBodyMoverSettings Settings;
    /* 0x0050 */ TArray<FIKRigBodyMoverGoalSettings> AllGoalSettings;
};

// Size: 0x10
struct FIKRigBoneSettingsBase : public FIKRigSettingsBase {
    /* 0x0008 */ FName bone;
};

// Size: 0xd8
class UIKRigComponent : public UActorComponent {

    void ClearAllGoals();
    void SetIKRigGoal(const FIKRigGoal& Goal);
    void SetIKRigGoalPositionAndRotation(const FName GoalName, const FVector position, const FQuat Rotation, const float PositionAlpha, const float RotationAlpha);
    void SetIKRigGoalTransform(const FName GoalName, const FTransform Transform, const float PositionAlpha, const float RotationAlpha);
};

// Size: 0x110
class UIKRigDefinition : public UObject {
    /* 0x0030 */ TSoftObjectPtr<USkeletalMesh> PreviewSkeletalMesh;
    /* 0x0058 */ FIKRigSkeleton Skeleton;
    /* 0x00c8 */ TArray<UIKRigEffectorGoal*> goals;
    /* 0x00d8 */ TArray<FInstancedStruct> SolverStack;
    /* 0x00e8 */ FRetargetDefinition RetargetDefinition;
    /* 0x0100 */ TArray<UIKRigSolver*> Solvers;
};

// Size: 0x100
class UIKRigEffectorGoal : public UObject {
    /* 0x0028 */ FName GoalName;
    /* 0x0030 */ FName BoneName;
    /* 0x0038 */ float PositionAlpha;
    /* 0x003c */ float RotationAlpha;
    /* 0x0040 */ FTransform CurrentTransform;
    /* 0x00a0 */ FTransform InitialTransform;
};

// Size: 0x58
struct FIKRigFBIKBoneSettings : public FIKRigBoneSettingsBase {
    /* 0x0010 */ float RotationStiffness;
    /* 0x0014 */ float PositionStiffness;
    /* 0x0018 */ EPBIKLimitType X;
    /* 0x001c */ float MinX;
    /* 0x0020 */ float MaxX;
    /* 0x0024 */ EPBIKLimitType Y;
    /* 0x0028 */ float MinY;
    /* 0x002c */ float MaxY;
    /* 0x0030 */ EPBIKLimitType Z;
    /* 0x0034 */ float minZ;
    /* 0x0038 */ float MaxZ;
    /* 0x003c */ bool bUsePreferredAngles;
    /* 0x0040 */ FVector PreferredAngles;
};

// Size: 0x30
class UIKRigFBIKController : public UIKRigSolverControllerBase {

    FIKRigFBIKBoneSettings GetBoneSettings(const FName InBoneName);
    FIKRigFBIKGoalSettings GetGoalSettings(const FName InGoalName);
    FIKRigFBIKSettings GetSolverSettings();
    void SetBoneSettings(const FName InBoneName, FIKRigFBIKBoneSettings InSettings);
    void SetGoalSettings(const FName InGoalName, FIKRigFBIKGoalSettings InSettings);
    void SetSolverSettings(FIKRigFBIKSettings InSettings);
};

// Size: 0x30
struct FIKRigFBIKGoalSettings : public FIKRigGoalSettingsBase {
    /* 0x0010 */ FName BoneName;
    /* 0x0018 */ int32_t ChainDepth;
    /* 0x001c */ float StrengthAlpha;
    /* 0x0020 */ float PullChainAlpha;
    /* 0x0024 */ float PinRotation;
    /* 0x0028 */ int32_t IndexInSolver;
};

// Size: 0x50
struct FIKRigFBIKSettings : public FIKRigSolverSettingsBase {
    /* 0x0008 */ FName RootBone;
    /* 0x0010 */ int32_t Iterations;
    /* 0x0014 */ int32_t SubIterations;
    /* 0x0018 */ float MassMultiplier;
    /* 0x001c */ bool bAllowStretch;
    /* 0x001d */ EPBIKRootBehavior RootBehavior;
    /* 0x0020 */ FRootPrePullSettings PrePullRootSettings;
    /* 0x0040 */ float GlobalPullChainAlpha;
    /* 0x0044 */ float maxAngle;
    /* 0x0048 */ float OverRelaxation;
};

// Size: 0x98
class UIKRigFBIKSolver : public UIKRigSolver {
    /* 0x0030 */ FName RootBone;
    /* 0x0038 */ int32_t Iterations;
    /* 0x003c */ int32_t SubIterations;
    /* 0x0040 */ float MassMultiplier;
    /* 0x0044 */ bool bAllowStretch;
    /* 0x0045 */ EPBIKRootBehavior RootBehavior;
    /* 0x0048 */ FRootPrePullSettings PrePullRootSettings;
    /* 0x0068 */ float PullChainAlpha;
    /* 0x006c */ float maxAngle;
    /* 0x0070 */ float OverRelaxation;
    /* 0x0078 */ TArray<UIKRig_FBIKEffector*> Effectors;
    /* 0x0088 */ TArray<UIKRig_FBIKBoneSettings*> BoneSettings;

    TArray<UIKRig_FBIKBoneSettings*> GetBoneSettings();
    TArray<UIKRig_FBIKEffector*> GetEffectors();
};

// Size: 0xd8
struct FIKRigFullBodyIKSolver : public FIKRigSolverBase {
    /* 0x0010 */ FIKRigFBIKSettings Settings;
    /* 0x0060 */ TArray<FIKRigFBIKGoalSettings> AllGoalSettings;
    /* 0x0070 */ TArray<FIKRigFBIKBoneSettings> AllBoneSettings;
};

// Size: 0xb0
struct FIKRigGoal {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName BoneName;
    /* 0x0010 */ EIKRigGoalTransformSource TransformSource;
    /* 0x0014 */ FBoneReference SourceBone;
    /* 0x0028 */ FVector position;
    /* 0x0040 */ FRotator Rotation;
    /* 0x0058 */ float PositionAlpha;
    /* 0x005c */ float RotationAlpha;
    /* 0x0060 */ EIKRigGoalSpace PositionSpace;
    /* 0x0061 */ EIKRigGoalSpace RotationSpace;
    /* 0x0068 */ FVector FinalBlendedPosition;
    /* 0x0080 */ FQuat FinalBlendedRotation;
    /* 0x00a0 */ bool bEnabled;
};

// Size: 0x18
struct FIKRigGoalContainer {
};

// Size: 0x10
struct FIKRigGoalSettingsBase : public FIKRigSettingsBase {
    /* 0x0008 */ FName Goal;
};

// Size: 0x38
struct FIKRigInputSkeleton {
};

// Size: 0x80
struct FIKRigLimbSolver : public FIKRigSolverBase {
    /* 0x0010 */ FIKRigLimbSolverSettings Settings;
};

// Size: 0x30
class UIKRigLimbSolverController : public UIKRigSolverControllerBase {

    FIKRigLimbSolverSettings GetSolverSettings();
    void SetSolverSettings(FIKRigLimbSolverSettings InSettings);
};

// Size: 0x48
struct FIKRigLimbSolverSettings : public FLimbSolverSettings {
    /* 0x0030 */ FName StartBone;
    /* 0x0038 */ FName GoalName;
    /* 0x0040 */ FName EndBone;
};

// Size: 0x58
struct FIKRigPoleSolver : public FIKRigSolverBase {
    /* 0x0010 */ FIKRigPoleSolverSettings Settings;
};

// Size: 0x30
class UIKRigPoleSolverController : public UIKRigSolverControllerBase {

    FIKRigPoleSolverSettings GetSolverSettings();
    void SetSolverSettings(FIKRigPoleSolverSettings InSettings);
};

// Size: 0x28
struct FIKRigPoleSolverSettings : public FIKRigSolverSettingsBase {
    /* 0x0008 */ FName StartBone;
    /* 0x0010 */ FName EndBone;
    /* 0x0018 */ FName AimAtGoal;
    /* 0x0020 */ float Alpha;
};

// Size: 0x188
class UIKRigProcessor : public UObject {
};

// Size: 0x40
struct FIKRigSetTransform : public FIKRigSolverBase {
    /* 0x0010 */ FIKRigSetTransformSettings Settings;
};

// Size: 0x30
class UIKRigSetTransformController : public UIKRigSolverControllerBase {

    FIKRigSetTransformSettings GetSolverSettings();
    void SetSolverSettings(FIKRigSetTransformSettings InSettings);
};

// Size: 0x28
struct FIKRigSetTransformSettings : public FIKRigSolverSettingsBase {
    /* 0x0008 */ FName Goal;
    /* 0x0010 */ FName BoneToAffect;
    /* 0x0018 */ float PositionAlpha;
    /* 0x001c */ float RotationAlpha;
    /* 0x0020 */ float Alpha;
    /* 0x0024 */ bool bPropagateToChildren;
};

// Size: 0x8
struct FIKRigSettingsBase {
};

// Size: 0x70
struct FIKRigSkeleton {
    /* 0x0000 */ TArray<FName> BoneNames;
    /* 0x0010 */ TArray<int32_t> ParentIndices;
    /* 0x0020 */ TArray<FName> ExcludedBones;
    /* 0x0030 */ TArray<FTransform> CurrentPoseGlobal;
    /* 0x0040 */ TArray<FTransform> CurrentPoseLocal;
    /* 0x0050 */ TArray<FTransform> RefPoseGlobal;
};

// Size: 0x30
class UIKRigSolver : public UObject {
    /* 0x0028 */ bool bIsEnabled;
};

// Size: 0x10
struct FIKRigSolverBase {
    /* 0x0008 */ bool bIsEnabled;
};

// Size: 0x30
class UIKRigSolverControllerBase : public UObject {

    bool GetEnabled();
    void SetEnabled(bool bIsEnabled);
};

// Size: 0x8
struct FIKRigSolverSettingsBase : public FIKRigSettingsBase {
};

// Size: 0x78
class UIKRig_BodyMover : public UIKRigSolver {
    /* 0x0030 */ FName RootBone;
    /* 0x0038 */ float PositionAlpha;
    /* 0x003c */ float PositionPositiveX;
    /* 0x0040 */ float PositionNegativeX;
    /* 0x0044 */ float PositionPositiveY;
    /* 0x0048 */ float PositionNegativeY;
    /* 0x004c */ float PositionPositiveZ;
    /* 0x0050 */ float PositionNegativeZ;
    /* 0x0054 */ float RotationAlpha;
    /* 0x0058 */ float RotateXAlpha;
    /* 0x005c */ float RotateYAlpha;
    /* 0x0060 */ float RotateZAlpha;
    /* 0x0068 */ TArray<UIKRig_BodyMoverEffector*> Effectors;
};

// Size: 0x40
class UIKRig_BodyMoverEffector : public UObject {
    /* 0x0028 */ FName GoalName;
    /* 0x0030 */ FName BoneName;
    /* 0x0038 */ float InfluenceMultiplier;
};

// Size: 0x78
class UIKRig_FBIKBoneSettings : public UObject {
    /* 0x0028 */ FName bone;
    /* 0x0030 */ float RotationStiffness;
    /* 0x0034 */ float PositionStiffness;
    /* 0x0038 */ EPBIKLimitType X;
    /* 0x003c */ float MinX;
    /* 0x0040 */ float MaxX;
    /* 0x0044 */ EPBIKLimitType Y;
    /* 0x0048 */ float MinY;
    /* 0x004c */ float MaxY;
    /* 0x0050 */ EPBIKLimitType Z;
    /* 0x0054 */ float minZ;
    /* 0x0058 */ float MaxZ;
    /* 0x005c */ bool bUsePreferredAngles;
    /* 0x0060 */ FVector PreferredAngles;
};

// Size: 0x48
class UIKRig_FBIKEffector : public UObject {
    /* 0x0028 */ FName GoalName;
    /* 0x0030 */ FName BoneName;
    /* 0x0038 */ int32_t ChainDepth;
    /* 0x003c */ float StrengthAlpha;
    /* 0x0040 */ float PullChainAlpha;
    /* 0x0044 */ float PinRotation;
};

// Size: 0x38
class UIKRig_LimbEffector : public UObject {
    /* 0x0028 */ FName GoalName;
    /* 0x0030 */ FName BoneName;
};

// Size: 0x68
class UIKRig_LimbSolver : public UIKRigSolver {
    /* 0x0030 */ FName RootName;
    /* 0x0038 */ float ReachPrecision;
    /* 0x003c */ uint8_t HingeRotationAxis;
    /* 0x0040 */ int32_t MaxIterations;
    /* 0x0044 */ bool bEnableLimit;
    /* 0x0048 */ float MinRotationAngle;
    /* 0x004c */ bool bAveragePull;
    /* 0x0050 */ float PullDistribution;
    /* 0x0054 */ float ReachStepAlpha;
    /* 0x0058 */ bool bEnableTwistCorrection;
    /* 0x0059 */ uint8_t EndBoneForwardAxis;
    /* 0x0060 */ UIKRig_LimbEffector* Effector;
};

// Size: 0x48
class UIKRig_PoleSolver : public UIKRigSolver {
    /* 0x0030 */ FName RootName;
    /* 0x0038 */ FName EndName;
    /* 0x0040 */ UIKRig_PoleSolverEffector* Effector;
};

// Size: 0x40
class UIKRig_PoleSolverEffector : public UObject {
    /* 0x0028 */ FName GoalName;
    /* 0x0030 */ FName BoneName;
    /* 0x0038 */ float Alpha;
};

// Size: 0x48
class UIKRig_SetTransform : public UIKRigSolver {
    /* 0x0030 */ FName Goal;
    /* 0x0038 */ FName RootBone;
    /* 0x0040 */ UIKRig_SetTransformEffector* Effector;
};

// Size: 0x30
class UIKRig_SetTransformEffector : public UObject {
    /* 0x0028 */ bool bEnablePosition;
    /* 0x0029 */ bool bEnableRotation;
    /* 0x002c */ float Alpha;
};

// Size: 0x68
struct FLimbLink {
};

// Size: 0x18
struct FLimbSolver {
};

// Size: 0x30
struct FLimbSolverSettings : public FIKRigSolverSettingsBase {
    /* 0x0008 */ float ReachPrecision;
    /* 0x000c */ uint8_t HingeRotationAxis;
    /* 0x0010 */ int32_t MaxIterations;
    /* 0x0014 */ bool bEnableLimit;
    /* 0x0018 */ float MinRotationAngle;
    /* 0x001c */ bool bAveragePull;
    /* 0x0020 */ float PullDistribution;
    /* 0x0024 */ float ReachStepAlpha;
    /* 0x0028 */ bool bEnableTwistCorrection;
    /* 0x0029 */ uint8_t EndBoneForwardAxis;
};

// Size: 0x160
struct FPinBoneData {
    /* 0x0000 */ FBoneReference BoneToCopyFrom;
    /* 0x0010 */ FBoneReference BoneToCopyTo;
    /* 0x0150 */ FName BoneToPin;
    /* 0x0158 */ FName BoneToPinTo;
};

// Size: 0x120
class UPinBoneOp : public URetargetOpBase {
    /* 0x0030 */ TArray<FPinBoneData> BonesToPin;
    /* 0x0040 */ ERetargetSourceOrTarget PinTo;
    /* 0x0041 */ bool bCopyTranslation;
    /* 0x0042 */ bool bCopyRotation;
    /* 0x0043 */ bool bCopyScale;
    /* 0x0044 */ EPinBoneTranslationMode TranslationMode;
    /* 0x0045 */ EPinBoneRotationMode RotationMode;
    /* 0x0050 */ FTransform GlobalOffset;
    /* 0x00b0 */ FTransform LocalOffset;
    /* 0x0110 */ bool bMaintainOffset;
    /* 0x0111 */ EPinBoneType PinType;
};

// Size: 0x20
struct FRetargetChainMapping {
    /* 0x0000 */ TArray<FRetargetChainPair> ChainMap;
    /* 0x0010 */ UIKRigDefinition* SourceIKRig;
    /* 0x0018 */ UIKRigDefinition* TargetIKRig;
};

// Size: 0x10
struct FRetargetChainPair {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ FName SourceChainName;
};

// Size: 0x188
class URetargetChainSettings : public UObject {
    /* 0x0028 */ FName SourceChain;
    /* 0x0030 */ FName TargetChain;
    /* 0x0038 */ FTargetChainSettings Settings;
    /* 0x00f0 */ bool CopyPoseUsingFK;
    /* 0x00f1 */ ERetargetRotationMode RotationMode;
    /* 0x00f4 */ float RotationAlpha;
    /* 0x00f8 */ ERetargetTranslationMode TranslationMode;
    /* 0x00fc */ float TranslationAlpha;
    /* 0x0100 */ bool DriveIKGoal;
    /* 0x0104 */ float BlendToSource;
    /* 0x0108 */ FVector BlendToSourceWeights;
    /* 0x0120 */ FVector StaticOffset;
    /* 0x0138 */ FVector StaticLocalOffset;
    /* 0x0150 */ FRotator StaticRotationOffset;
    /* 0x0168 */ float Extension;
    /* 0x016c */ bool UseSpeedCurveToPlantIK;
    /* 0x0170 */ FName SpeedCurveName;
    /* 0x0178 */ float VelocityThreshold;
    /* 0x017c */ float UnplantStiffness;
    /* 0x0180 */ float UnplantCriticalDamping;
};

// Size: 0x18
struct FRetargetDefinition {
    /* 0x0000 */ FName RootBone;
    /* 0x0008 */ TArray<FBoneChain> BoneChains;
};

// Size: 0x28
struct FRetargetFKChainSettings {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ bool EnableFK;
    /* 0x0009 */ EFKChainRotationMode RotationMode;
    /* 0x0010 */ double RotationAlpha;
    /* 0x0018 */ EFKChainTranslationMode TranslationMode;
    /* 0x0020 */ double TranslationAlpha;
};

// Size: 0x34
struct FRetargetGlobalSettings {
    /* 0x0000 */ bool bEnableRoot;
    /* 0x0001 */ bool bEnableFK;
    /* 0x0002 */ bool bEnableIK;
    /* 0x0003 */ bool bEnablePost;
    /* 0x0004 */ bool bCopyBasePose;
    /* 0x0008 */ FName CopyBasePoseRoot;
    /* 0x0010 */ float SourceScaleFactor;
    /* 0x0014 */ bool bWarping;
    /* 0x0018 */ EWarpingDirectionSource DirectionSource;
    /* 0x001c */ EBasicAxis ForwardDirection;
    /* 0x0020 */ FName DirectionChain;
    /* 0x0028 */ float WarpForwards;
    /* 0x002c */ float SidewaysOffset;
    /* 0x0030 */ float WarpSplay;
};

// Size: 0x98
struct FRetargetIKChainSettings {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ bool EnableIK;
    /* 0x0010 */ double BlendToSource;
    /* 0x0018 */ double BlendToSourceTranslation;
    /* 0x0020 */ double BlendToSourceRotation;
    /* 0x0028 */ FVector BlendToSourceWeights;
    /* 0x0040 */ FVector StaticOffset;
    /* 0x0058 */ FVector StaticLocalOffset;
    /* 0x0070 */ FRotator StaticRotationOffset;
    /* 0x0088 */ double ScaleVertical;
    /* 0x0090 */ double Extension;
};

// Size: 0x30
class URetargetOpBase : public UObject {
    /* 0x0028 */ bool bIsEnabled;
};

// Size: 0x20
struct FRetargetOpProfile {
    /* 0x0000 */ FName OpToApplySettingsTo;
    /* 0x0008 */ FInstancedStruct SettingsToApply;
};

// Size: 0x38
class URetargetOpStack : public UObject {
    /* 0x0028 */ TArray<URetargetOpBase*> RetargetOps;
};

// Size: 0x28
struct FRetargetPoleVectorSettings {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ bool bEnabled;
    /* 0x0010 */ double AlignAlpha;
    /* 0x0018 */ double StaticAngularOffset;
    /* 0x0020 */ bool MaintainOffset;
};

// Size: 0x128
struct FRetargetProfile {
    /* 0x0000 */ TArray<FRetargetOpProfile> RetargetOpProfiles;
    /* 0x0010 */ bool bApplyTargetRetargetPose;
    /* 0x0014 */ FName TargetRetargetPoseName;
    /* 0x001c */ bool bApplySourceRetargetPose;
    /* 0x0020 */ FName SourceRetargetPoseName;
    /* 0x0028 */ bool bForceAllIKOff;
    /* 0x0029 */ bool bApplyChainSettings;
    /* 0x0030 */ TMap<FName, FTargetChainSettings> ChainSettings;
    /* 0x0080 */ bool bApplyRootSettings;
    /* 0x0088 */ FTargetRootSettings RootSettings;
    /* 0x00f0 */ bool bApplyGlobalSettings;
    /* 0x00f4 */ FRetargetGlobalSettings GlobalSettings;
};

// Size: 0x28
class URetargetProfileLibrary : public UBlueprintFunctionLibrary {

    static FRetargetProfile CopyRetargetProfileFromRetargetAsset(const UIKRetargeter* InRetargetAsset);
    static UIKRetargetOpControllerBase* GetOpControllerFromRetargetProfile(FRetargetProfile& InRetargetProfile, const FName InRetargetOpName);
};

// Size: 0xe8
class URetargetRootSettings : public UObject {
    /* 0x0028 */ FTargetRootSettings Settings;
    /* 0x0090 */ bool RetargetRootTranslation;
    /* 0x0094 */ float GlobalScaleHorizontal;
    /* 0x0098 */ float GlobalScaleVertical;
    /* 0x00a0 */ FVector BlendToSource;
    /* 0x00b8 */ FVector StaticOffset;
    /* 0x00d0 */ FRotator StaticRotationOffset;
};

// Size: 0x10
struct FRetargetSpeedPlantingSettings {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ FName SpeedCurveName;
};

// Size: 0xc
struct FRetargetStrideWarpChainSettings {
    /* 0x0000 */ FName TargetChainName;
    /* 0x0008 */ bool EnableStrideWarping;
};

// Size: 0xb0
class URootMotionGeneratorOp : public URetargetOpBase {
    /* 0x0030 */ FName SourceRootBone;
    /* 0x0038 */ FName TargetRootBone;
    /* 0x0040 */ FName TargetPelvisBone;
    /* 0x0048 */ ERootMotionSource RootMotionSource;
    /* 0x0049 */ ERootMotionHeightSource RootHeightSource;
    /* 0x004a */ bool bPropagateToNonRetargetedChildren;
    /* 0x004b */ bool bMaintainOffsetFromPelvis;
    /* 0x004c */ bool bRotateWithPelvis;
    /* 0x0050 */ FTransform GlobalOffset;
};

// Size: 0x1c
struct FTargetChainFKSettings {
    /* 0x0000 */ bool EnableFK;
    /* 0x0001 */ ERetargetRotationMode RotationMode;
    /* 0x0004 */ float RotationAlpha;
    /* 0x0008 */ ERetargetTranslationMode TranslationMode;
    /* 0x000c */ float TranslationAlpha;
    /* 0x0010 */ float PoleVectorMatching;
    /* 0x0014 */ bool PoleVectorMaintainOffset;
    /* 0x0018 */ float PoleVectorOffset;
};

// Size: 0x80
struct FTargetChainIKSettings {
    /* 0x0000 */ bool EnableIK;
    /* 0x0004 */ float BlendToSource;
    /* 0x0008 */ float BlendToSourceTranslation;
    /* 0x000c */ float BlendToSourceRotation;
    /* 0x0010 */ FVector BlendToSourceWeights;
    /* 0x0028 */ FVector StaticOffset;
    /* 0x0040 */ FVector StaticLocalOffset;
    /* 0x0058 */ FRotator StaticRotationOffset;
    /* 0x0070 */ float ScaleVertical;
    /* 0x0074 */ float Extension;
    /* 0x0078 */ bool bAffectedByIKWarping;
};

// Size: 0xb8
struct FTargetChainSettings {
    /* 0x0000 */ FTargetChainFKSettings FK;
    /* 0x0020 */ FTargetChainIKSettings IK;
    /* 0x00a0 */ FTargetChainSpeedPlantSettings SpeedPlanting;
};

// Size: 0x18
struct FTargetChainSpeedPlantSettings {
    /* 0x0000 */ bool EnableSpeedPlanting;
    /* 0x0004 */ FName SpeedCurveName;
    /* 0x000c */ float SpeedThreshold;
    /* 0x0010 */ float UnplantStiffness;
    /* 0x0014 */ float UnplantCriticalDamping;
};

// Size: 0x68
struct FTargetRootSettings {
    /* 0x0000 */ float RotationAlpha;
    /* 0x0004 */ float TranslationAlpha;
    /* 0x0008 */ float BlendToSource;
    /* 0x0010 */ FVector BlendToSourceWeights;
    /* 0x0028 */ float ScaleHorizontal;
    /* 0x002c */ float ScaleVertical;
    /* 0x0030 */ FVector TranslationOffset;
    /* 0x0048 */ FRotator RotationOffset;
    /* 0x0060 */ float AffectIKHorizontal;
    /* 0x0064 */ float AffectIKVertical;
};

// Size: 0x2b8
class AISMPoolActor : public AActor {
    /* 0x02a8 */ UISMPoolComponent* ISMPoolComp;
    /* 0x02b0 */ UISMPoolDebugDrawComponent* ISMPoolDebugDrawComp;
};

// Size: 0x370
class UISMPoolComponent : public USceneComponent {
};

// Size: 0x5a0
class UISMPoolDebugDrawComponent : public UDebugDrawComponent {
    /* 0x0580 */ bool bShowGlobalStats;
    /* 0x0581 */ bool bShowStats;
    /* 0x0582 */ bool bShowBounds;
    /* 0x0588 */ UInstancedStaticMeshComponent* SelectedComponent;
};

// Size: 0x80
class UISMPoolSubSystem : public UWorldSubsystem {

    void OnActorEndPlay(AActor* InSource, uint8_t Reason);
};

// Size: 0x8
struct FSharedImageConstRefBlueprint {
};

// Size: 0x28
class USharedImageConstRefBlueprintFns : public UObject {

    static int32_t GetHeight(const FSharedImageConstRefBlueprint& Image);
    static FLinearColor GetPixelLinearColor(const FSharedImageConstRefBlueprint& Image, int32_t X, int32_t Y, bool& bValid, FLinearColor FailureColor);
    static FVector4f GetPixelValue(const FSharedImageConstRefBlueprint& Image, int32_t X, int32_t Y, bool& bValid);
    static FVector2f GetSize(const FSharedImageConstRefBlueprint& Image);
    static int32_t GetWidth(const FSharedImageConstRefBlueprint& Image);
    static bool IsValid(const FSharedImageConstRefBlueprint& Image);
};

enum class EDesiredImageFormat {
    PNG = 0,
    JPG = 1,
    BMP = 2,
    EXR = 3,
    EDesiredImageFormat_MAX = 4,
};

// Size: 0x28
class UImageWriteBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void ExportToDisk(UTexture* Texture, FString Filename, const FImageWriteOptions& Options);
};

// Size: 0x50
struct FImageWriteOptions {
    /* 0x0000 */ EDesiredImageFormat Format;
    /* 0x0004 */ FDelegate OnComplete;
    /* 0x0014 */ int32_t CompressionQuality;
    /* 0x0018 */ bool bOverwriteFile;
    /* 0x0019 */ bool bAsync;
};

enum class EMediaSourceEncoding {
    MSE_None = 0,
    MSE_Linear = 1,
    MSE_sRGB = 2,
    MSE_ST2084 = 3,
    MSE_SLog3 = 12,
    MSE_MAX = 13,
};

// Size: 0x148
class UImgMediaSource : public UBaseMediaSource {
    /* 0x0088 */ bool IsPathRelativeToProjectRoot;
    /* 0x008c */ FFrameRate FrameRateOverride;
    /* 0x0098 */ FString ProxyOverride;
    /* 0x00a8 */ bool bFillGapsInSequence;
    /* 0x00ac */ FTimecode StartTimecode;
    /* 0x00c8 */ FMediaSourceColorSettings SourceColorSettings;
    /* 0x0118 */ FDirectoryPath SequencePath;

    void AddTargetObject(AActor* InActor);
    void GetProxies(TArray<FString>& OutProxies) const;
    FString GetSequencePath() const;
    void RemoveTargetObject(AActor* InActor);
    void SetSequencePath(FString Path);
    void SetTokenizedSequencePath(FString Path);
};

// Size: 0x1
struct FImgMediaSourceCustomizationSequenceProxy {
};

// Size: 0x50
struct FMediaSourceColorSettings {
    /* 0x0000 */ EMediaSourceEncoding EncodingOverride;
    /* 0x0001 */ ETextureColorSpace ColorSpaceOverride;
    /* 0x0008 */ FVector2D RedChromaticityCoordinate;
    /* 0x0018 */ FVector2D GreenChromaticityCoordinate;
    /* 0x0028 */ FVector2D BlueChromaticityCoordinate;
    /* 0x0038 */ FVector2D WhiteChromaticityCoordinate;
    /* 0x0048 */ ETextureChromaticAdaptationMethod ChromaticAdaptationMethod;
};

// Size: 0xe0
class UImgMediaPlaybackComponent : public UActorComponent {
    /* 0x00b8 */ float LODBias;
};

// Size: 0x68
class UImgMediaSettings : public UObject {
    /* 0x0028 */ FFrameRate DefaultFrameRate;
    /* 0x0030 */ bool BandwidthThrottlingEnabled;
    /* 0x0034 */ float CacheBehindPercentage;
    /* 0x0038 */ float CacheSizeGB;
    /* 0x003c */ int32_t CacheThreads;
    /* 0x0040 */ int32_t CacheThreadStackSizeKB;
    /* 0x0044 */ float GlobalCacheSizeGB;
    /* 0x0048 */ bool UseGlobalCache;
    /* 0x004c */ uint32_t ExrDecoderThreads;
    /* 0x0050 */ FString DefaultProxy;
    /* 0x0060 */ bool UseDefaultProxy;
};

enum class EConsoleForGamepadLabels {
    None = 0,
    XBoxOne = 1,
    PS4 = 2,
    EConsoleForGamepadLabels_MAX = 3,
};

enum class EControllerHand {
    Left = 0,
    Right = 1,
    AnyHand = 2,
    Pad = 3,
    ExternalCamera = 4,
    Gun = 5,
    HMD = 6,
    Chest = 7,
    LeftShoulder = 8,
    RightShoulder = 9,
    LeftElbow = 10,
    RightElbow = 11,
    Waist = 12,
    LeftKnee = 13,
    RightKnee = 14,
    LeftFoot = 15,
    RightFoot = 16,
    Special = 17,
    ControllerHand_Count = 18,
    EControllerHand_MAX = 19,
};

enum class ETouchIndex {
    Touch1 = 0,
    Touch2 = 1,
    Touch3 = 2,
    Touch4 = 3,
    Touch5 = 4,
    Touch6 = 5,
    Touch7 = 6,
    Touch8 = 7,
    Touch9 = 8,
    Touch10 = 9,
    CursorPointerIndex = 10,
    MAX_TOUCHES = 11,
    ETouchIndex_MAX = 12,
};

enum class ETouchType {
    Began = 0,
    Moved = 1,
    Stationary = 2,
    ForceChanged = 3,
    FirstMove = 4,
    Ended = 5,
    NumTypes = 6,
    ETouchType_MAX = 7,
};

// Size: 0x28
class UInputCoreTypes : public UObject {
};

// Size: 0x18
struct FKey {
    /* 0x0000 */ FName KeyName;
};

// Size: 0x30
struct FActiveGizmo {
    /* 0x0000 */ UInteractiveGizmo* Gizmo;
};

// Size: 0x70
class UAnyButtonInputBehavior : public UInputBehavior {
};

// Size: 0x28
class IAssetBackedTarget : public UInterface {
};

// Size: 0x1b0
class UAxisAngleGizmo : public UInteractiveGizmo {
    /* 0x0048 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x0058 */ TScriptInterface<IGizmoFloatParameterSource> AngleSource;
    /* 0x0068 */ TScriptInterface<IGizmoClickTarget> HitTarget;
    /* 0x0078 */ TScriptInterface<IGizmoStateTarget> StateTarget;
    /* 0x0088 */ UClickDragInputBehavior* MouseBehavior;
    /* 0x00f0 */ bool bInInteraction;
    /* 0x00f8 */ FVector RotationOrigin;
    /* 0x0110 */ FVector RotationAxis;
    /* 0x0128 */ FVector RotationPlaneX;
    /* 0x0140 */ FVector RotationPlaneY;
    /* 0x0158 */ FVector InteractionStartPoint;
    /* 0x0170 */ FVector InteractionCurPoint;
    /* 0x0188 */ float InteractionStartAngle;
    /* 0x018c */ float InteractionCurAngle;
};

// Size: 0x28
class UAxisAngleGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x1a0
class UAxisPositionGizmo : public UInteractiveGizmo {
    /* 0x0048 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x0058 */ TScriptInterface<IGizmoFloatParameterSource> ParameterSource;
    /* 0x0068 */ UGizmoViewContext* GizmoViewContext;
    /* 0x0070 */ TScriptInterface<IGizmoClickTarget> HitTarget;
    /* 0x0080 */ TScriptInterface<IGizmoStateTarget> StateTarget;
    /* 0x0090 */ UClickDragInputBehavior* MouseBehavior;
    /* 0x0098 */ bool bEnableSignedAxis;
    /* 0x0101 */ bool bInInteraction;
    /* 0x0108 */ FVector InteractionOrigin;
    /* 0x0120 */ FVector InteractionAxis;
    /* 0x0138 */ FVector InteractionStartPoint;
    /* 0x0150 */ FVector InteractionCurPoint;
    /* 0x0168 */ float InteractionStartParameter;
    /* 0x016c */ float InteractionCurParameter;
    /* 0x0170 */ float ParameterSign;
};

// Size: 0x28
class UAxisPositionGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x2a8
class UBaseBrushTool : public UMeshSurfacePointTool {
    /* 0x0100 */ UBrushBaseProperties* BrushProperties;
    /* 0x0108 */ bool bInBrushStroke;
    /* 0x010c */ float WorldToLocalScale;
    /* 0x0110 */ FBrushStampData LastBrushStamp;
    /* 0x0260 */ TSoftClassPtr<UBrushBaseProperties> PropertyClass;
    /* 0x0288 */ UBrushStampIndicator* BrushStampIndicator;
};

// Size: 0x20
struct FBehaviorInfo {
    /* 0x0000 */ UInputBehavior* Behavior;
};

// Size: 0xc0
class UBrushAdjusterInputBehavior : public UAnyButtonInputBehavior {
};

// Size: 0xc0
class UBrushBaseProperties : public UInteractiveToolPropertySet {
    /* 0x00a8 */ float BrushSize;
    /* 0x00ac */ bool bSpecifyRadius;
    /* 0x00b0 */ float BrushRadius;
    /* 0x00b4 */ float BrushStrength;
    /* 0x00b8 */ float BrushFalloffAmount;
    /* 0x00bc */ bool bShowStrength;
    /* 0x00bd */ bool bShowFalloff;
};

// Size: 0x140
struct FBrushStampData {
};

// Size: 0xd8
class UBrushStampIndicator : public UInteractiveGizmo {
    /* 0x0038 */ bool bVisible;
    /* 0x003c */ float BrushRadius;
    /* 0x0040 */ float BrushFalloff;
    /* 0x0044 */ float BrushStrength;
    /* 0x0048 */ FVector BrushPosition;
    /* 0x0060 */ FVector BrushNormal;
    /* 0x0078 */ bool bDrawIndicatorLines;
    /* 0x0079 */ bool bDrawRadiusCircle;
    /* 0x007a */ bool bScaleNormalByStrength;
    /* 0x007c */ int32_t SampleStepCount;
    /* 0x0080 */ FLinearColor LineColor;
    /* 0x0090 */ float LineThickness;
    /* 0x0094 */ bool bDepthTested;
    /* 0x0095 */ bool bDrawSecondaryLines;
    /* 0x0098 */ float SecondaryLineThickness;
    /* 0x009c */ FLinearColor SecondaryLineColor;
    /* 0x00b0 */ UPrimitiveComponent* AttachedComponent;
};

// Size: 0x28
class UBrushStampIndicatorBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x120
class UClickDragInputBehavior : public UAnyButtonInputBehavior {
    /* 0x0100 */ bool bUpdateModifiersDuringDrag;
};

// Size: 0xa0
class UClickDragTool : public UInteractiveTool {
};

// Size: 0x28
class UClickDragToolBuilder : public UInteractiveToolBuilder {
};

// Size: 0x540
class UCombinedTransformGizmo : public UInteractiveGizmo {
    /* 0x0038 */ UTransformProxy* ActiveTarget;
    /* 0x0040 */ bool bSnapToWorldGrid;
    /* 0x0044 */ bool bGridSizeIsExplicit;
    /* 0x0048 */ FVector ExplicitGridSize;
    /* 0x0060 */ bool bRotationGridSizeIsExplicit;
    /* 0x0068 */ FRotator ExplicitRotationGridSize;
    /* 0x0080 */ bool bSnapToWorldRotGrid;
    /* 0x0081 */ bool bSnapToScaleGrid;
    /* 0x0082 */ bool bUseContextCoordinateSystem;
    /* 0x0083 */ EToolContextCoordinateSystem CurrentCoordinateSystem;
    /* 0x0084 */ bool bUseContextGizmoMode;
    /* 0x0085 */ EToolContextTransformGizmoMode ActiveGizmoMode;
    /* 0x0190 */ TArray<UPrimitiveComponent*> ActiveComponents;
    /* 0x01a0 */ TArray<UInteractiveGizmo*> ActiveGizmos;
    /* 0x03d0 */ UGizmoConstantFrameAxisSource* CameraAxisSource;
    /* 0x03d8 */ UGizmoComponentAxisSource* AxisXSource;
    /* 0x03e0 */ UGizmoComponentAxisSource* AxisYSource;
    /* 0x03e8 */ UGizmoComponentAxisSource* AxisZSource;
    /* 0x03f0 */ UGizmoComponentAxisSource* UnitAxisXSource;
    /* 0x03f8 */ UGizmoComponentAxisSource* UnitAxisYSource;
    /* 0x0400 */ UGizmoComponentAxisSource* UnitAxisZSource;
    /* 0x0408 */ UGizmoTransformChangeStateTarget* StateTarget;
};

// Size: 0x370
class ACombinedTransformGizmoActor : public AGizmoActor {
    /* 0x02b0 */ UPrimitiveComponent* TranslateX;
    /* 0x02b8 */ UPrimitiveComponent* TranslateY;
    /* 0x02c0 */ UPrimitiveComponent* TranslateZ;
    /* 0x02c8 */ UPrimitiveComponent* TranslateYZ;
    /* 0x02d0 */ UPrimitiveComponent* TranslateXZ;
    /* 0x02d8 */ UPrimitiveComponent* TranslateXY;
    /* 0x02e0 */ UPrimitiveComponent* RotateX;
    /* 0x02e8 */ UPrimitiveComponent* RotateY;
    /* 0x02f0 */ UPrimitiveComponent* RotateZ;
    /* 0x02f8 */ UPrimitiveComponent* RotationSphere;
    /* 0x0300 */ UPrimitiveComponent* FreeRotateHandle;
    /* 0x0308 */ UPrimitiveComponent* FreeTranslateHandle;
    /* 0x0310 */ UPrimitiveComponent* UniformScale;
    /* 0x0318 */ UPrimitiveComponent* AxisScaleX;
    /* 0x0320 */ UPrimitiveComponent* AxisScaleY;
    /* 0x0328 */ UPrimitiveComponent* AxisScaleZ;
    /* 0x0330 */ UPrimitiveComponent* PlaneScaleYZ;
    /* 0x0338 */ UPrimitiveComponent* PlaneScaleXZ;
    /* 0x0340 */ UPrimitiveComponent* PlaneScaleXY;
    /* 0x0358 */ UPrimitiveComponent* FullAxisScaleX;
    /* 0x0360 */ UPrimitiveComponent* FullAxisScaleY;
    /* 0x0368 */ UPrimitiveComponent* FullAxisScaleZ;
};

// Size: 0xd0
class UCombinedTransformGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x58
class UCombinedTransformGizmoContextObject : public UObject {
};

// Size: 0x1c0
class UComponentBoundTransformProxy : public UTransformProxy {
};

// Size: 0x38
class UContextObjectStore : public UObject {
    /* 0x0028 */ TArray<UObject*> ContextObjects;
};

// Size: 0x20
struct FDeviceButtonState {
    /* 0x0000 */ FKey button;
    /* 0x0018 */ bool bPressed;
    /* 0x0019 */ bool bDown;
    /* 0x001a */ bool bReleased;
    /* 0x001b */ bool bDoubleClicked;
};

// Size: 0x110
class UDoubleClickInputBehavior : public USingleClickInputBehavior {
};

enum class EGizmoElementArrowHeadType {
    Cone = 0,
    Cube = 1,
    EGizmoElementArrowHeadType_MAX = 2,
};

enum class EGizmoElementDrawType {
    None = 0,
    Fill = 2,
    Line = 4,
    FillAndLine = 6,
    EGizmoElementDrawType_MAX = 7,
};

enum class EGizmoElementInteractionState {
    None = 0,
    Hovering = 1,
    Interacting = 2,
    EGizmoElementInteractionState_MAX = 3,
};

enum class EGizmoElementPartialType {
    None = 0,
    Partial = 1,
    PartialViewDependent = 2,
    EGizmoElementPartialType_MAX = 3,
};

enum class EGizmoElementState {
    None = 0,
    Visible = 2,
    Hittable = 4,
    VisibleAndHittable = 6,
    EGizmoElementState_MAX = 7,
};

enum class EGizmoElementViewAlignType {
    None = 0,
    PointOnly = 1,
    PointEye = 2,
    PointScreen = 3,
    Axial = 4,
    EGizmoElementViewAlignType_MAX = 5,
};

enum class EGizmoElementViewDependentType {
    None = 0,
    Axis = 1,
    Plane = 2,
    EGizmoElementViewDependentType_MAX = 3,
};

enum class EInputCaptureRequestType {
    Begin = 1,
    Ignore = 2,
    EInputCaptureRequestType_MAX = 3,
};

enum class EInputCaptureSide {
    None = 0,
    Left = 1,
    Right = 2,
    Both = 3,
    Any = 99,
    EInputCaptureSide_MAX = 100,
};

enum class EInputCaptureState {
    Begin = 1,
    Continue = 2,
    End = 3,
    Ignore = 4,
    EInputCaptureState_MAX = 5,
};

enum class EInputDevices {
    None = 0,
    Keyboard = 1,
    Mouse = 2,
    Gamepad = 4,
    OculusTouch = 8,
    HTCViveWands = 16,
    AnySpatialDevice = 24,
    TabletFingers = 1024,
    EInputDevices_MAX = 1025,
};

enum class ESceneSnapQueryTargetResult {
    NotSnapped = 0,
    Snapped = 1,
    Disabled = 2,
    Unsupported = 3,
    ESceneSnapQueryTargetResult_MAX = 4,
};

enum class ESceneSnapQueryTargetType {
    None = 0,
    MeshVertex = 1,
    MeshEdge = 2,
    Grid = 4,
    ObjectTransform = 8,
    Custom = 16,
    All = 31,
    ESceneSnapQueryTargetType_MAX = 32,
};

enum class ESceneSnapQueryType {
    Position = 1,
    Rotation = 2,
    RotationAngle = 3,
    Scale = 4,
    Transform = 5,
    ESceneSnapQueryType_MAX = 6,
};

enum class ESelectedObjectsModificationType {
    Replace = 0,
    Add = 1,
    Remove = 2,
    Clear = 3,
    ESelectedObjectsModificationType_MAX = 4,
};

enum class EStandardToolContextMaterials {
    VertexColorMaterial = 1,
    EStandardToolContextMaterials_MAX = 2,
};

enum class EToolChangeTrackingMode {
    NoChangeTracking = 1,
    UndoToExit = 2,
    FullUndoRedo = 3,
    EToolChangeTrackingMode_MAX = 4,
};

enum class EToolContextCoordinateSystem {
    World = 0,
    Local = 1,
    Screen = 2,
    EToolContextCoordinateSystem_MAX = 3,
};

enum class EToolContextTransformGizmoMode {
    NoGizmo = 0,
    Translation = 1,
    Rotation = 2,
    Scale = 3,
    Combined = 8,
    EToolContextTransformGizmoMode_MAX = 9,
};

enum class EToolManagerToolSwitchMode {
    AcceptIfAble = 0,
    CancelIfAble = 1,
    CustomizableAcceptIfAble = 2,
    CustomizableCancelIfAble = 3,
    EToolManagerToolSwitchMode_MAX = 4,
};

enum class EToolMessageLevel {
    Internal = 0,
    UserMessage = 1,
    UserNotification = 2,
    UserWarning = 3,
    UserError = 4,
    EToolMessageLevel_MAX = 5,
};

enum class EToolShutdownType {
    Completed = 0,
    Accept = 1,
    Cancel = 2,
    EToolShutdownType_MAX = 3,
};

enum class EToolSide {
    Left = 1,
    Mouse = 1,
    Right = 2,
    EToolSide_MAX = 3,
};

enum class ETransformGizmoSubElements {
    None = 0,
    TranslateAxisX = 2,
    TranslateAxisY = 4,
    TranslateAxisZ = 8,
    TranslateAllAxes = 14,
    TranslatePlaneXY = 16,
    TranslatePlaneXZ = 32,
    TranslatePlaneYZ = 64,
    TranslateAllPlanes = 112,
    RotateAxisX = 128,
    RotateAxisY = 256,
    RotateAxisZ = 512,
    RotateAllAxes = 896,
    ScaleAxisX = 1024,
    ScaleAxisY = 2048,
    ScaleAxisZ = 4096,
    ScaleAllAxes = 7168,
    ScalePlaneYZ = 8192,
    ScalePlaneXZ = 16384,
    ScalePlaneXY = 32768,
    ScaleAllPlanes = 57344,
    ScaleUniform = 65536,
    FreeTranslate = 131072,
    FreeRotate = 262144,
    StandardTranslateRotate = 394238,
    TranslateRotateUniformScale = 459774,
    FullTranslateRotateScale = 524286,
    ETransformGizmoSubElements_MAX = 524287,
};

enum class EViewInteractionState {
    None = 0,
    Hovered = 1,
    Focused = 2,
    EViewInteractionState_MAX = 3,
};

// Size: 0x290
class UFreePositionSubGizmo : public UPlanePositionGizmo {
    /* 0x0280 */ TScriptInterface<IGizmoTransformSource> TransformSource;
};

// Size: 0x100
class UFreeRotationSubGizmo : public UInteractiveGizmo {
    /* 0x0048 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x0058 */ TScriptInterface<IGizmoClickTarget> HitTarget;
    /* 0x0068 */ TScriptInterface<IGizmoStateTarget> StateTarget;
    /* 0x0078 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x0088 */ UGizmoViewContext* GizmoViewContext;
    /* 0x0090 */ UClickDragInputBehavior* MouseBehavior;
};

// Size: 0x2b0
class AGizmoActor : public AInternalToolFrameworkActor {
};

// Size: 0x580
class UGizmoArrowComponent : public UGizmoBaseComponent {
    /* 0x0558 */ FVector Direction;
    /* 0x0570 */ float Gap;
    /* 0x0574 */ float Length;
    /* 0x0578 */ float Thickness;
};

// Size: 0x60
class UGizmoAxisIntervalParameterSource : public UGizmoBaseFloatParameterSource {
    /* 0x0048 */ TScriptInterface<IGizmoFloatParameterSource> FloatParameterSource;
    /* 0x0058 */ float MinParameter;
    /* 0x005c */ float MaxParameter;
};

// Size: 0x170
class UGizmoAxisRotationParameterSource : public UGizmoBaseFloatParameterSource {
    /* 0x00b0 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x00c0 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x00d0 */ float Angle;
    /* 0x00d4 */ FGizmoFloatParameterChange LastChange;
    /* 0x00e0 */ FVector CurRotationAxis;
    /* 0x00f8 */ FVector CurRotationOrigin;
    /* 0x0110 */ FTransform InitialTransform;
};

// Size: 0x180
class UGizmoAxisScaleParameterSource : public UGizmoBaseFloatParameterSource {
    /* 0x00b0 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x00c0 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x00d0 */ float ScaleMultiplier;
    /* 0x00d4 */ bool bClampToZero;
    /* 0x00d8 */ float Parameter;
    /* 0x00dc */ FGizmoFloatParameterChange LastChange;
    /* 0x00e8 */ FVector CurScaleAxis;
    /* 0x0100 */ FVector CurScaleOrigin;
    /* 0x0120 */ FTransform InitialTransform;
};

// Size: 0x28
class IGizmoAxisSource : public UInterface {

    FVector GetDirection() const;
    FVector GetOrigin() const;
    void GetTangentVectors(FVector& TangentXOut, FVector& TangentYOut) const;
    bool HasTangentVectors() const;
};

// Size: 0x170
class UGizmoAxisTranslationParameterSource : public UGizmoBaseFloatParameterSource {
    /* 0x00b0 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x00c0 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x00d0 */ float Parameter;
    /* 0x00d4 */ FGizmoFloatParameterChange LastChange;
    /* 0x00e0 */ FVector CurTranslationAxis;
    /* 0x00f8 */ FVector CurTranslationOrigin;
    /* 0x0110 */ FTransform InitialTransform;
};

// Size: 0x560
class UGizmoBaseComponent : public UPrimitiveComponent {
    /* 0x0528 */ FLinearColor Color;
    /* 0x0538 */ float HoverSizeMultiplier;
    /* 0x053c */ float PixelHitDistanceThreshold;
    /* 0x0548 */ UGizmoViewContext* GizmoViewContext;

    void UpdateHoverState(bool bHoveringIn);
    void UpdateWorldLocalState(bool bWorldIn);
};

// Size: 0x28
class IGizmoBaseComponentInterface : public UInterface {
};

// Size: 0x48
class UGizmoBaseFloatParameterSource : public UObject {
};

// Size: 0x48
class UGizmoBaseTransformSource : public UObject {
};

// Size: 0x48
class UGizmoBaseVec2ParameterSource : public UObject {
};

// Size: 0x5b0
class UGizmoBoxComponent : public UGizmoBaseComponent {
    /* 0x0558 */ FVector Origin;
    /* 0x0570 */ FQuat Rotation;
    /* 0x0590 */ FVector Dimensions;
    /* 0x05a8 */ float LineThickness;
    /* 0x05ac */ bool bRemoveHiddenLines;
    /* 0x05ad */ bool bEnableAxisFlip;
};

// Size: 0x580
class UGizmoCircleComponent : public UGizmoBaseComponent {
    /* 0x0558 */ FVector Normal;
    /* 0x0570 */ float Radius;
    /* 0x0574 */ float Thickness;
    /* 0x0578 */ int32_t NumSides;
    /* 0x057c */ bool bViewAligned;
    /* 0x057d */ bool bDrawFullCircle;
    /* 0x057e */ bool bOnlyAllowFrontFacingHits;
};

// Size: 0x28
class IGizmoClickMultiTarget : public UInterface {

    void UpdateHittableState(bool bHittable, uint32_t InPartIdentifier);
    void UpdateHoverState(bool bHovering, uint32_t InPartIdentifier);
    void UpdateInteractingState(bool bInteracting, uint32_t InPartIdentifier);
};

// Size: 0x28
class IGizmoClickTarget : public UInterface {

    void UpdateHoverState(bool bHovering);
    void UpdateInteractingState(bool bInteracting);
};

// Size: 0x40
class UGizmoComponentAxisSource : public UObject {
    /* 0x0030 */ USceneComponent* Component;
    /* 0x0038 */ int32_t AxisIndex;
    /* 0x003c */ bool bLocalAxes;
};

// Size: 0xd0
class UGizmoComponentHitTarget : public UObject {
    /* 0x0030 */ UPrimitiveComponent* Component;
};

// Size: 0x58
class UGizmoComponentWorldTransformSource : public UGizmoBaseTransformSource {
    /* 0x0048 */ USceneComponent* Component;
    /* 0x0050 */ bool bModifyComponentOnTransform;
};

// Size: 0x60
class UGizmoConstantAxisSource : public UObject {
    /* 0x0030 */ FVector Origin;
    /* 0x0048 */ FVector Direction;
};

// Size: 0x90
class UGizmoConstantFrameAxisSource : public UObject {
    /* 0x0030 */ FVector Origin;
    /* 0x0048 */ FVector Direction;
    /* 0x0060 */ FVector TangentX;
    /* 0x0078 */ FVector TangentY;
};

// Size: 0x1d0
class UGizmoElementArc : public UGizmoElementCircleBase {
    /* 0x01c8 */ double InnerRadius;
};

// Size: 0x198
class UGizmoElementArrow : public UGizmoElementBase {
    /* 0x0110 */ UGizmoElementCylinder* CylinderElement;
    /* 0x0118 */ UGizmoElementCone* ConeElement;
    /* 0x0120 */ UGizmoElementBox* BoxElement;
    /* 0x0128 */ FVector base;
    /* 0x0140 */ FVector Direction;
    /* 0x0158 */ FVector SideDirection;
    /* 0x0170 */ float BodyLength;
    /* 0x0174 */ float BodyRadius;
    /* 0x0178 */ float HeadLength;
    /* 0x017c */ float HeadRadius;
    /* 0x0180 */ int32_t NumSides;
    /* 0x0184 */ bool bEndCaps;
    /* 0x0188 */ EGizmoElementArrowHeadType HeadType;
    /* 0x018c */ TWeakObjectPtr<UGizmoElementBase> HitMask;
};

// Size: 0x108
class UGizmoElementBase : public UObject {
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ bool bEnabledForPerspectiveProjection;
    /* 0x002a */ bool bEnabledForOrthographicProjection;
    /* 0x002b */ bool bEnabledForDefaultState;
    /* 0x002c */ bool bEnabledForHoveringState;
    /* 0x002d */ bool bEnabledForInteractingState;
    /* 0x0030 */ uint32_t PartIdentifier;
    /* 0x0034 */ FGizmoElementMeshRenderStateAttributes MeshRenderAttributes;
    /* 0x0094 */ EGizmoElementState ElementState;
    /* 0x0098 */ EGizmoElementInteractionState ElementInteractionState;
    /* 0x009c */ EGizmoElementViewDependentType ViewDependentType;
    /* 0x00a0 */ FVector ViewDependentAxis;
    /* 0x00b8 */ float ViewDependentAngleTol;
    /* 0x00bc */ float ViewDependentAxialMaxCosAngleTol;
    /* 0x00c0 */ float ViewDependentPlanarMinCosAngleTol;
    /* 0x00c4 */ EGizmoElementViewAlignType ViewAlignType;
    /* 0x00c8 */ FVector ViewAlignAxis;
    /* 0x00e0 */ FVector ViewAlignNormal;
    /* 0x00f8 */ float ViewAlignAxialAngleTol;
    /* 0x00fc */ float ViewAlignAxialMaxCosAngleTol;
    /* 0x0100 */ float PixelHitDistanceThreshold;
};

// Size: 0x168
class UGizmoElementBox : public UGizmoElementBase {
    /* 0x0108 */ FVector Center;
    /* 0x0120 */ FVector Dimensions;
    /* 0x0138 */ FVector UpDirection;
    /* 0x0150 */ FVector SideDirection;
};

// Size: 0x1d0
class UGizmoElementCircle : public UGizmoElementCircleBase {
    /* 0x01c8 */ bool bDrawMesh;
    /* 0x01c9 */ bool bDrawLine;
    /* 0x01ca */ bool bHitMesh;
    /* 0x01cb */ bool bHitLine;
};

// Size: 0x1c8
class UGizmoElementCircleBase : public UGizmoElementLineBase {
    /* 0x0158 */ FVector Center;
    /* 0x0170 */ FVector Axis0;
    /* 0x0188 */ FVector Axis1;
    /* 0x01a0 */ double Radius;
    /* 0x01a8 */ int32_t NumSegments;
    /* 0x01ac */ EGizmoElementPartialType PartialType;
    /* 0x01b0 */ double PartialStartAngle;
    /* 0x01b8 */ double PartialEndAngle;
    /* 0x01c0 */ double PartialViewDependentMaxCosTol;
};

// Size: 0x14
struct FGizmoElementColorAttribute {
    /* 0x0000 */ FLinearColor Value;
    /* 0x0010 */ bool bHasValue;
    /* 0x0011 */ bool bOverridesChildState;
};

// Size: 0x148
class UGizmoElementCone : public UGizmoElementBase {
    /* 0x0108 */ FVector Origin;
    /* 0x0120 */ FVector Direction;
    /* 0x0138 */ float Height;
    /* 0x013c */ float Radius;
    /* 0x0140 */ int32_t NumSides;
    /* 0x0144 */ bool bEndCaps;
};

// Size: 0x148
class UGizmoElementCylinder : public UGizmoElementBase {
    /* 0x0108 */ FVector base;
    /* 0x0120 */ FVector Direction;
    /* 0x0138 */ float Height;
    /* 0x013c */ float Radius;
    /* 0x0140 */ int32_t NumSides;
};

// Size: 0x170
class UGizmoElementGroup : public UGizmoElementLineBase {
    /* 0x0158 */ bool bConstantScale;
    /* 0x0159 */ bool bHitOwner;
    /* 0x0160 */ TArray<UGizmoElementBase*> Elements;
};

// Size: 0x80
class UGizmoElementHitMultiTarget : public UObject {
    /* 0x0030 */ UGizmoElementBase* GizmoElement;
    /* 0x0038 */ UGizmoViewContext* GizmoViewContext;
    /* 0x0040 */ UTransformProxy* GizmoTransformProxy;
};

// Size: 0x80
class UGizmoElementHitTarget : public UObject {
    /* 0x0030 */ UGizmoElementBase* GizmoElement;
    /* 0x0038 */ UGizmoViewContext* GizmoViewContext;
    /* 0x0040 */ UTransformProxy* GizmoTransformProxy;
};

// Size: 0x158
class UGizmoElementLineBase : public UGizmoElementBase {
    /* 0x0108 */ FGizmoElementLineRenderStateAttributes LineRenderAttributes;
    /* 0x0144 */ float LineThickness;
    /* 0x0148 */ bool bScreenSpaceLine;
    /* 0x014c */ float HoverLineThicknessMultiplier;
    /* 0x0150 */ float InteractLineThicknessMultiplier;
};

// Size: 0x3c
struct FGizmoElementLineRenderStateAttributes {
    /* 0x0000 */ FGizmoElementColorAttribute LineColor;
    /* 0x0014 */ FGizmoElementColorAttribute HoverLineColor;
    /* 0x0028 */ FGizmoElementColorAttribute InteractLineColor;
};

// Size: 0x1c8
class UGizmoElementLineStrip : public UGizmoElementLineBase {
    /* 0x0158 */ TArray<FVector> Vertices;
    /* 0x0168 */ FVector base;
    /* 0x0180 */ FVector UpDirection;
    /* 0x0198 */ FVector SideDirection;
    /* 0x01b0 */ bool bDrawLineStrip;
};

// Size: 0xc
struct FGizmoElementMaterialAttribute {
    /* 0x0000 */ TWeakObjectPtr<UMaterialInterface> Value;
    /* 0x0008 */ bool bOverridesChildState;
};

// Size: 0x60
struct FGizmoElementMeshRenderStateAttributes {
    /* 0x0000 */ FGizmoElementMaterialAttribute Material;
    /* 0x000c */ FGizmoElementMaterialAttribute HoverMaterial;
    /* 0x0018 */ FGizmoElementMaterialAttribute InteractMaterial;
    /* 0x0024 */ FGizmoElementColorAttribute VertexColor;
    /* 0x0038 */ FGizmoElementColorAttribute HoverVertexColor;
    /* 0x004c */ FGizmoElementColorAttribute InteractVertexColor;
};

// Size: 0x1b0
class UGizmoElementRectangle : public UGizmoElementLineBase {
    /* 0x0158 */ FVector Center;
    /* 0x0170 */ float Width;
    /* 0x0174 */ float Height;
    /* 0x0178 */ FVector UpDirection;
    /* 0x0190 */ FVector SideDirection;
    /* 0x01a8 */ bool bDrawMesh;
    /* 0x01a9 */ bool bDrawLine;
    /* 0x01aa */ bool bHitMesh;
    /* 0x01ab */ bool bHitLine;
};

// Size: 0x128
class UGizmoElementSphere : public UGizmoElementBase {
    /* 0x0108 */ FVector Center;
    /* 0x0120 */ float Radius;
    /* 0x0124 */ int32_t NumSides;
};

// Size: 0x1d8
class UGizmoElementTorus : public UGizmoElementCircleBase {
    /* 0x01c8 */ double InnerRadius;
    /* 0x01d0 */ int32_t NumInnerSlices;
    /* 0x01d4 */ bool bEndCaps;
};

// Size: 0x170
class UGizmoElementTriangleList : public UGizmoElementBase {
    /* 0x0108 */ TArray<FVector> Vertices;
    /* 0x0118 */ FVector base;
    /* 0x0130 */ FVector UpDirection;
    /* 0x0148 */ FVector SideDirection;
};

// Size: 0x8
struct FGizmoFloatParameterChange {
    /* 0x0000 */ float InitialValue;
    /* 0x0004 */ float CurrentValue;
};

// Size: 0x28
class IGizmoFloatParameterSource : public UInterface {

    void BeginModify();
    void EndModify();
    float GetParameter() const;
    void SetParameter(float NewValue);
};

// Size: 0xc0
class UGizmoLambdaHitTarget : public UObject {
};

// Size: 0x90
class UGizmoLambdaStateTarget : public UObject {
};

// Size: 0x5a0
class UGizmoLineHandleComponent : public UGizmoBaseComponent {
    /* 0x0558 */ FVector Normal;
    /* 0x0570 */ float HandleSize;
    /* 0x0574 */ float Thickness;
    /* 0x0578 */ FVector Direction;
    /* 0x0590 */ float Length;
    /* 0x0594 */ bool bImageScale;
};

// Size: 0x58
class UGizmoLocalFloatParameterSource : public UGizmoBaseFloatParameterSource {
    /* 0x0048 */ float Value;
    /* 0x004c */ FGizmoFloatParameterChange LastChange;
};

// Size: 0x78
class UGizmoLocalVec2ParameterSource : public UGizmoBaseVec2ParameterSource {
    /* 0x0048 */ FVector2D Value;
    /* 0x0058 */ FGizmoVec2ParameterChange LastChange;
};

// Size: 0x30
class UGizmoNilStateTarget : public UObject {
};

// Size: 0x58
class UGizmoObjectModifyStateTarget : public UObject {
    /* 0x0048 */ TScriptInterface<IToolContextTransactionProvider> TransactionManager;
};

// Size: 0x230
class UGizmoPlaneScaleParameterSource : public UGizmoBaseVec2ParameterSource {
    /* 0x0110 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x0120 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x0130 */ float ScaleMultiplier;
    /* 0x0134 */ bool bUseEqualScaling;
    /* 0x0135 */ bool bClampToZero;
    /* 0x0138 */ FVector2D Parameter;
    /* 0x0148 */ FGizmoVec2ParameterChange LastChange;
    /* 0x0168 */ FVector CurScaleOrigin;
    /* 0x0180 */ FVector CurScaleNormal;
    /* 0x0198 */ FVector CurScaleAxisX;
    /* 0x01b0 */ FVector CurScaleAxisY;
    /* 0x01d0 */ FTransform InitialTransform;
};

// Size: 0x1f0
class UGizmoPlaneTranslationParameterSource : public UGizmoBaseVec2ParameterSource {
    /* 0x00e0 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x00f0 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x0100 */ FVector2D Parameter;
    /* 0x0110 */ FGizmoVec2ParameterChange LastChange;
    /* 0x0130 */ FVector CurTranslationOrigin;
    /* 0x0148 */ FVector CurTranslationNormal;
    /* 0x0160 */ FVector CurTranslationAxisX;
    /* 0x0178 */ FVector CurTranslationAxisY;
    /* 0x0190 */ FTransform InitialTransform;
};

// Size: 0x5b0
class UGizmoRectangleComponent : public UGizmoBaseComponent {
    /* 0x0558 */ FVector DirectionX;
    /* 0x0570 */ FVector DirectionY;
    /* 0x0588 */ bool bOrientYAccordingToCamera;
    /* 0x058c */ float OffsetX;
    /* 0x0590 */ float OffsetY;
    /* 0x0594 */ float LengthX;
    /* 0x0598 */ float LengthY;
    /* 0x059c */ float Thickness;
    /* 0x05a0 */ uint8_t SegmentFlags;
};

// Size: 0x28
class IGizmoRenderMultiTarget : public UInterface {

    void UpdateVisibilityState(bool bVisible, uint32_t InPartIdentifier);
};

// Size: 0x28
class IGizmoRenderTarget : public UInterface {
};

// Size: 0x68
class UGizmoScaledAndUnscaledTransformSources : public UGizmoBaseTransformSource {
    /* 0x0048 */ TScriptInterface<IGizmoTransformSource> ScaledTransformSource;
    /* 0x0058 */ TScriptInterface<IGizmoTransformSource> UnscaledTransformSource;
};

// Size: 0xc0
class UGizmoScaledTransformSource : public UGizmoBaseTransformSource {
    /* 0x0048 */ TScriptInterface<IGizmoTransformSource> ChildTransformSource;
};

// Size: 0x28
class IGizmoStateTarget : public UInterface {

    void BeginUpdate();
    void EndUpdate();
};

// Size: 0x140
class UGizmoTransformChangeStateTarget : public UObject {
    /* 0x0048 */ TScriptInterface<IToolContextTransactionProvider> TransactionManager;
};

// Size: 0x70
class UGizmoTransformProxyTransformSource : public UGizmoBaseTransformSource {
    /* 0x0048 */ UTransformProxy* Proxy;
};

// Size: 0x28
class IGizmoTransformSource : public UInterface {

    FTransform GetTransform() const;
    void SetTransform(const FTransform& NewTransform);
};

// Size: 0x1d0
class UGizmoUniformScaleParameterSource : public UGizmoBaseVec2ParameterSource {
    /* 0x00b0 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x00c0 */ TScriptInterface<IGizmoTransformSource> TransformSource;
    /* 0x00d0 */ float ScaleMultiplier;
    /* 0x00d8 */ FVector2D Parameter;
    /* 0x00e8 */ FGizmoVec2ParameterChange LastChange;
    /* 0x0108 */ FVector CurScaleOrigin;
    /* 0x0120 */ FVector CurScaleNormal;
    /* 0x0138 */ FVector CurScaleAxisX;
    /* 0x0150 */ FVector CurScaleAxisY;
    /* 0x0170 */ FTransform InitialTransform;
};

// Size: 0x20
struct FGizmoVec2ParameterChange {
    /* 0x0000 */ FVector2D InitialValue;
    /* 0x0010 */ FVector2D CurrentValue;
};

// Size: 0x28
class IGizmoVec2ParameterSource : public UInterface {

    void BeginModify();
    void EndModify();
    FVector2D GetParameter() const;
    void SetParameter(const FVector2D& NewValue);
};

// Size: 0x260
class UGizmoViewContext : public UObject {
};

// Size: 0x50
class UGizmoWorldAxisSource : public UObject {
    /* 0x0030 */ FVector Origin;
    /* 0x0048 */ int32_t AxisIndex;
};

// Size: 0x30
class UInputBehavior : public UObject {
};

// Size: 0x38
class UInputBehaviorSet : public UObject {
    /* 0x0028 */ TArray<FBehaviorInfo> Behaviors;
};

// Size: 0x28
class IInputBehaviorSource : public UInterface {
};

// Size: 0x48
struct FInputDeviceRay {
    /* 0x0000 */ FRay WorldRay;
    /* 0x0030 */ bool bHas2D;
    /* 0x0038 */ FVector2D screenPosition;
};

// Size: 0xe0
struct FInputDeviceState {
    /* 0x0000 */ EInputDevices InputDevice;
    /* 0x0004 */ bool bShiftKeyDown;
    /* 0x0005 */ bool bAltKeyDown;
    /* 0x0006 */ bool bCtrlKeyDown;
    /* 0x0007 */ bool bCmdKeyDown;
    /* 0x0008 */ FKeyboardInputDeviceState keyboard;
    /* 0x0028 */ FMouseInputDeviceState Mouse;
};

// Size: 0x40
struct FInputRayHit {
    /* 0x0000 */ bool bHit;
    /* 0x0008 */ double HitDepth;
    /* 0x0010 */ FVector HitNormal;
    /* 0x0028 */ bool bHasHitNormal;
    /* 0x002c */ int32_t HitIdentifier;
    /* 0x0038 */ TWeakObjectPtr<UObject> HitObject;
};

// Size: 0x190
class UInputRouter : public UObject {
    /* 0x0028 */ bool bAutoInvalidateOnHover;
    /* 0x0029 */ bool bAutoInvalidateOnCapture;
    /* 0x0038 */ UInputBehaviorSet* ActiveInputBehaviors;
};

// Size: 0x30
class UInteractionMechanic : public UObject {
};

// Size: 0x28
class UInteractiveCommand : public UObject {
};

// Size: 0x30
class UInteractiveCommandArguments : public UObject {
};

// Size: 0x28
class UInteractiveCommandResult : public UObject {
};

// Size: 0x38
class UInteractiveGizmo : public UObject {
    /* 0x0030 */ UInputBehaviorSet* InputBehaviors;
};

// Size: 0x28
class UInteractiveGizmoBuilder : public UObject {
};

// Size: 0xc0
class UInteractiveGizmoManager : public UObject {
    /* 0x0030 */ TArray<FActiveGizmo> ActiveGizmos;
    /* 0x0058 */ TMap<FString, UInteractiveGizmoBuilder*> GizmoBuilders;
};

// Size: 0x98
class UInteractiveTool : public UObject {
    /* 0x0060 */ UInputBehaviorSet* InputBehaviors;
    /* 0x0068 */ TArray<UObject*> ToolPropertyObjects;
};

// Size: 0x28
class UInteractiveToolBuilder : public UObject {
};

// Size: 0x28
class IInteractiveToolCameraFocusAPI : public UInterface {
};

// Size: 0x28
class IInteractiveToolEditorGizmoAPI : public UInterface {
};

// Size: 0x28
class IInteractiveToolExclusiveToolAPI : public UInterface {
};

// Size: 0x28
class IInteractiveToolManageGeometrySelectionAPI : public UInterface {
};

// Size: 0x1b0
class UInteractiveToolManager : public UObject {
    /* 0x0058 */ UInteractiveTool* ActiveLeftTool;
    /* 0x0060 */ UInteractiveTool* ActiveRightTool;
    /* 0x0100 */ TMap<FString, UInteractiveToolBuilder*> ToolBuilders;
};

// Size: 0x28
class IInteractiveToolNestedAcceptCancelAPI : public UInterface {
};

// Size: 0xa8
class UInteractiveToolPropertySet : public UObject {
    /* 0x0038 */ TMap<FString, UInteractiveToolPropertySet*> CachedPropertiesMap;
    /* 0x0088 */ bool bIsPropertySetEnabled;
};

// Size: 0x28
class IInteractiveToolShutdownQueryAPI : public UInterface {
};

// Size: 0x28
class UInteractiveToolWithToolTargetsBuilder : public UInteractiveToolBuilder {
};

// Size: 0x290
class UInteractiveToolsContext : public UObject {
    /* 0x0058 */ UInputRouter* InputRouter;
    /* 0x0060 */ UToolTargetManager* TargetManager;
    /* 0x0068 */ UInteractiveToolManager* ToolManager;
    /* 0x0070 */ UInteractiveGizmoManager* GizmoManager;
    /* 0x0078 */ UContextObjectStore* ContextObjectStore;
    /* 0x0260 */ TSoftClassPtr<UInteractiveToolManager> ToolManagerClass;
};

// Size: 0x2b0
class AInternalToolFrameworkActor : public AActor {
    /* 0x02a8 */ bool bIsSelectableInEditor;
};

// Size: 0x210
class UIntervalGizmo : public UInteractiveGizmo {
    /* 0x0038 */ UGizmoTransformChangeStateTarget* StateTarget;
    /* 0x0088 */ UWorld* World;
    /* 0x0090 */ AIntervalGizmoActor* GizmoActor;
    /* 0x0098 */ UTransformProxy* TransformProxy;
    /* 0x00a0 */ TArray<UPrimitiveComponent*> ActiveComponents;
    /* 0x00b0 */ TArray<UInteractiveGizmo*> ActiveGizmos;
    /* 0x00c0 */ UGizmoLocalFloatParameterSource* UpIntervalSource;
    /* 0x00c8 */ UGizmoLocalFloatParameterSource* DownIntervalSource;
    /* 0x00d0 */ UGizmoLocalFloatParameterSource* ForwardIntervalSource;
    /* 0x00d8 */ UGizmoLocalFloatParameterSource* BackwardIntervalSource;
    /* 0x00e0 */ UGizmoLocalFloatParameterSource* RightIntervalSource;
    /* 0x00e8 */ UGizmoLocalFloatParameterSource* LeftIntervalSource;
    /* 0x00f0 */ UGizmoComponentAxisSource* AxisXSource;
    /* 0x00f8 */ UGizmoComponentAxisSource* AxisYSource;
    /* 0x0100 */ UGizmoComponentAxisSource* AxisZSource;
};

// Size: 0x2e0
class AIntervalGizmoActor : public AGizmoActor {
    /* 0x02b0 */ UGizmoLineHandleComponent* UpIntervalComponent;
    /* 0x02b8 */ UGizmoLineHandleComponent* DownIntervalComponent;
    /* 0x02c0 */ UGizmoLineHandleComponent* ForwardIntervalComponent;
    /* 0x02c8 */ UGizmoLineHandleComponent* BackwardIntervalComponent;
    /* 0x02d0 */ UGizmoLineHandleComponent* RightIntervalComponent;
    /* 0x02d8 */ UGizmoLineHandleComponent* LeftIntervalComponent;
};

// Size: 0xa0
class UIntervalGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x98
class UKeyAsModifierInputBehavior : public UInputBehavior {
};

// Size: 0x100
class UKeyInputBehavior : public UInputBehavior {
};

// Size: 0x20
struct FKeyboardInputDeviceState {
    /* 0x0000 */ FDeviceButtonState ActiveKey;
};

// Size: 0x210
class ULocalClickDragInputBehavior : public UClickDragInputBehavior {
};

// Size: 0x1b0
class ULocalDoubleClickInputBehavior : public UDoubleClickInputBehavior {
};

// Size: 0x60
class ULocalInputBehaviorSource : public UObject {
};

// Size: 0x1c0
class ULocalMouseHoverBehavior : public UMouseHoverBehavior {
};

// Size: 0x1b0
class ULocalSingleClickInputBehavior : public USingleClickInputBehavior {
};

// Size: 0x250
class ULocalTwoAxisPropertyEditInputBehavior : public UTwoAxisPropertyEditInputBehavior {
};

// Size: 0x28
class IMaterialProvider : public UInterface {
};

// Size: 0x28
class IMeshDescriptionCommitter : public UInterface {
};

// Size: 0x28
class IMeshDescriptionProvider : public UInterface {
};

// Size: 0x80
class UMeshSelectionSet : public USelectionSet {
    /* 0x0040 */ TArray<int32_t> Vertices;
    /* 0x0050 */ TArray<int32_t> Edges;
    /* 0x0060 */ TArray<int32_t> Faces;
    /* 0x0070 */ TArray<int32_t> Groups;
};

// Size: 0x100
class UMeshSurfacePointTool : public USingleSelectionTool {
    /* 0x00f8 */ TWeakObjectPtr<UWorld> TargetWorld;
};

// Size: 0x30
class UMeshSurfacePointToolBuilder : public UInteractiveToolWithToolTargetsBuilder {
};

// Size: 0xd0
class UMouseHoverBehavior : public UInputBehavior {
};

// Size: 0xb8
struct FMouseInputDeviceState {
    /* 0x0000 */ FDeviceButtonState Left;
    /* 0x0020 */ FDeviceButtonState Middle;
    /* 0x0040 */ FDeviceButtonState Right;
    /* 0x0060 */ float WheelDelta;
    /* 0x0068 */ FVector2D Position2D;
    /* 0x0078 */ FVector2D Delta2D;
    /* 0x0088 */ FRay WorldRay;
};

// Size: 0x110
class UMouseWheelInputBehavior : public UAnyButtonInputBehavior {
};

// Size: 0x140
class UMultiClickSequenceInputBehavior : public UAnyButtonInputBehavior {
};

// Size: 0xb0
class UMultiSelectionTool : public UInteractiveTool {
    /* 0x00a0 */ TArray<UToolTarget*> Targets;
};

// Size: 0x28
class IPhysicsDataSource : public UInterface {
};

// Size: 0x280
class UPlanePositionGizmo : public UInteractiveGizmo {
    /* 0x0048 */ TScriptInterface<IGizmoAxisSource> AxisSource;
    /* 0x0058 */ TScriptInterface<IGizmoVec2ParameterSource> ParameterSource;
    /* 0x0068 */ TScriptInterface<IGizmoClickTarget> HitTarget;
    /* 0x0078 */ TScriptInterface<IGizmoStateTarget> StateTarget;
    /* 0x0088 */ UClickDragInputBehavior* MouseBehavior;
    /* 0x0090 */ bool bEnableSignedAxis;
    /* 0x0091 */ bool bFlipX;
    /* 0x0092 */ bool bFlipY;
    /* 0x0100 */ bool bInInteraction;
    /* 0x0108 */ FVector InteractionOrigin;
    /* 0x0120 */ FVector InteractionNormal;
    /* 0x0138 */ FVector InteractionAxisX;
    /* 0x0150 */ FVector InteractionAxisY;
    /* 0x0168 */ FVector InteractionStartPoint;
    /* 0x0180 */ FVector InteractionCurPoint;
    /* 0x0198 */ FVector2D InteractionStartParameter;
    /* 0x01a8 */ FVector2D InteractionCurParameter;
    /* 0x01b8 */ FVector2D ParameterSigns;
};

// Size: 0x28
class UPlanePositionGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x28
class UPrimitiveComponentBackedTarget : public ISceneComponentBackedTarget {
};

// Size: 0x38
class UPrimitiveComponentToolTarget : public UToolTarget {
};

// Size: 0x28
class UPrimitiveComponentToolTargetFactory : public UToolTargetFactory {
};

// Size: 0x5c0
class URepositionableTransformGizmo : public UCombinedTransformGizmo {
    /* 0x05b0 */ UGizmoTransformChangeStateTarget* RepositionStateTarget;
};

// Size: 0xd0
class URepositionableTransformGizmoBuilder : public UCombinedTransformGizmoBuilder {
};

// Size: 0xf0
class UScalableSphereGizmo : public UInteractiveGizmo {
    /* 0x0070 */ float HitErrorThreshold;
    /* 0x0078 */ FText TransactionDescription;
    /* 0x0088 */ float Radius;
    /* 0x008c */ bool bIsHovering;
    /* 0x008d */ bool bIsDragging;
    /* 0x0090 */ UTransformProxy* ActiveTarget;
    /* 0x0098 */ FVector ActiveAxis;
    /* 0x00b0 */ FVector DragStartWorldPosition;
    /* 0x00c8 */ FVector DragCurrentPositionProjected;
    /* 0x00e0 */ float InteractionStartParameter;
};

// Size: 0x28
class UScalableSphereGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0xc0
class UScalableSphereGizmoInputBehavior : public UAnyButtonInputBehavior {
};

// Size: 0x28
class ISceneComponentBackedTarget : public UInterface {
};

// Size: 0x38
class USceneComponentToolTarget : public UToolTarget {
};

// Size: 0x28
class USceneComponentToolTargetFactory : public UToolTargetFactory {
};

// Size: 0x28
class USceneSnappingManager : public UObject {
};

// Size: 0x40
class USelectionSet : public UObject {
};

// Size: 0x60
class USimpleLambdaInteractiveGizmoBuilder : public UInteractiveGizmoBuilder {
};

// Size: 0x78
class USimpleSingleClickGizmo : public UInteractiveGizmo {
    /* 0x0060 */ TScriptInterface<IGizmoClickTarget> HitTarget;
    /* 0x0070 */ USingleClickInputBehavior* ClickBehavior;
};

// Size: 0x110
class USingleClickInputBehavior : public UAnyButtonInputBehavior {
    /* 0x00a0 */ bool HitTestOnRelease;
};

// Size: 0x160
class USingleClickOrDragInputBehavior : public UAnyButtonInputBehavior {
    /* 0x0100 */ bool bBeginDragIfClickTargetNotHit;
    /* 0x0104 */ float ClickDistanceThreshold;
};

// Size: 0xa0
class USingleClickTool : public UInteractiveTool {
};

// Size: 0x28
class USingleClickToolBuilder : public UInteractiveToolBuilder {
};

// Size: 0x100
class USingleKeyCaptureBehavior : public UInputBehavior {
};

// Size: 0xa8
class USingleSelectionTool : public UInteractiveTool {
    /* 0x00a0 */ UToolTarget* Target;
};

// Size: 0x28
class USkeletalMeshBackedTarget : public IAssetBackedTarget {
};

// Size: 0x28
class UStaticMeshBackedTarget : public IAssetBackedTarget {
};

// Size: 0x28
class IToolContextTransactionProvider : public UInterface {
};

// Size: 0x28
class IToolFrameworkComponent : public UInterface {
};

// Size: 0x28
class UToolTarget : public UObject {
};

// Size: 0x28
class UToolTargetFactory : public UObject {
};

// Size: 0x40
class UToolTargetManager : public UObject {
    /* 0x0030 */ TArray<UToolTargetFactory*> Factories;
};

// Size: 0x30
class UToolsContextCursorAPI : public UObject {
};

// Size: 0x1b0
class UTransformProxy : public UObject {
    /* 0x00d0 */ bool bRotatePerObject;
    /* 0x00d1 */ bool bSetPivotMode;
    /* 0x00f0 */ FTransform SharedTransform;
    /* 0x0150 */ FTransform InitialSharedTransform;
};

// Size: 0x70
class UTwoAxisPropertyEditInputBehavior : public UInputBehavior {
};

// Size: 0x680
class UViewAdjustedStaticMeshGizmoComponent : public UStaticMeshComponent {
    /* 0x0618 */ UGizmoViewContext* GizmoViewContext;
    /* 0x0620 */ UPrimitiveComponent* SubstituteInteractionComponent;
    /* 0x0628 */ UMaterialInterface* HoverOverrideMaterial;
};

// Size: 0x28
class IWidgetBaseBehavior : public UInterface {
};

enum class EInterchangeMaterialXBSDF {
    OrenNayarDiffuse = 0,
    BurleyDiffuse = 1,
    Translucent = 2,
    Dielectric = 3,
    Conductor = 4,
    GeneralizedSchlick = 5,
    Subsurface = 6,
    Sheen = 7,
    ThinFilm = 8,
    MaxBSDFCount = 9,
    EInterchangeMaterialXBSDF_MAX = 10,
};

enum class EInterchangeMaterialXEDF {
    Uniform = 0,
    Conical = 1,
    Measured = 2,
    MaxEDFCount = 3,
    EInterchangeMaterialXEDF_MAX = 4,
};

enum class EInterchangeMaterialXShaders {
    OpenPBRSurface = 0,
    OpenPBRSurfaceTransmission = 1,
    StandardSurface = 2,
    StandardSurfaceTransmission = 3,
    SurfaceUnlit = 4,
    UsdPreviewSurface = 5,
    Surface = 6,
    Displacement = 7,
    MaxShaderCount = 8,
    EInterchangeMaterialXShaders_MAX = 9,
};

enum class EInterchangeMaterialXVDF {
    Absorption = 0,
    Anisotropic = 1,
    MaxVDFCount = 2,
    EInterchangeMaterialXVDF_MAX = 3,
};

enum class EInterchangeSparseVolumeTextureFormat {
    Unorm8 = 0,
    Float16 = 1,
    Float32 = 2,
    EInterchangeSparseVolumeTextureFormat_MAX = 3,
};

enum class EInterchangeUsdPrimvar {
    Standard = 0,
    Bake = 1,
    All = 2,
    EInterchangeUsdPrimvar_MAX = 3,
};

enum class EInterchangeCurveInterpMode {
    Linear = 0,
    Constant = 1,
    Cubic = 2,
    None = 3,
    EInterchangeCurveInterpMode_MAX = 4,
};

enum class EInterchangeCurveTangentMode {
    Auto = 0,
    User = 1,
    Break = 2,
    None = 3,
    EInterchangeCurveTangentMode_MAX = 4,
};

enum class EInterchangeCurveTangentWeightMode {
    WeightedNone = 0,
    WeightedArrive = 1,
    WeightedLeave = 2,
    WeightedBoth = 3,
    EInterchangeCurveTangentWeightMode_MAX = 4,
};

// Size: 0x10
struct FInterchangeCurve {
    /* 0x0000 */ TArray<FInterchangeCurveKey> Keys;
};

// Size: 0x1c
struct FInterchangeCurveKey {
    /* 0x0000 */ EInterchangeCurveInterpMode InterpMode;
    /* 0x0001 */ EInterchangeCurveTangentMode TangentMode;
    /* 0x0002 */ EInterchangeCurveTangentWeightMode TangentWeightMode;
    /* 0x0004 */ float Time;
    /* 0x0008 */ float Value;
    /* 0x000c */ float ArriveTangent;
    /* 0x0010 */ float ArriveTangentWeight;
    /* 0x0014 */ float LeaveTangent;
    /* 0x0018 */ float LeaveTangentWeight;
};

// Size: 0x60
struct FInterchangeStepCurve {
    /* 0x0000 */ TArray<float> KeyTimes;
};

enum class EInterchangeFactoryAssetType {
    None = 0,
    Textures = 1,
    Materials = 2,
    Meshes = 3,
    Animations = 4,
    Physics = 5,
    EInterchangeFactoryAssetType_MAX = 6,
};

enum class EInterchangeNodeContainerType {
    None = 0,
    TranslatedScene = 1,
    TranslatedAsset = 2,
    FactoryData = 3,
    EInterchangeNodeContainerType_MAX = 4,
};

enum class EInterchangeNodeUserInterfaceContext {
    None = 0,
    Preview = 1,
    EInterchangeNodeUserInterfaceContext_MAX = 2,
};

enum class EInterchangePipelineContext {
    None = 0,
    AssetImport = 1,
    AssetReimport = 2,
    SceneImport = 3,
    SceneReimport = 4,
    AssetCustomLODImport = 5,
    AssetCustomLODReimport = 6,
    AssetAlternateSkinningImport = 7,
    AssetAlternateSkinningReimport = 8,
    AssetCustomMorphTargetImport = 9,
    AssetCustomMorphTargetReImport = 10,
    EInterchangePipelineContext_MAX = 11,
};

enum class EInterchangePipelineTask {
    PostTranslator = 0,
    PostFactory = 1,
    PostImport = 2,
    Export = 3,
    EInterchangePipelineTask_MAX = 4,
};

enum class EInterchangeResultType {
    Success = 0,
    Warning = 1,
    Error = 2,
    EInterchangeResultType_MAX = 3,
};

enum class EInterchangeTranslatorAssetType {
    None = 0,
    Textures = 1,
    Materials = 2,
    Meshes = 4,
    Animations = 8,
    EInterchangeTranslatorAssetType_MAX = 9,
};

enum class EInterchangeTranslatorType {
    Invalid = 0,
    Assets = 2,
    Actors = 4,
    Scenes = 6,
    EInterchangeTranslatorType_MAX = 7,
};

enum class EReimportStrategyFlags {
    ApplyNoProperties = 0,
    ApplyPipelineProperties = 1,
    ApplyEditorChangedProperties = 2,
    EReimportStrategyFlags_MAX = 3,
};

// Size: 0x60
class UInterchangeBaseNode : public UObject {

    bool AddBooleanAttribute(FString NodeAttributeKey, const bool& Value);
    bool AddDoubleAttribute(FString NodeAttributeKey, const double& Value);
    bool AddFloatAttribute(FString NodeAttributeKey, const float& Value);
    bool AddGuidAttribute(FString NodeAttributeKey, const FGuid& Value);
    bool AddInt32Attribute(FString NodeAttributeKey, const int32_t& Value);
    bool AddLinearColorAttribute(FString NodeAttributeKey, const FLinearColor& Value);
    bool AddStringAttribute(FString NodeAttributeKey, FString Value);
    bool AddTargetNodeUid(FString AssetUid) const;
    bool AddVector2Attribute(FString NodeAttributeKey, const FVector2f& Value);
    FString GetAssetName() const;
    bool GetBooleanAttribute(FString NodeAttributeKey, bool& OutValue) const;
    int32_t GetDesiredChildIndex() const;
    FString GetDisplayLabel() const;
    bool GetDoubleAttribute(FString NodeAttributeKey, double& OutValue) const;
    bool GetFloatAttribute(FString NodeAttributeKey, float& OutValue) const;
    bool GetGuidAttribute(FString NodeAttributeKey, FGuid& OutValue) const;
    FName GetIconName() const;
    bool GetInt32Attribute(FString NodeAttributeKey, int32_t& OutValue) const;
    bool GetLinearColorAttribute(FString NodeAttributeKey, FLinearColor& OutValue) const;
    bool GetNameSpace(FString& Namespace) const;
    EInterchangeNodeContainerType GetNodeContainerType() const;
    FString GetParentUid() const;
    bool GetStringAttribute(FString NodeAttributeKey, FString& OutValue) const;
    int32_t GetTargetNodeCount() const;
    void GetTargetNodeUids(TArray<FString>& OutTargetAssets) const;
    FString GetTypeName() const;
    FString GetUniqueID() const;
    bool GetVector2Attribute(FString NodeAttributeKey, FVector2f& OutValue) const;
    void InitializeNode(FString UniqueID, FString DisplayLabel, const EInterchangeNodeContainerType NodeContainerType);
    bool IsEnabled() const;
    bool RemoveAttribute(FString NodeAttributeKey);
    bool RemoveTargetNodeUid(FString AssetUid) const;
    bool SetAssetName(FString AssetName);
    bool SetDisplayLabel(FString DisplayName);
    bool SetEnabled(const bool bIsEnabled);
};

// Size: 0xc8
class UInterchangeBaseNodeContainer : public UObject {
    /* 0x0028 */ TMap<FString, UInterchangeBaseNode*> Nodes;

    FString AddNode(UInterchangeBaseNode* Node);
    bool ClearNodeParentUid(FString NodeUniqueID);
    void ComputeChildrenCache();
    UInterchangeFactoryBaseNode* GetFactoryNode(FString NodeUniqueID) const;
    bool GetIsAncestor(FString NodeUniqueID, FString AncestorUID) const;
    UInterchangeBaseNode* GetNode(FString NodeUniqueID) const;
    UInterchangeBaseNode* GetNodeChildren(FString NodeUniqueID, int32_t ChildIndex);
    int32_t GetNodeChildrenCount(FString NodeUniqueID) const;
    TArray<FString> GetNodeChildrenUids(FString NodeUniqueID) const;
    void GetNodes(const UClass* ClassNode, TArray<FString>& OutNodes) const;
    void GetRoots(TArray<FString>& RootNodes) const;
    bool IsNodeUidValid(FString NodeUniqueID) const;
    void LoadFromFile(FString Filename);
    void RemoveNode(FString NodeUniqueID);
    void ReplaceNode(FString NodeUniqueID, UInterchangeFactoryBaseNode* NewNode);
    void Reset();
    void ResetChildrenCache();
    void SaveToFile(FString Filename);
    void SetNamespace(FString Namespace, UClass* TargetClass);
    bool SetNodeDesiredChildIndex(FString NodeUniqueID, const int32_t& NewNodeDesiredChildIndex);
    bool SetNodeParentUid(FString NodeUniqueID, FString NewParentNodeUid);
};

// Size: 0x30
class UInterchangeFactoryBase : public UObject {
    /* 0x0028 */ UInterchangeResultsContainer* Results;

    EInterchangeFactoryAssetType GetFactoryAssetType();
    UClass* GetFactoryClass() const;
    bool GetSourceFilenames(const UObject* Object, TArray<FString>& OutSourceFilenames) const;
    bool SetSourceFilename(const UObject* Object, FString SourceFilename, int32_t SourceIndex) const;
};

// Size: 0x1c0
class UInterchangeFactoryBaseNode : public UInterchangeBaseNode {
    /* 0x0140 */ TSet<FString> AttributesAppliedThroughDelegatesKeySet;

    bool AddFactoryDependencyUid(FString DependencyUid);
    bool GetCustomLevelUid(FString& AttributeValue) const;
    bool GetCustomReferenceObject(FSoftObjectPath& AttributeValue) const;
    bool GetCustomSubPath(FString& AttributeValue) const;
    void GetFactoryDependencies(TArray<FString>& OutDependencies) const;
    int32_t GetFactoryDependenciesCount() const;
    void GetFactoryDependency(const int32_t Index, FString& OutDependency) const;
    UClass* GetObjectClass() const;
    EReimportStrategyFlags GetReimportStrategyFlags() const;
    bool IsRuntimeImportAllowed() const;
    bool RemoveFactoryDependencyUid(FString DependencyUid);
    bool SetCustomLevelUid(FString AttributeValue);
    bool SetCustomReferenceObject(const FSoftObjectPath& AttributeValue);
    bool SetCustomSubPath(FString AttributeValue);
    bool SetForceNodeReimport();
    bool SetReimportStrategyFlags(const EReimportStrategyFlags& ReimportStrategyFlags);
    bool SetSkipNodeImport();
    bool ShouldForceNodeReimport() const;
    bool ShouldSkipNodeImport() const;
    bool UnsetForceNodeReimport();
    bool UnsetSkipNodeImport();
};

// Size: 0x128
class UInterchangePipelineBase : public UObject {
    /* 0x0028 */ FString DestinationName;
    /* 0x0038 */ FString ContentImportPath;
    /* 0x0048 */ bool bAllowPropertyStatesEdition;
    /* 0x0049 */ bool bIsReimportContext;
    /* 0x004a */ bool bIsShowEssentials;
    /* 0x004b */ bool bFromReimportOrOverride;
    /* 0x0050 */ UInterchangeResultsContainer* Results;
    /* 0x0058 */ TMap<FName, FInterchangePipelinePropertyStates> PropertiesStates;
    /* 0x00a8 */ TMap<FName, FInterchangePipelinePropertyStates> CachePropertiesStates;
    /* 0x00f8 */ FInterchangePipelineContextParams CacheContextParam;

    bool DoesPropertyStatesExist(const FName PropertyPath) const;
    FInterchangePipelinePropertyStates FindOrAddPropertyStates(const FName PropertyPath);
    bool IsReimportContext();
    void ScriptedExecuteExportPipeline(UInterchangeBaseNodeContainer* BaseNodeContainer);
    void ScriptedExecutePipeline(UInterchangeBaseNodeContainer* BaseNodeContainer, const TArray<UInterchangeSourceData*>& SourceDatas, FString ContentBasePath);
    void ScriptedExecutePostBroadcastPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, FString FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    void ScriptedExecutePostFactoryPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, FString FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    void ScriptedExecutePostImportPipeline(const UInterchangeBaseNodeContainer* BaseNodeContainer, FString FactoryNodeKey, UObject* CreatedAsset, bool bIsAReimport);
    FString ScriptedGetPipelineDisplayName() const;
    void ScriptedSetReimportSourceIndex(UClass* ReimportObjectClass, const int32_t SourceFileIndex);
    bool SupportReimport() const;
};

// Size: 0x20
struct FInterchangePipelineContextParams {
    /* 0x0000 */ EInterchangePipelineContext ContextType;
    /* 0x0008 */ UClass* ImportObjectType;
    /* 0x0010 */ UObject* ReimportAsset;
    /* 0x0018 */ UInterchangeBaseNodeContainer* BaseNodeContainer;
};

// Size: 0x1
struct FInterchangePipelinePropertyStatePerContext {
    /* 0x0000 */ bool bVisible;
};

// Size: 0x5
struct FInterchangePipelinePropertyStates {
    /* 0x0000 */ bool bLocked;
    /* 0x0001 */ bool bPreDialogReset;
    /* 0x0002 */ FInterchangePipelinePropertyStatePerContext BasicLayoutStates;
    /* 0x0003 */ FInterchangePipelinePropertyStatePerContext ImportStates;
    /* 0x0004 */ FInterchangePipelinePropertyStatePerContext ReimportStates;
};

// Size: 0x70
class UInterchangeResult : public UObject {
    /* 0x0028 */ FString SourceAssetName;
    /* 0x0038 */ FString DestinationAssetName;
    /* 0x0048 */ FString AssetFriendlyName;
    /* 0x0058 */ UClass* AssetType;
    /* 0x0060 */ FString InterchangeKey;
};

// Size: 0x80
class UInterchangeResultDisplay_Generic : public UInterchangeResultSuccess {
    /* 0x0070 */ FText Text;
};

// Size: 0x70
class UInterchangeResultError : public UInterchangeResult {
};

// Size: 0x80
class UInterchangeResultError_Generic : public UInterchangeResultError {
    /* 0x0070 */ FText Text;
};

// Size: 0x70
class UInterchangeResultError_ReimportFail : public UInterchangeResultError {
};

// Size: 0x70
class UInterchangeResultSuccess : public UInterchangeResult {
};

// Size: 0x70
class UInterchangeResultWarning : public UInterchangeResult {
};

// Size: 0x80
class UInterchangeResultWarning_Generic : public UInterchangeResultWarning {
    /* 0x0070 */ FText Text;
};

// Size: 0x60
class UInterchangeResultsContainer : public UObject {
    /* 0x0050 */ TArray<UInterchangeResult*> Results;
};

// Size: 0xa0
class UInterchangeSourceData : public UObject {
    /* 0x0028 */ FString Filename;
    /* 0x0050 */ TMap<FString, UObject*> ContextObjectsByTag;

    TArray<FString> GetAllContextObjectTags() const;
    UObject* GetContextObjectByTag(FString Tag) const;
    FString GetFilename() const;
    void RemoveAllContextObjects() const;
    void SetContextObjectByTag(FString Tag, UObject* Object) const;
    bool SetFilename(FString InFilename);
};

// Size: 0x198
class UInterchangeSourceNode : public UInterchangeBaseNode {

    bool GetCustomAnimatedTimeEnd(double& AttributeValue) const;
    bool GetCustomAnimatedTimeStart(double& AttributeValue) const;
    bool GetCustomAxisConversionInverseTransform(FTransform& AxisConversionInverseTransform) const;
    bool GetCustomImportUnusedMaterial(bool& AttributeValue) const;
    bool GetCustomReimportStrategyFlags(uint8_t& StrategyFlag) const;
    bool GetCustomSourceFrameRateDenominator(int32_t& AttributeValue) const;
    bool GetCustomSourceFrameRateNumerator(int32_t& AttributeValue) const;
    bool GetCustomSourceTimelineEnd(double& AttributeValue) const;
    bool GetCustomSourceTimelineStart(double& AttributeValue) const;
    bool GetCustomSubPathPrefix(FString& Prefix) const;
    bool GetCustomUseAssetTypeSubPathSuffix(bool& Suffix) const;
    bool GetCustomUseLegacySkeletalMeshBakeTransform(bool& AttributeValue) const;
    void GetExtraInformation(TMap<FString, FString>& OutExtraInformation) const;
    static UInterchangeSourceNode* GetUniqueInstance(const UInterchangeBaseNodeContainer* NodeContainer);
    void InitializeSourceNode(FString UniqueID, FString DisplayLabel, UInterchangeBaseNodeContainer* NodeContainer);
    bool RemoveExtraInformation(FString Name);
    bool SetCustomAnimatedTimeEnd(const double& AttributeValue);
    bool SetCustomAnimatedTimeStart(const double& AttributeValue);
    bool SetCustomAxisConversionInverseTransform(const FTransform& AxisConversionInverseTransform);
    bool SetCustomImportUnusedMaterial(const bool& AttributeValue);
    bool SetCustomReimportStrategyFlags(uint8_t StrategyFlag);
    bool SetCustomSourceFrameRateDenominator(const int32_t& AttributeValue);
    bool SetCustomSourceFrameRateNumerator(const int32_t& AttributeValue);
    bool SetCustomSourceTimelineEnd(const double& AttributeValue);
    bool SetCustomSourceTimelineStart(const double& AttributeValue);
    bool SetCustomSubPathPrefix(FString Prefix);
    bool SetCustomUseAssetTypeSubPathSuffix(const bool& Suffix);
    bool SetCustomUseLegacySkeletalMeshBakeTransform(const bool& AttributeValue);
    bool SetExtraInformation(FString Name, FString Value);
};

// Size: 0x48
class UInterchangeTranslatorBase : public UObject {
    /* 0x0028 */ UInterchangeResultsContainer* Results;
    /* 0x0030 */ UInterchangeSourceData* SourceData;

    bool CanImportSourceData(const UInterchangeSourceData* InSourceData) const;
    UInterchangeTranslatorSettings* GetSettings() const;
    UInterchangeSourceData* GetSourceData() const;
    EInterchangeTranslatorAssetType GetSupportedAssetTypes() const;
    TArray<FString> GetSupportedFormats() const;
    EInterchangeTranslatorType GetTranslatorType() const;
    void SetSettings(const UInterchangeTranslatorSettings* InterchangeTranslatorSettings);
};

// Size: 0x28
class UInterchangeTranslatorSettings : public UObject {

    void LoadSettings();
    void SaveSettings();
};

// Size: 0x30
struct FInterchangeUserDefinedAttributeInfo {
    /* 0x0000 */ FString Name;
};

// Size: 0x28
class UInterchangeUserDefinedAttributesAPI : public UObject {

    static bool CreateUserDefinedAttribute_Boolean(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, const bool& Value, FString PayloadKey, bool RequiresDelegate);
    static bool CreateUserDefinedAttribute_Double(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, const double& Value, FString PayloadKey, bool RequiresDelegate);
    static bool CreateUserDefinedAttribute_FString(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, FString Value, FString PayloadKey, bool RequiresDelegate);
    static bool CreateUserDefinedAttribute_Float(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, const float& Value, FString PayloadKey, bool RequiresDelegate);
    static bool CreateUserDefinedAttribute_Int32(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, const int32_t& Value, FString PayloadKey, bool RequiresDelegate);
    static void DuplicateAllUserDefinedAttribute(const UInterchangeBaseNode* InterchangeSourceNode, UInterchangeBaseNode* InterchangeDestinationNode, bool bAddSourceNodeName);
    static void GetUserDefinedAttributeInfos(const UInterchangeBaseNode* InterchangeNode, TArray<FInterchangeUserDefinedAttributeInfo>& UserDefinedAttributeInfos);
    static bool GetUserDefinedAttribute_Boolean(const UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, bool& OutValue, FString& OutPayloadKey);
    static bool GetUserDefinedAttribute_Double(const UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, double& OutValue, FString& OutPayloadKey);
    static bool GetUserDefinedAttribute_FString(const UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, FString& OutValue, FString& OutPayloadKey);
    static bool GetUserDefinedAttribute_Float(const UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, float& OutValue, FString& OutPayloadKey);
    static bool GetUserDefinedAttribute_Int32(const UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName, int32_t& OutValue, FString& OutPayloadKey);
    static bool RemoveUserDefinedAttribute(UInterchangeBaseNode* InterchangeNode, FString UserDefinedAttributeName);
};

// Size: 0x28
class UInterchangeWriterBase : public UObject {
};

enum class EInterchangePipelineConfigurationDialogResult {
    Cancel = 0,
    Import = 1,
    ImportAll = 2,
    SaveConfig = 3,
    EInterchangePipelineConfigurationDialogResult_MAX = 4,
};

// Size: 0xc8
struct FImportAssetParameters {
    /* 0x0000 */ UObject* ReimportAsset;
    /* 0x0008 */ int32_t ReimportSourceIndex;
    /* 0x000c */ bool bIsAutomated;
    /* 0x000d */ bool bFollowRedirectors;
    /* 0x0010 */ TArray<FSoftObjectPath> OverridePipelines;
    /* 0x0020 */ ULevel* ImportLevel;
    /* 0x0028 */ FString DestinationName;
    /* 0x0038 */ bool bReplaceExisting;
    /* 0x0039 */ bool bForceShowDialog;
    /* 0x003c */ FDelegate OnAssetDone;
    /* 0x0060 */ FDelegate OnAssetsImportDone;
    /* 0x0080 */ FDelegate OnSceneObjectDone;
    /* 0x00a0 */ FDelegate OnSceneImportDone;
};

// Size: 0xd8
class UInterchangeAssetImportData : public UAssetImportData {
    /* 0x0028 */ FSoftObjectPath SceneImportAsset;
    /* 0x0048 */ FString NodeUniqueID;
    /* 0x0058 */ UInterchangeBaseNodeContainer* NodeContainer;
    /* 0x0060 */ TArray<UObject*> Pipelines;
    /* 0x0070 */ UInterchangeBaseNodeContainer* TransientNodeContainer;
    /* 0x0078 */ TArray<UObject*> TransientPipelines;
    /* 0x0088 */ UInterchangeTranslatorSettings* TransientTranslatorSettings;

    UInterchangeBaseNodeContainer* GetNodeContainer() const;
    int32_t GetNumberOfPipelines() const;
    TArray<UObject*> GetPipelines() const;
    UInterchangeFactoryBaseNode* GetStoredFactoryNode(FString InNodeUniqueId) const;
    UInterchangeBaseNode* GetStoredNode(FString InNodeUniqueId) const;
    UInterchangeTranslatorSettings* GetTranslatorSettings() const;
    TArray<FString> ScriptExtractDisplayLabels() const;
    TArray<FString> ScriptExtractFilenames() const;
    FString ScriptGetFirstFilename() const;
    void SetNodeContainer(UInterchangeBaseNodeContainer* InNodeContainer) const;
    void SetPipelines(const TArray<UObject*>& InPipelines);
    void SetTranslatorSettings(UInterchangeTranslatorSettings* TranslatorSettings) const;
};

// Size: 0x28
class UInterchangeAssetImportDataConverterBase : public UObject {
};

// Size: 0xa8
class UInterchangeBlueprintPipelineBase : public UBlueprint {
};

// Size: 0x128
struct FInterchangeContentImportSettings : public FInterchangeImportSettings {
    /* 0x0088 */ TMap<EInterchangeTranslatorAssetType, FName> DefaultPipelineStackOverride;
    /* 0x00d8 */ TMap<EInterchangeTranslatorAssetType, FInterchangeDialogOverride> ShowImportDialogOverride;
};

// Size: 0x18
struct FInterchangeDialogOverride {
    /* 0x0000 */ bool bShowImportDialog;
    /* 0x0001 */ bool bShowReimportDialog;
    /* 0x0008 */ TArray<FInterchangePerTranslatorDialogOverride> PerTranslatorImportDialogOverride;
};

// Size: 0x58
class UInterchangeEditorSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bShowImportDialogAtReimport;
    /* 0x003c */ FName UsedGroupName;
    /* 0x0044 */ FGuid UsedGroupUID;

    TArray<FName> GetSelectableItems() const;
    FName GetUsedGroupName() const;
    void SetUsedGroupName(const FName& InUsedGroupName);
};

// Size: 0x28
class UInterchangeEditorUtilitiesBase : public UObject {
};

// Size: 0x28
class UInterchangeFilePickerBase : public UObject {

    bool ScriptedFilePickerForTranslatorAssetType(const EInterchangeTranslatorAssetType TranslatorAssetType, FInterchangeFilePickerParameters& Parameters, TArray<FString>& OutFilenames);
    bool ScriptedFilePickerForTranslatorType(const EInterchangeTranslatorType TranslatorType, FInterchangeFilePickerParameters& Parameters, TArray<FString>& OutFilenames);
};

// Size: 0x40
struct FInterchangeFilePickerParameters {
    /* 0x0000 */ bool bAllowMultipleFiles;
    /* 0x0008 */ FText Title;
    /* 0x0018 */ FString DefaultPath;
    /* 0x0028 */ bool bShowAllFactoriesExtension;
    /* 0x0030 */ TArray<FString> ExtraFormats;
};

// Size: 0xc8
struct FInterchangeGroup {
    /* 0x0000 */ FName DisplayName;
    /* 0x0008 */ FGuid UniqueID;
    /* 0x0018 */ FName DefaultPipelineStack;
    /* 0x0020 */ TMap<EInterchangeTranslatorAssetType, FName> DefaultPipelineStackOverride;
    /* 0x0070 */ bool bShowImportDialog;
    /* 0x0071 */ bool bShowReimportDialog;
    /* 0x0078 */ TMap<EInterchangeTranslatorAssetType, FInterchangeDialogOverride> ShowImportDialogOverride;
};

// Size: 0x88
struct FInterchangeImportSettings {
    /* 0x0000 */ TMap<FName, FInterchangePipelineStack> PipelineStacks;
    /* 0x0050 */ FName DefaultPipelineStack;
    /* 0x0058 */ TSoftClassPtr<UInterchangePipelineConfigurationBase> ImportDialogClass;
    /* 0x0080 */ bool bShowImportDialog;
    /* 0x0081 */ bool bShowReimportDialog;
};

// Size: 0x400
class UInterchangeManager : public UObject {
    /* 0x0238 */ TSet<UClass*> RegisteredTranslatorsClass;
    /* 0x0288 */ TMap<UClass*, UClass*> RegisteredFactoryClasses;
    /* 0x02d8 */ TMap<UClass*, UInterchangeWriterBase*> RegisteredWriters;
    /* 0x0328 */ TMap<UClass*, UInterchangeAssetImportDataConverterBase*> RegisteredConverters;

    bool CanReimport(const UObject* Object, TArray<FString>& OutFilenames) const;
    bool CanTranslateSourceData(const UInterchangeSourceData* SourceData, bool bSceneImportOnly) const;
    void CancelAllTasks();
    static UInterchangeSourceData* CreateSourceData(FString InFilename);
    bool ExportAsset(const UObject* Asset, bool bIsAutomated);
    bool ExportScene(const UObject* World, bool bIsAutomated);
    UInterchangeAssetImportData* GetAssetImportData(UObject* Asset) const;
    static UInterchangeManager* GetInterchangeManagerScripted();
    UClass* GetRegisteredFactoryClass(const UClass* ClassToMake) const;
    TArray<FString> GetSupportedAssetTypeFormats(const EInterchangeTranslatorAssetType ForTranslatorAssetType, const EInterchangeTranslatorType ForTranslatorType, bool bStrictMatchTranslatorType) const;
    TArray<FString> GetSupportedFormats(const EInterchangeTranslatorType ForTranslatorType) const;
    TArray<FString> GetSupportedFormatsForObject(const UObject* Object, int32_t SourceFileIndex) const;
    UInterchangeTranslatorBase* GetTranslatorForSourceData(const UInterchangeSourceData* SourceData) const;
    bool ImportAsset(FString ContentPath, const UInterchangeSourceData* SourceData, const FImportAssetParameters& ImportAssetParameters, TArray<UObject*>& OutImportedObjects);
    bool ImportScene(FString ContentPath, const UInterchangeSourceData* SourceData, const FImportAssetParameters& ImportAssetParameters);
    bool IsInterchangeActive();
    bool IsObjectBeingImported(UObject* Object) const;
    bool ReimportAsset(UObject* ObjectToReimport, const FImportAssetParameters& ImportAssetParameters, TArray<UObject*>& OutImportedObjects);
    bool ScriptedImportAssetAsync(FString ContentPath, const UInterchangeSourceData* SourceData, const FImportAssetParameters& ImportAssetParameters);
    bool ScriptedImportSceneAsync(FString ContentPath, const UInterchangeSourceData* SourceData, const FImportAssetParameters& ImportAssetParameters);
    bool ScriptedReimportAssetAsync(UObject* ObjectToReimport, const FImportAssetParameters& ImportAssetParameters);
    void WaitUntilAllTasksDone(bool bCancel);
    bool WarnIfInterchangeIsActive();
};

// Size: 0x28
class UInterchangeMeshUtilities : public UObject {

    bool ScriptedImportMorphTarget(USkeletalMesh* SkeletalMesh, const int32_t LODIndex, const UInterchangeSourceData* SourceData, FString MorphTargetName) const;
};

// Size: 0x30
struct FInterchangePerTranslatorDialogOverride {
    /* 0x0000 */ TSoftClassPtr<UInterchangeTranslatorBase> Translator;
    /* 0x0028 */ bool bShowImportDialog;
    /* 0x0029 */ bool bShowReimportDialog;
};

// Size: 0x28
class UInterchangePipelineConfigurationBase : public UObject {

    EInterchangePipelineConfigurationDialogResult ScriptedShowPipelineConfigurationDialog(TArray<FInterchangeStackInfo>& PipelineStacks, TArray<UInterchangePipelineBase*>& OutPipelines, UInterchangeSourceData* SourceData, UInterchangeTranslatorBase* Translator, UInterchangeBaseNodeContainer* BaseNodeContainer);
    EInterchangePipelineConfigurationDialogResult ScriptedShowReimportPipelineConfigurationDialog(TArray<FInterchangeStackInfo>& PipelineStacks, TArray<UInterchangePipelineBase*>& OutPipelines, UInterchangeSourceData* SourceData, UInterchangeTranslatorBase* Translator, UInterchangeBaseNodeContainer* BaseNodeContainer, UObject* ReimportAsset, bool bSceneImport);
    EInterchangePipelineConfigurationDialogResult ScriptedShowScenePipelineConfigurationDialog(TArray<FInterchangeStackInfo>& PipelineStacks, TArray<UInterchangePipelineBase*>& OutPipelines, UInterchangeSourceData* SourceData, UInterchangeTranslatorBase* Translator, UInterchangeBaseNodeContainer* BaseNodeContainer);
    EInterchangePipelineConfigurationDialogResult ScriptedShowTestPlanConfigurationDialog(TArray<FInterchangeStackInfo>& PipelineStacks, TArray<UInterchangePipelineBase*>& OutPipelines, UInterchangeSourceData* SourceData, UInterchangeTranslatorBase* Translator, UInterchangeBaseNodeContainer* BaseNodeContainer, UObject* ReimportAsset, bool bSceneImport, bool bReimport);
};

// Size: 0x20
struct FInterchangePipelineStack {
    /* 0x0000 */ TArray<FSoftObjectPath> Pipelines;
    /* 0x0010 */ TArray<FInterchangeTranslatorPipelines> PerTranslatorPipelines;
};

// Size: 0x38
class UInterchangePipelineStackOverride : public UObject {
    /* 0x0028 */ TArray<FSoftObjectPath> OverridePipelines;

    void AddBlueprintPipeline(UInterchangeBlueprintPipelineBase* PipelineBase);
    void AddPipeline(UInterchangePipelineBase* PipelineBase);
    void AddPythonPipeline(UInterchangePythonPipelineBase* PipelineBase);
};

// Size: 0x280
class UInterchangeProjectSettings : public UDeveloperSettings {
    /* 0x0038 */ FInterchangeContentImportSettings ContentImportSettings;
    /* 0x0160 */ FInterchangeSceneImportSettings SceneImportSettings;
    /* 0x01f8 */ TSoftClassPtr<UInterchangeFilePickerBase> FilePickerClass;
    /* 0x0220 */ bool bStaticMeshUseSmoothEdgesIfSmoothingInformationIsMissing;
    /* 0x0228 */ TSoftClassPtr<UInterchangePipelineBase> GenericPipelineClass;
    /* 0x0250 */ FSoftObjectPath ConverterDefaultPipeline;
    /* 0x0270 */ TArray<FInterchangeGroup> InterchangeGroups;
};

// Size: 0x68
class UInterchangePythonPipelineAsset : public UObject {
    /* 0x0028 */ TSoftClassPtr<UInterchangePythonPipelineBase> PythonClass;
    /* 0x0050 */ UInterchangePythonPipelineBase* GeneratedPipeline;
    /* 0x0058 */ FString JsonDefaultProperties;
};

// Size: 0x128
class UInterchangePythonPipelineBase : public UInterchangePipelineBase {
};

// Size: 0x30
class UInterchangeSceneImportAsset : public UObject {
};

// Size: 0x98
struct FInterchangeSceneImportSettings : public FInterchangeImportSettings {
    /* 0x0088 */ TArray<FInterchangePerTranslatorDialogOverride> PerTranslatorDialogOverride;
};

// Size: 0x18
struct FInterchangeStackInfo {
    /* 0x0000 */ FName StackName;
    /* 0x0008 */ TArray<UInterchangePipelineBase*> Pipelines;
};

// Size: 0x38
struct FInterchangeTranslatorPipelines {
    /* 0x0000 */ TSoftClassPtr<UInterchangeTranslatorBase> Translator;
    /* 0x0028 */ TArray<FSoftObjectPath> Pipelines;
};

// Size: 0x18
struct FPropertyData {
};

// Size: 0x28
class UInterchangeTextureWriter : public UInterchangeWriterBase {
};

enum class EInterchangeSkeletalMeshContentType {
    All = 0,
    Geometry = 1,
    SkinningWeights = 2,
    MAX = 3,
};

// Size: 0x260
class UInterchangeActorFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomActorClassName(FString& AttributeValue) const;
    bool GetCustomActorVisibility(bool& AttributeValue) const;
    bool GetCustomComponentVisibility(bool& AttributeValue) const;
    bool GetCustomGlobalTransform(FTransform& AttributeValue) const;
    bool GetCustomLocalTransform(FTransform& AttributeValue) const;
    bool GetCustomMobility(uint8_t& AttributeValue) const;
    bool SetCustomActorClassName(FString AttributeValue);
    bool SetCustomActorVisibility(bool AttributeValue, bool bAddApplyDelegate);
    bool SetCustomComponentVisibility(bool AttributeValue, bool bAddApplyDelegate);
    bool SetCustomGlobalTransform(const FTransform& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomLocalTransform(const FTransform& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMobility(const uint8_t& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x500
class UInterchangeAnimSequenceFactoryNode : public UInterchangeFactoryBaseNode {

    void GetAnimatedAttributeCurveName(const int32_t Index, FString& OutAttributeCurveName) const;
    void GetAnimatedAttributeCurveNames(TArray<FString>& OutAttributeCurveNames) const;
    int32_t GetAnimatedAttributeCurveNamesCount() const;
    void GetAnimatedAttributeStepCurveName(const int32_t Index, FString& OutAttributeStepCurveName) const;
    void GetAnimatedAttributeStepCurveNames(TArray<FString>& OutAttributeStepCurveNames) const;
    int32_t GetAnimatedAttributeStepCurveNamesCount() const;
    void GetAnimatedMaterialCurveSuffixe(const int32_t Index, FString& OutMaterialCurveSuffixe) const;
    void GetAnimatedMaterialCurveSuffixes(TArray<FString>& OutMaterialCurveSuffixes) const;
    int32_t GetAnimatedMaterialCurveSuffixesCount() const;
    bool GetCustomAddCurveMetadataToSkeleton(bool& AttributeValue) const;
    bool GetCustomDeleteExistingCustomAttributeCurves(bool& AttributeValue) const;
    bool GetCustomDeleteExistingMorphTargetCurves(bool& AttributeValue) const;
    bool GetCustomDeleteExistingNonCurveCustomAttributes(bool& AttributeValue) const;
    bool GetCustomDoNotImportCurveWithZero(bool& AttributeValue) const;
    bool GetCustomImportAttributeCurves(bool& AttributeValue) const;
    bool GetCustomImportBoneTracks(bool& AttributeValue) const;
    bool GetCustomImportBoneTracksRangeStart(double& AttributeValue) const;
    bool GetCustomImportBoneTracksRangeStop(double& AttributeValue) const;
    bool GetCustomImportBoneTracksSampleRate(double& AttributeValue) const;
    bool GetCustomMaterialDriveParameterOnCustomAttribute(bool& AttributeValue) const;
    bool GetCustomRemoveCurveRedundantKeys(bool& AttributeValue) const;
    bool GetCustomSkeletonFactoryNodeUid(FString& AttributeValue) const;
    bool GetCustomSkeletonSoftObjectPath(FSoftObjectPath& AttributeValue) const;
    void GetMorphTargetNodeAnimationPayloadKeys(TMap<FString, FInterchangeAnimationPayLoadKey>& OutMorphTargetNodeAnimationPayloads) const;
    void GetSceneNodeAnimationPayloadKeys(TMap<FString, FInterchangeAnimationPayLoadKey>& OutSceneNodeAnimationPayloadKeys) const;
    void InitializeAnimSequenceNode(FString UniqueID, FString DisplayLabel, UInterchangeBaseNodeContainer* NodeContainer);
    bool RemoveAnimatedAttributeCurveName(FString AttributeCurveName);
    bool RemoveAnimatedAttributeStepCurveName(FString AttributeStepCurveName);
    bool RemoveAnimatedMaterialCurveSuffixe(FString MaterialCurveSuffixe);
    bool SetAnimatedAttributeCurveName(FString AttributeCurveName);
    bool SetAnimatedAttributeStepCurveName(FString AttributeStepCurveName);
    bool SetAnimatedMaterialCurveSuffixe(FString MaterialCurveSuffixe);
    void SetAnimationPayloadKeysForMorphTargetNodeUids(const TMap<FString, FString>& MorphTargetAnimationPayloadKeyUids, const TMap<FString, uint8_t>& MorphTargetAnimationPayloadKeyTypes);
    void SetAnimationPayloadKeysForSceneNodeUids(const TMap<FString, FString>& SceneNodeAnimationPayloadKeyUids, const TMap<FString, uint8_t>& SceneNodeAnimationPayloadKeyTypes);
    bool SetCustomAddCurveMetadataToSkeleton(const bool& AttributeValue);
    bool SetCustomDeleteExistingCustomAttributeCurves(const bool& AttributeValue);
    bool SetCustomDeleteExistingMorphTargetCurves(const bool& AttributeValue);
    bool SetCustomDeleteExistingNonCurveCustomAttributes(const bool& AttributeValue);
    bool SetCustomDoNotImportCurveWithZero(const bool& AttributeValue);
    bool SetCustomImportAttributeCurves(const bool& AttributeValue);
    bool SetCustomImportBoneTracks(const bool& AttributeValue);
    bool SetCustomImportBoneTracksRangeStart(const double& AttributeValue);
    bool SetCustomImportBoneTracksRangeStop(const double& AttributeValue);
    bool SetCustomImportBoneTracksSampleRate(const double& AttributeValue);
    bool SetCustomMaterialDriveParameterOnCustomAttribute(const bool& AttributeValue);
    bool SetCustomRemoveCurveRedundantKeys(const bool& AttributeValue);
    bool SetCustomSkeletonFactoryNodeUid(FString AttributeValue);
    bool SetCustomSkeletonSoftObjectPath(const FSoftObjectPath& AttributeValue);
};

// Size: 0x2a0
class UInterchangeBaseLightFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomIntensity(float& AttributeValue) const;
    bool GetCustomLightColor(FColor& AttributeValue) const;
    bool GetCustomTemperature(float& AttributeValue) const;
    bool GetCustomUseTemperature(bool& AttributeValue) const;
    bool SetCustomIntensity(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomLightColor(const FColor& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomTemperature(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseTemperature(bool AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1d0
class UInterchangeBaseMaterialFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomIsMaterialImportEnabled(bool& AttributeValue) const;
    bool SetCustomIsMaterialImportEnabled(const bool& AttributeValue);
};

// Size: 0x1f0
class UInterchangeCommonPipelineDataFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetBakeMeshes(bool& AttributeValue) const;
    bool GetBakePivotMeshes(bool& AttributeValue) const;
    bool GetCustomGlobalOffsetTransform(FTransform& AttributeValue) const;
    bool SetBakeMeshes(const bool& AttributeValue);
    bool SetBakePivotMeshes(const bool& AttributeValue);
    bool SetCustomGlobalOffsetTransform(const UInterchangeBaseNodeContainer* NodeContainer, const FTransform& AttributeValue);
};

// Size: 0x290
class UInterchangeDecalActorFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomDecalMaterialPathName(FString& AttributeValue) const;
    bool GetCustomDecalSize(FVector& AttributeValue) const;
    bool GetCustomSortOrder(int32_t& AttributeValue) const;
    bool SetCustomDecalMaterialPathName(FString AttributeValue);
    bool SetCustomDecalSize(const FVector& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSortOrder(const int32_t& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1f0
class UInterchangeDecalMaterialFactoryNode : public UInterchangeBaseMaterialFactoryNode {

    bool GetCustomDiffuseTexturePath(FString& AttributeValue) const;
    bool GetCustomNormalTexturePath(FString& AttributeValue) const;
    bool SetCustomDiffuseTexturePath(FString AttributeValue);
    bool SetCustomNormalTexturePath(FString AttributeValue);
};

// Size: 0x2a0
class UInterchangeDirectionalLightFactoryNode : public UInterchangeBaseLightFactoryNode {
};

// Size: 0x3f8
class UInterchangeGeometryCacheFactoryNode : public UInterchangeMeshFactoryNode {

    bool GetCustomApplyConstantTopologyOptimization(bool& AttributeValue) const;
    bool GetCustomEndFrame(int32_t& AttributeValue) const;
    bool GetCustomFlattenTracks(bool& AttributeValue) const;
    bool GetCustomMotionVectorsImport(EInterchangeMotionVectorsHandling& AttributeValue) const;
    bool GetCustomNumBitsForUVs(int32_t& AttributeValue) const;
    bool GetCustomOptimizeIndexBuffers(bool& AttributeValue) const;
    bool GetCustomPositionPrecision(float& AttributeValue) const;
    bool GetCustomStartFrame(int32_t& AttributeValue) const;
    bool GetCustomStoreImportedVertexNumbers(bool& AttributeValue) const;
    void InitializeGeometryCacheNode(FString UniqueID, FString DisplayLabel, FString InAssetClass, UInterchangeBaseNodeContainer* NodeContainer);
    bool SetCustomApplyConstantTopologyOptimization(const bool& AttributeValue);
    bool SetCustomEndFrame(const int32_t& AttributeValue);
    bool SetCustomFlattenTracks(const bool& AttributeValue);
    bool SetCustomMotionVectorsImport(EInterchangeMotionVectorsHandling AttributeValue);
    bool SetCustomNumBitsForUVs(const int32_t& AttributeValue);
    bool SetCustomOptimizeIndexBuffers(const bool& AttributeValue);
    bool SetCustomPositionPrecision(const float& AttributeValue);
    bool SetCustomStartFrame(const int32_t& AttributeValue);
    bool SetCustomStoreImportedVertexNumbers(const bool& AttributeValue);
};

// Size: 0x270
class UInterchangeHeterogeneousVolumeActorFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomVolumetricMaterialUid(FString& MaterialFactoryNodeUid) const;
    bool SetCustomVolumetricMaterialUid(FString MaterialFactoryNodeUid);
};

// Size: 0x220
class UInterchangeLevelFactoryNode : public UInterchangeFactoryBaseNode {

    bool AddCustomActorFactoryNodeUid(FString ActorFactoryNodeUid);
    void GetCustomActorFactoryNodeUid(const int32_t Index, FString& OutActorFactoryNodeUid) const;
    int32_t GetCustomActorFactoryNodeUidCount() const;
    void GetCustomActorFactoryNodeUids(TArray<FString>& OutActorFactoryNodeUids) const;
    bool GetCustomCreateWorldPartitionLevel(bool& AttributeValue) const;
    bool GetCustomSceneImportAssetFactoryNodeUid(FString& AttributeValue) const;
    bool GetCustomShouldCreateLevel(bool& AttributeValue) const;
    bool RemoveCustomActorFactoryNodeUid(FString ActorFactoryNodeUid);
    bool SetCustomCreateWorldPartitionLevel(const bool& AttributeValue);
    bool SetCustomSceneImportAssetFactoryNodeUid(FString AttributeValue);
    bool SetCustomShouldCreateLevel(const bool& AttributeValue);
};

// Size: 0x280
class UInterchangeLevelInstanceActorFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomLevelReference(FString& AttributeValue) const;
    bool SetCustomLevelReference(FString AttributeValue);
};

// Size: 0x1f0
class UInterchangeLevelSequenceFactoryNode : public UInterchangeFactoryBaseNode {

    bool AddCustomAnimationTrackUid(FString AnimationTrackUid);
    void GetCustomAnimationTrackUid(const int32_t Index, FString& OutAnimationTrackUid) const;
    int32_t GetCustomAnimationTrackUidCount() const;
    void GetCustomAnimationTrackUids(TArray<FString>& OutAnimationTrackUids) const;
    bool GetCustomFrameRate(float& AttributeValue) const;
    bool RemoveCustomAnimationTrackUid(FString AnimationTrackUid);
    bool SetCustomFrameRate(const float& AttributeValue);
};

// Size: 0x300
class UInterchangeLightFactoryNode : public UInterchangeBaseLightFactoryNode {

    bool GetCustomAttenuationRadius(float& AttributeValue) const;
    bool GetCustomIESBrightnessScale(float& AttributeValue) const;
    bool GetCustomIESTexture(FString& AttributeValue) const;
    bool GetCustomIntensityUnits(ELightUnits& AttributeValue) const;
    bool GetCustomRotation(FRotator& AttributeValue) const;
    bool GetCustomUseIESBrightness(bool& AttributeValue) const;
    bool SetCustomAttenuationRadius(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomIESBrightnessScale(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomIESTexture(FString AttributeValue);
    bool SetCustomIntensityUnits(ELightUnits AttributeValue, bool bAddApplyDelegate);
    bool SetCustomRotation(const FRotator& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseIESBrightness(const bool& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1d0
class UInterchangeMaterialExpressionFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomExpressionClassName(FString& AttributeValue) const;
    bool SetCustomExpressionClassName(FString AttributeValue);
};

// Size: 0x250
class UInterchangeMaterialFactoryNode : public UInterchangeBaseMaterialFactoryNode {

    bool ConnectOutputToAnisotropy(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToBaseColor(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToClearCoat(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToClearCoatNormal(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToClearCoatRoughness(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToCloth(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToDisplacement(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToEmissiveColor(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToFuzzColor(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToMetallic(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToNormal(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToOcclusion(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToOpacity(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToRefraction(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToRoughness(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToSpecular(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToSubsurface(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToSurfaceCoverage(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToTangent(FString ExpressionNodeUid, FString OutputName);
    bool ConnectOutputToTransmissionColor(FString ExpressionNodeUid, FString OutputName);
    bool ConnectToAnisotropy(FString ExpressionNodeUid);
    bool ConnectToBaseColor(FString AttributeValue);
    bool ConnectToClearCoat(FString AttributeValue);
    bool ConnectToClearCoatNormal(FString AttributeValue);
    bool ConnectToClearCoatRoughness(FString AttributeValue);
    bool ConnectToCloth(FString AttributeValue);
    bool ConnectToDisplacement(FString AttributeValue);
    bool ConnectToEmissiveColor(FString ExpressionNodeUid);
    bool ConnectToFuzzColor(FString AttributeValue);
    bool ConnectToMetallic(FString AttributeValue);
    bool ConnectToNormal(FString ExpressionNodeUid);
    bool ConnectToOcclusion(FString AttributeValue);
    bool ConnectToOpacity(FString AttributeValue);
    bool ConnectToRefraction(FString AttributeValue);
    bool ConnectToRoughness(FString ExpressionNodeUid);
    bool ConnectToSpecular(FString ExpressionNodeUid);
    bool ConnectToSubsurface(FString ExpressionNodeUid);
    bool ConnectToSurfaceCoverage(FString ExpressionUid);
    bool ConnectToTangent(FString ExpressionNodeUid);
    bool ConnectToTransmissionColor(FString AttributeValue);
    bool GetAnisotropyConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetBaseColorConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetClearCoatConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetClearCoatNormalConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetClearCoatRoughnessConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetClothConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetCustomBlendMode(uint8_t& AttributeValue) const;
    bool GetCustomDisplacementCenter(float& AttributeValue) const;
    bool GetCustomOpacityMaskClipValue(float& AttributeValue) const;
    bool GetCustomRefractionMethod(uint8_t& AttributeValue) const;
    bool GetCustomScreenSpaceReflections(bool& AttributeValue) const;
    bool GetCustomShadingModel(uint8_t& AttributeValue) const;
    bool GetCustomTranslucencyLightingMode(uint8_t& AttributeValue) const;
    bool GetCustomTwoSided(bool& AttributeValue) const;
    bool GetDisplacementConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetEmissiveColorConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetFuzzColorConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetMetallicConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetNormalConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetOcclusionConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetOpacityConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetRefractionConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetRoughnessConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetSpecularConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetSubsurfaceConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetSurfaceCoverageConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetTangentConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool GetTransmissionColorConnection(FString& ExpressionNodeUid, FString& OutputName) const;
    bool SetCustomBlendMode(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDisplacementCenter(float AttributeValue);
    bool SetCustomOpacityMaskClipValue(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomRefractionMethod(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomScreenSpaceReflections(const bool& AttributeValue);
    bool SetCustomShadingModel(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomTranslucencyLightingMode(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomTwoSided(const bool& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1e0
class UInterchangeMaterialFunctionCallExpressionFactoryNode : public UInterchangeMaterialExpressionFactoryNode {

    bool GetCustomMaterialFunctionDependency(FString& AttributeValue) const;
    bool SetCustomMaterialFunctionDependency(FString AttributeValue);
};

// Size: 0x1d0
class UInterchangeMaterialFunctionFactoryNode : public UInterchangeBaseMaterialFactoryNode {

    bool GetInputConnection(FString InputName, FString& ExpressionNodeUid, FString& OutputName) const;
};

// Size: 0x1f0
class UInterchangeMaterialInstanceFactoryNode : public UInterchangeBaseMaterialFactoryNode {

    bool GetCustomInstanceClassName(FString& AttributeValue) const;
    bool GetCustomParent(FString& AttributeValue) const;
    bool SetCustomInstanceClassName(FString AttributeValue);
    bool SetCustomParent(FString AttributeValue);
};

// Size: 0x1d0
class UInterchangeMaterialReferenceFactoryNode : public UInterchangeBaseMaterialFactoryNode {
};

// Size: 0x308
class UInterchangeMeshActorFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomAnimationAssetUidToPlay(FString& AttributeValue) const;
    bool GetCustomGeometricTransform(FTransform& AttributeValue) const;
    bool GetCustomInstancedAssetFactoryNodeUid(FString& AttributeValue) const;
    void GetSlotMaterialDependencies(TMap<FString, FString>& OutMaterialDependencies) const;
    bool GetSlotMaterialDependencyUid(FString SlotName, FString& OutMaterialDependency) const;
    bool RemoveSlotMaterialDependencyUid(FString SlotName);
    bool SetCustomAnimationAssetUidToPlay(FString AttributeValue);
    bool SetCustomGeometricTransform(const FTransform& AttributeValue);
    bool SetCustomInstancedAssetFactoryNodeUid(FString AttributeValue);
    bool SetSlotMaterialDependencyUid(FString SlotName, FString MaterialDependencyUid);
};

// Size: 0x350
class UInterchangeMeshFactoryNode : public UInterchangeFactoryBaseNode {

    bool AddLodDataUniqueId(FString LodDataUniqueId);
    bool AddPayloadKeyBooleanAttribute(FString PayloadAttributeKey, bool Value);
    bool AddPayloadKeyDoubleAttribute(FString PayloadAttributeKey, double Value);
    bool AddPayloadKeyFloatAttribute(FString PayloadAttributeKey, float Value);
    bool AddPayloadKeyInt32Attribute(FString PayloadAttributeKey, int32_t Value);
    bool AddPayloadKeyStringAttribute(FString PayloadAttributeKey, FString Value);
    bool GetCustomComputeWeightedNormals(bool& AttributeValue) const;
    bool GetCustomImportSockets(bool& AttributeValue) const;
    bool GetCustomKeepSectionsSeparate(bool& AttributeValue) const;
    bool GetCustomLODGroup(FName& AttributeValue) const;
    bool GetCustomRecomputeNormals(bool& AttributeValue) const;
    bool GetCustomRecomputeTangents(bool& AttributeValue) const;
    bool GetCustomRemoveDegenerates(bool& AttributeValue) const;
    bool GetCustomUseBackwardsCompatibleF16TruncUVs(bool& AttributeValue) const;
    bool GetCustomUseFullPrecisionUVs(bool& AttributeValue) const;
    bool GetCustomUseHighPrecisionTangentBasis(bool& AttributeValue) const;
    bool GetCustomUseMikkTSpace(bool& AttributeValue) const;
    bool GetCustomVertexColorIgnore(bool& AttributeValue) const;
    bool GetCustomVertexColorOverride(FColor& AttributeValue) const;
    bool GetCustomVertexColorReplace(bool& AttributeValue) const;
    int32_t GetLodDataCount() const;
    void GetLodDataUniqueIds(TArray<FString>& OutLodDataUniqueIds) const;
    bool GetPayloadKeyBooleanAttribute(FString PayloadAttributeKey, bool& Value);
    bool GetPayloadKeyDoubleAttribute(FString PayloadAttributeKey, double& Value);
    bool GetPayloadKeyFloatAttribute(FString PayloadAttributeKey, float& Value);
    bool GetPayloadKeyInt32Attribute(FString PayloadAttributeKey, int32_t& Value);
    bool GetPayloadKeyStringAttribute(FString PayloadAttributeKey, FString& Value);
    void GetSlotMaterialDependencies(TMap<FString, FString>& OutMaterialDependencies) const;
    bool GetSlotMaterialDependencyUid(FString SlotName, FString& OutMaterialDependency) const;
    bool RemoveLodDataUniqueId(FString LodDataUniqueId);
    bool RemoveSlotMaterialDependencyUid(FString SlotName);
    bool ResetSlotMaterialDependencies();
    bool SetCustomComputeWeightedNormals(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomImportSockets(const bool& AttributeValue);
    bool SetCustomKeepSectionsSeparate(const bool& AttributeValue);
    bool SetCustomLODGroup(const FName& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomRecomputeNormals(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomRecomputeTangents(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomRemoveDegenerates(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseBackwardsCompatibleF16TruncUVs(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseFullPrecisionUVs(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseHighPrecisionTangentBasis(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseMikkTSpace(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomVertexColorIgnore(const bool& AttributeValue);
    bool SetCustomVertexColorOverride(const FColor& AttributeValue);
    bool SetCustomVertexColorReplace(const bool& AttributeValue);
    bool SetSlotMaterialDependencyUid(FString SlotName, FString MaterialDependencyUid);
};

// Size: 0x2a0
class UInterchangePhysicalCameraFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomFocalLength(float& AttributeValue) const;
    bool GetCustomFocusMethod(ECameraFocusMethod& AttributeValue) const;
    bool GetCustomSensorHeight(float& AttributeValue) const;
    bool GetCustomSensorWidth(float& AttributeValue) const;
    bool SetCustomFocalLength(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomFocusMethod(const ECameraFocusMethod& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSensorHeight(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSensorWidth(const float& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1f0
class UInterchangePhysicsAssetFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomSkeletalMeshUid(FString& AttributeValue) const;
    void InitializePhysicsAssetNode(FString UniqueID, FString DisplayLabel, FString InAssetClass, UInterchangeBaseNodeContainer* NodeContainer);
    bool SetCustomSkeletalMeshUid(FString AttributeValue);
};

// Size: 0x320
class UInterchangePointLightFactoryNode : public UInterchangeLightFactoryNode {

    bool GetCustomLightFalloffExponent(float& AttributeValue) const;
    bool GetCustomUseInverseSquaredFalloff(bool& AttributeValue) const;
    bool SetCustomLightFalloffExponent(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseInverseSquaredFalloff(bool AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x320
class UInterchangeRectLightFactoryNode : public UInterchangeLightFactoryNode {

    bool GetCustomSourceHeight(float& AttributeValue) const;
    bool GetCustomSourceWidth(float& AttributeValue) const;
    bool SetCustomSourceHeight(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSourceWidth(float AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1c0
class UInterchangeSceneImportAssetFactoryNode : public UInterchangeFactoryBaseNode {
};

// Size: 0x1e0
class UInterchangeSceneVariantSetsFactoryNode : public UInterchangeFactoryBaseNode {

    bool AddCustomVariantSetUid(FString VariantUid);
    void GetCustomVariantSetUid(const int32_t Index, FString& OutVariantUid) const;
    int32_t GetCustomVariantSetUidCount() const;
    void GetCustomVariantSetUids(TArray<FString>& OutVariantUids) const;
    bool RemoveCustomVariantSetUid(FString VariantUid);
};

// Size: 0x448
class UInterchangeSkeletalMeshFactoryNode : public UInterchangeMeshFactoryNode {

    bool GetCustomAddCurveMetadataToSkeleton(bool& AttributeValue) const;
    bool GetCustomBoneInfluenceLimit(int32_t& AttributeValue) const;
    bool GetCustomCreatePhysicsAsset(bool& AttributeValue) const;
    bool GetCustomImportContentType(EInterchangeSkeletalMeshContentType& AttributeValue) const;
    bool GetCustomImportMorphTarget(bool& AttributeValue) const;
    bool GetCustomImportVertexAttributes(bool& AttributeValue) const;
    bool GetCustomMergeMorphTargetShapeWithSameName(bool& AttributeValue) const;
    bool GetCustomMorphThresholdPosition(float& AttributeValue) const;
    bool GetCustomPhysicAssetSoftObjectPath(FSoftObjectPath& AttributeValue) const;
    bool GetCustomSkeletonSoftObjectPath(FSoftObjectPath& AttributeValue) const;
    bool GetCustomThresholdPosition(float& AttributeValue) const;
    bool GetCustomThresholdTangentNormal(float& AttributeValue) const;
    bool GetCustomThresholdUV(float& AttributeValue) const;
    bool GetCustomUseHighPrecisionSkinWeights(bool& AttributeValue) const;
    void InitializeSkeletalMeshNode(FString UniqueID, FString DisplayLabel, FString InAssetClass, UInterchangeBaseNodeContainer* NodeContainer);
    bool SetCustomAddCurveMetadataToSkeleton(const bool& AttributeValue);
    bool SetCustomBoneInfluenceLimit(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCreatePhysicsAsset(const bool& AttributeValue);
    bool SetCustomImportContentType(const EInterchangeSkeletalMeshContentType& AttributeValue);
    bool SetCustomImportMorphTarget(const bool& AttributeValue);
    bool SetCustomImportVertexAttributes(const bool& AttributeValue);
    bool SetCustomMergeMorphTargetShapeWithSameName(const bool& AttributeValue);
    bool SetCustomMorphThresholdPosition(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomPhysicAssetSoftObjectPath(const FSoftObjectPath& AttributeValue);
    bool SetCustomSkeletonSoftObjectPath(const FSoftObjectPath& AttributeValue);
    bool SetCustomThresholdPosition(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomThresholdTangentNormal(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomThresholdUV(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseHighPrecisionSkinWeights(const bool& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x1f0
class UInterchangeSkeletalMeshLodDataNode : public UInterchangeFactoryBaseNode {

    bool AddMeshUid(FString MeshName);
    bool GetCustomSkeletonUid(FString& AttributeValue) const;
    void GetMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetMeshUidsCount() const;
    bool RemoveAllMeshes();
    bool RemoveMeshUid(FString MeshName);
    bool SetCustomSkeletonUid(FString AttributeValue);
};

// Size: 0x210
class UInterchangeSkeletonFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomRootJointUid(FString& AttributeValue) const;
    bool GetCustomSkeletalMeshFactoryNodeUid(FString& AttributeValue) const;
    bool GetCustomUseTimeZeroForBindPose(bool& AttributeValue) const;
    void InitializeSkeletonNode(FString UniqueID, FString DisplayLabel, FString InAssetClass, UInterchangeBaseNodeContainer* NodeContainer);
    bool SetCustomRootJointUid(FString AttributeValue);
    bool SetCustomSkeletalMeshFactoryNodeUid(FString AttributeValue);
    bool SetCustomUseTimeZeroForBindPose(const bool& AttributeValue);
};

// Size: 0x270
class UInterchangeSparseVolumeTextureFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomAnimationID(FString& OutAnimationID) const;
    bool GetCustomAttributesAChannelW(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesAChannelX(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesAChannelY(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesAChannelZ(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesAFormat(EInterchangeSparseVolumeTextureFormat& Format) const;
    bool GetCustomAttributesBChannelW(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesBChannelX(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesBChannelY(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesBChannelZ(FString& GridNameAndComponentIndex) const;
    bool GetCustomAttributesBFormat(EInterchangeSparseVolumeTextureFormat& Format) const;
    bool SetCustomAnimationID(FString InAnimationID);
    bool SetCustomAttributesAChannelW(FString GridNameAndComponentIndex);
    bool SetCustomAttributesAChannelX(FString GridNameAndComponentIndex);
    bool SetCustomAttributesAChannelY(FString GridNameAndComponentIndex);
    bool SetCustomAttributesAChannelZ(FString GridNameAndComponentIndex);
    bool SetCustomAttributesAFormat(EInterchangeSparseVolumeTextureFormat Format);
    bool SetCustomAttributesBChannelW(FString GridNameAndComponentIndex);
    bool SetCustomAttributesBChannelX(FString GridNameAndComponentIndex);
    bool SetCustomAttributesBChannelY(FString GridNameAndComponentIndex);
    bool SetCustomAttributesBChannelZ(FString GridNameAndComponentIndex);
    bool SetCustomAttributesBFormat(EInterchangeSparseVolumeTextureFormat Format);
};

// Size: 0x1e0
class UInterchangeSpecularProfileFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomFormat(ESpecularProfileFormat& Format) const;
    bool GetCustomTexture(FString& TextureUid) const;
    bool SetCustomFormat(ESpecularProfileFormat Format);
    bool SetCustomTexture(FString TextureUid);
};

// Size: 0x340
class UInterchangeSpotLightFactoryNode : public UInterchangePointLightFactoryNode {

    bool GetCustomInnerConeAngle(float& AttributeValue) const;
    bool GetCustomOuterConeAngle(float& AttributeValue) const;
    bool SetCustomInnerConeAngle(float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomOuterConeAngle(float AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x2c0
class UInterchangeStandardCameraFactoryNode : public UInterchangeActorFactoryNode {

    bool GetCustomAspectRatio(float& AttributeValue) const;
    bool GetCustomFarClipPlane(float& AttributeValue) const;
    bool GetCustomFieldOfView(float& AttributeValue) const;
    bool GetCustomNearClipPlane(float& AttributeValue) const;
    bool GetCustomProjectionMode(uint8_t& AttributeValue) const;
    bool GetCustomWidth(float& AttributeValue) const;
    bool SetCustomAspectRatio(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomFarClipPlane(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomFieldOfView(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomNearClipPlane(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomProjectionMode(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomWidth(const float& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x468
class UInterchangeStaticMeshFactoryNode : public UInterchangeMeshFactoryNode {

    bool AddSocketUid(FString SocketUid);
    bool AddSocketUids(const TArray<FString>& InSocketUids);
    bool GetCustomAutoComputeLODScreenSizes(bool& AttributeValue) const;
    bool GetCustomBuildNanite(bool& AttributeValue) const;
    bool GetCustomBuildReversedIndexBuffer(bool& AttributeValue) const;
    bool GetCustomBuildScale3D(FVector& AttributeValue) const;
    bool GetCustomDistanceFieldReplacementMesh(FSoftObjectPath& AttributeValue) const;
    bool GetCustomDistanceFieldResolutionScale(float& AttributeValue) const;
    bool GetCustomDstLightmapIndex(int32_t& AttributeValue) const;
    bool GetCustomGenerateDistanceFieldAsIfTwoSided(bool& AttributeValue) const;
    bool GetCustomGenerateLightmapUVs(bool& AttributeValue) const;
    bool GetCustomMaxLumenMeshCards(int32_t& AttributeValue) const;
    bool GetCustomMinLightmapResolution(int32_t& AttributeValue) const;
    bool GetCustomSrcLightmapIndex(int32_t& AttributeValue) const;
    bool GetCustomSupportFaceRemap(bool& AttributeValue) const;
    int32_t GetLODScreenSizeCount() const;
    void GetLODScreenSizes(TArray<float>& OutLODScreenSizes) const;
    int32_t GetSocketUidCount() const;
    void GetSocketUids(TArray<FString>& OutSocketUids) const;
    void InitializeStaticMeshNode(FString UniqueID, FString DisplayLabel, FString InAssetClass, UInterchangeBaseNodeContainer* NodeContainer);
    bool RemoveSocketUd(FString SocketUid);
    bool SetCustomAutoComputeLODScreenSizes(const bool& AttributeValue);
    bool SetCustomBuildNanite(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomBuildReversedIndexBuffer(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomBuildScale3D(const FVector& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDistanceFieldReplacementMesh(const FSoftObjectPath& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDistanceFieldResolutionScale(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDstLightmapIndex(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomGenerateDistanceFieldAsIfTwoSided(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomGenerateLightmapUVs(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMaxLumenMeshCards(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMinLightmapResolution(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSrcLightmapIndex(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomSupportFaceRemap(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetLODScreenSizes(const TArray<float>& InLODScreenSizes);
};

// Size: 0x400
class UInterchangeStaticMeshLodDataNode : public UInterchangeFactoryBaseNode {

    bool AddBoxCollisionMeshUid(FString ColliderMeshUid);
    bool AddBoxCollisionMeshUids(FString ColliderMeshUid, FString RenderMeshUid);
    bool AddCapsuleCollisionMeshUid(FString ColliderMeshUid);
    bool AddCapsuleCollisionMeshUids(FString ColliderMeshUid, FString RenderMeshUid);
    bool AddConvexCollisionMeshUid(FString ColliderMeshUid);
    bool AddConvexCollisionMeshUids(FString ColliderMeshUid, FString RenderMeshUid);
    bool AddMeshUid(FString MeshName);
    bool AddSphereCollisionMeshUid(FString ColliderMeshUid);
    bool AddSphereCollisionMeshUids(FString ColliderMeshUid, FString RenderMeshUid);
    void GetBoxColliderRenderMeshUid(FString InColliderMeshUid, FString& OutRenderMeshUid) const;
    TMap<FString, FString> GetBoxCollisionMeshMap() const;
    void GetBoxCollisionMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetBoxCollisionMeshUidsCount() const;
    void GetCapsuleColliderRenderMeshUid(FString InColliderMeshUid, FString& OutRenderMeshUid) const;
    TMap<FString, FString> GetCapsuleCollisionMeshMap() const;
    void GetCapsuleCollisionMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetCapsuleCollisionMeshUidsCount() const;
    void GetConvexColliderRenderMeshUid(FString InColliderMeshUid, FString& OutRenderMeshUid) const;
    TMap<FString, FString> GetConvexCollisionMeshMap() const;
    void GetConvexCollisionMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetConvexCollisionMeshUidsCount() const;
    bool GetForceCollisionPrimitiveGeneration(bool& bGenerate) const;
    bool GetImportCollision(bool& AttributeValue) const;
    bool GetImportCollisionType(EInterchangeMeshCollision& AttributeValue) const;
    void GetMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetMeshUidsCount() const;
    bool GetOneConvexHullPerUCX(bool& AttributeValue) const;
    void GetSphereColliderRenderMeshUid(FString InColliderMeshUid, FString& OutRenderMeshUid) const;
    TMap<FString, FString> GetSphereCollisionMeshMap() const;
    void GetSphereCollisionMeshUids(TArray<FString>& OutMeshNames) const;
    int32_t GetSphereCollisionMeshUidsCount() const;
    bool RemoveAllBoxCollisionMeshes();
    bool RemoveAllCapsuleCollisionMeshes();
    bool RemoveAllConvexCollisionMeshes();
    bool RemoveAllMeshes();
    bool RemoveAllSphereCollisionMeshes();
    bool RemoveBoxCollisionMeshUid(FString ColliderMeshUid);
    bool RemoveCapsuleCollisionMeshUid(FString ColliderMeshUid);
    bool RemoveConvexCollisionMeshUid(FString MeshName);
    bool RemoveMeshUid(FString MeshName);
    bool RemoveSphereCollisionMeshUid(FString ColliderMeshUid);
    bool SetForceCollisionPrimitiveGeneration(bool bGenerate);
    bool SetImportCollision(bool AttributeValue);
    bool SetImportCollisionType(EInterchangeMeshCollision AttributeValue);
    bool SetOneConvexHullPerUCX(bool AttributeValue);
};

// Size: 0x490
class UInterchangeTexture2DArrayFactoryNode : public UInterchangeTextureFactoryNode {

    bool GetCustomAddressX(uint8_t& AttributeValue) const;
    bool GetCustomAddressY(uint8_t& AttributeValue) const;
    bool GetCustomAddressZ(uint8_t& AttributeValue) const;
    bool SetCustomAddressZ(const uint8_t AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x4f8
class UInterchangeTexture2DFactoryNode : public UInterchangeTextureFactoryNode {

    bool GetCustomAddressX(uint8_t& AttributeValue) const;
    bool GetCustomAddressY(uint8_t& AttributeValue) const;
    bool GetSourceBlock(int32_t BlockIndex, FString& OutSourceFile) const;
    bool GetSourceBlockByCoordinates(int32_t X, int32_t Y, FString& OutSourceFile) const;
    TMap<int32_t, FString> GetSourceBlocks() const;
    bool SetCustomAddressX(const uint8_t AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAddressY(const uint8_t AttributeValue, bool bAddApplyDelegate);
    void SetSourceBlock(int32_t BlockIndex, FString InSourceFile);
    void SetSourceBlockByCoordinates(int32_t X, int32_t Y, FString InSourceFile);
    void SetSourceBlocks(const TMap<int32_t, FString>& InSourceBlocks);
};

// Size: 0x460
class UInterchangeTextureCubeArrayFactoryNode : public UInterchangeTextureFactoryNode {
};

// Size: 0x460
class UInterchangeTextureCubeFactoryNode : public UInterchangeTextureFactoryNode {
};

// Size: 0x460
class UInterchangeTextureFactoryNode : public UInterchangeFactoryBaseNode {

    bool GetCustomAdjustBrightness(float& AttributeValue) const;
    bool GetCustomAdjustBrightnessCurve(float& AttributeValue) const;
    bool GetCustomAdjustHue(float& AttributeValue) const;
    bool GetCustomAdjustMaxAlpha(float& AttributeValue) const;
    bool GetCustomAdjustMinAlpha(float& AttributeValue) const;
    bool GetCustomAdjustRGBCurve(float& AttributeValue) const;
    bool GetCustomAdjustSaturation(float& AttributeValue) const;
    bool GetCustomAdjustVibrance(float& AttributeValue) const;
    bool GetCustomAllowNonPowerOfTwo(bool& AttributeValue) const;
    bool GetCustomAlphaCoverageThresholds(FVector4& AttributeValue) const;
    bool GetCustomChromaKeyColor(FColor& AttributeValue) const;
    bool GetCustomChromaKeyThreshold(float& AttributeValue) const;
    bool GetCustomColorSpace(ETextureColorSpace& AttributeValue) const;
    bool GetCustomCompositePower(float& AttributeValue) const;
    bool GetCustomCompositeTextureMode(uint8_t& AttributeValue) const;
    bool GetCustomCompressionNoAlpha(bool& AttributeValue) const;
    bool GetCustomCompressionQuality(uint8_t& AttributeValue) const;
    bool GetCustomCompressionSettings(uint8_t& AttributeValue) const;
    bool GetCustomDeferCompression(bool& AttributeValue) const;
    bool GetCustomDownscale(float& AttributeValue) const;
    bool GetCustomDownscaleOptions(uint8_t& AttributeValue) const;
    bool GetCustomFilter(uint8_t& AttributeValue) const;
    bool GetCustomLODBias(int32_t& AttributeValue) const;
    bool GetCustomLODGroup(uint8_t& AttributeValue) const;
    bool GetCustomLossyCompressionAmount(uint8_t& AttributeValue) const;
    bool GetCustomMaxTextureSize(int32_t& AttributeValue) const;
    bool GetCustomMipGenSettings(uint8_t& AttributeValue) const;
    bool GetCustomMipLoadOptions(uint8_t& AttributeValue) const;
    bool GetCustomPaddingColor(FColor& AttributeValue) const;
    bool GetCustomPowerOfTwoMode(uint8_t& AttributeValue) const;
    bool GetCustomPreferCompressedSourceData(bool& AttributeValue) const;
    bool GetCustomSRGB(bool& AttributeValue) const;
    bool GetCustomTranslatedTextureNodeUid(FString& AttributeValue) const;
    bool GetCustomVirtualTextureStreaming(bool& AttributeValue) const;
    bool GetCustombChromaKeyTexture(bool& AttributeValue) const;
    bool GetCustombDoScaleMipsForAlphaCoverage(bool& AttributeValue) const;
    bool GetCustombFlipGreenChannel(bool& AttributeValue) const;
    bool GetCustombPreserveBorder(bool& AttributeValue) const;
    bool GetCustombUseLegacyGamma(bool& AttributeValue) const;
    void InitializeTextureNode(FString UniqueID, FString DisplayLabel, FString InAssetName, UInterchangeBaseNodeContainer* NodeContainer);
    bool SetCustomAdjustBrightness(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustBrightnessCurve(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustHue(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustMaxAlpha(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustMinAlpha(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustRGBCurve(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustSaturation(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAdjustVibrance(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomAllowNonPowerOfTwo(const bool& AttributeValue);
    bool SetCustomAlphaCoverageThresholds(const FVector4& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomChromaKeyColor(const FColor& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomChromaKeyThreshold(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomColorSpace(ETextureColorSpace AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCompositePower(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCompositeTextureMode(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCompressionNoAlpha(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCompressionQuality(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomCompressionSettings(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDeferCompression(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDownscale(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomDownscaleOptions(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomFilter(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomLODBias(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomLODGroup(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomLossyCompressionAmount(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMaxTextureSize(const int32_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMipGenSettings(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomMipLoadOptions(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomPaddingColor(const FColor& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomPowerOfTwoMode(const uint8_t& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomPreferCompressedSourceData(const bool& AttributeValue);
    bool SetCustomSRGB(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomTranslatedTextureNodeUid(FString AttributeValue);
    bool SetCustomVirtualTextureStreaming(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustombChromaKeyTexture(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustombDoScaleMipsForAlphaCoverage(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustombFlipGreenChannel(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustombPreserveBorder(const bool& AttributeValue, bool bAddApplyDelegate);
    bool SetCustombUseLegacyGamma(const bool& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x538
class UInterchangeTextureLightProfileFactoryNode : public UInterchangeTexture2DFactoryNode {

    bool GetCustomBrightness(float& AttributeValue) const;
    bool GetCustomTextureMultiplier(float& AttributeValue) const;
    bool SetCustomBrightness(const float AttributeValue, bool bAddApplyDelegate);
    bool SetCustomTextureMultiplier(const float AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x460
class UInterchangeVolumeTextureFactoryNode : public UInterchangeTextureFactoryNode {
};

enum class EMAterialXTextureSampleBlurKernel {
    Kernel1 = 0,
    Kernel3 = 1,
    Kernel5 = 2,
    Kernel7 = 3,
    EMAterialXTextureSampleBlurKernel_MAX = 4,
};

enum class EMaterialXLuminanceMode {
    ACEScg = 0,
    Rec709 = 1,
    Rec2020 = 2,
    Rec2100 = 2,
    Custom = 3,
    EMaterialXLuminanceMode_MAX = 4,
};

enum class EMaterialXTextureSampleBlurFilter {
    Box = 0,
    Gaussian = 1,
    EMaterialXTextureSampleBlurFilter_MAX = 2,
};

// Size: 0x30
class UInterchangeActorFactory : public UInterchangeFactoryBase {
};

// Size: 0x1d8
class UInterchangeAnimSequenceFactory : public UInterchangeFactoryBase {
};

// Size: 0x28
class IInterchangeAnimationPayloadInterface : public UInterface {
};

// Size: 0x78
class UInterchangeAssetUserData : public UAssetUserData {
    /* 0x0028 */ TMap<FString, FString> MetaData;
};

// Size: 0x28
class IInterchangeBlockedTexturePayloadInterface : public UInterface {
};

// Size: 0x30
class UInterchangeCameraActorFactory : public UInterchangeActorFactory {
};

// Size: 0x30
class UInterchangeCineCameraActorFactory : public UInterchangeActorFactory {
};

// Size: 0x58
class UInterchangeDDSTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x30
class UInterchangeDecalActorFactory : public UInterchangeActorFactory {
};

// Size: 0x88
class UInterchangeFbxTranslator : public UInterchangeTranslatorBase {
    /* 0x0068 */ UInterchangeFbxTranslatorSettings* CacheFbxTranslatorSettings;
};

// Size: 0x30
class UInterchangeFbxTranslatorSettings : public UInterchangeTranslatorSettings {
    /* 0x0028 */ bool bConvertScene;
    /* 0x0029 */ bool bForceFrontXAxis;
    /* 0x002a */ bool bConvertSceneUnit;
    /* 0x002b */ bool bKeepFbxNamespace;
};

// Size: 0x2b8
class UInterchangeGLTFTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x48
class UInterchangeGeometryCacheFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeHeterogeneousVolumeActorFactory : public UInterchangeActorFactory {
};

// Size: 0x50
class UInterchangeIESTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x58
class UInterchangeImageWrapperTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x50
class UInterchangeJPGTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x38
class UInterchangeLevelAssetUserData : public UAssetUserData {
    /* 0x0028 */ TArray<FSoftObjectPath> SceneImportPaths;
};

// Size: 0x30
class UInterchangeLevelFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeLevelInstanceActorFactory : public UInterchangeActorFactory {
};

// Size: 0x38
class UInterchangeLevelSequenceFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeLightActorFactory : public UInterchangeActorFactory {
};

// Size: 0x38
class UInterchangeMaterialFactory : public UInterchangeFactoryBase {
};

// Size: 0x38
class UInterchangeMaterialFunctionFactory : public UInterchangeFactoryBase {
};

// Size: 0x50
class UInterchangeMaterialXTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x28
class IInterchangeMeshPayloadInterface : public UInterface {
};

// Size: 0x60
class UInterchangeOBJTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x50
class UInterchangePSDTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x30
class UInterchangePhysicsAssetFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeSceneImportAssetFactory : public UInterchangeFactoryBase {
};

// Size: 0x38
class UInterchangeSceneVariantSetsFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeSkeletalMeshActorFactory : public UInterchangeActorFactory {
};

// Size: 0xd0
class UInterchangeSkeletalMeshFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeSkeletonFactory : public UInterchangeFactoryBase {
};

// Size: 0x28
class IInterchangeSlicedTexturePayloadInterface : public UInterface {
};

// Size: 0x48
class UInterchangeSparseVolumeTextureFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeSpecularProfileFactory : public UInterchangeFactoryBase {
};

// Size: 0x30
class UInterchangeStaticMeshActorFactory : public UInterchangeActorFactory {
};

// Size: 0x140
class UInterchangeStaticMeshFactory : public UInterchangeFactoryBase {
};

// Size: 0x108
class UInterchangeTextureFactory : public UInterchangeFactoryBase {
};

// Size: 0x28
class IInterchangeTextureLightProfilePayloadInterface : public UInterface {
};

// Size: 0x28
class IInterchangeTexturePayloadInterface : public UInterface {
};

// Size: 0x50
class UInterchangeUEJPEGTranslator : public UInterchangeTranslatorBase {
};

// Size: 0x28
class IInterchangeVariantSetPayloadInterface : public UInterface {
};

// Size: 0x28
class IInterchangeVolumePayloadInterface : public UInterface {
};

// Size: 0x40
class UInterchangeVolumeTranslatorSettings : public UInterchangeTranslatorSettings {
    /* 0x0028 */ bool bTranslateAdjacentNumberedFiles;
    /* 0x0030 */ FString AnimationID;
};

// Size: 0x128
class UMaterialExpressionMaterialXAppend3Vector : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput C;
};

// Size: 0x150
class UMaterialExpressionMaterialXAppend4Vector : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput C;
    /* 0x0128 */ FExpressionInput D;
};

// Size: 0x130
class UMaterialExpressionMaterialXBurn : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXContrast : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput amount;
    /* 0x0100 */ FExpressionInput Pivot;
    /* 0x0128 */ float ConstAmount;
    /* 0x012c */ float ConstPivot;
};

// Size: 0x130
class UMaterialExpressionMaterialXDifference : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXDisjointOver : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXDodge : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x1a8
class UMaterialExpressionMaterialXFractal3D : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput position;
    /* 0x00d8 */ FExpressionInput Amplitude;
    /* 0x0100 */ float ConstAmplitude;
    /* 0x0108 */ FExpressionInput Octaves;
    /* 0x0130 */ int32_t ConstOctaves;
    /* 0x0138 */ FExpressionInput Lacunarity;
    /* 0x0160 */ float ConstLacunarity;
    /* 0x0168 */ FExpressionInput Diminish;
    /* 0x0190 */ float ConstDiminish;
    /* 0x0194 */ float Scale;
    /* 0x0198 */ bool bTurbulence;
    /* 0x019c */ int32_t Levels;
    /* 0x01a0 */ float OutputMin;
    /* 0x01a4 */ float OutputMax;
};

// Size: 0x130
class UMaterialExpressionMaterialXIn : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0xf0
class UMaterialExpressionMaterialXLuminance : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FLinearColor LuminanceFactors;
    /* 0x00e8 */ EMaterialXLuminanceMode LuminanceMode;
};

// Size: 0x130
class UMaterialExpressionMaterialXMask : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXMatte : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXMinus : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x108
class UMaterialExpressionMaterialXMod : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ float ConstB;
};

// Size: 0x130
class UMaterialExpressionMaterialXOut : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXOver : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x130
class UMaterialExpressionMaterialXOverlay : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x180
class UMaterialExpressionMaterialXPlace2D : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput Pivot;
    /* 0x0100 */ FExpressionInput Scale;
    /* 0x0128 */ FExpressionInput Offset;
    /* 0x0150 */ FExpressionInput RotationAngle;
    /* 0x0178 */ float ConstRotationAngle;
    /* 0x017c */ uint8_t ConstCoordinate;
};

// Size: 0x130
class UMaterialExpressionMaterialXPlus : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0xd8
class UMaterialExpressionMaterialXPremult : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x180
class UMaterialExpressionMaterialXRamp4 : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput A;
    /* 0x0100 */ FExpressionInput B;
    /* 0x0128 */ FExpressionInput C;
    /* 0x0150 */ FExpressionInput D;
    /* 0x0178 */ uint8_t ConstCoordinate;
};

// Size: 0x130
class UMaterialExpressionMaterialXRampLeftRight : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput A;
    /* 0x0100 */ FExpressionInput B;
    /* 0x0128 */ uint8_t ConstCoordinate;
};

// Size: 0x130
class UMaterialExpressionMaterialXRampTopBottom : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput A;
    /* 0x0100 */ FExpressionInput B;
    /* 0x0128 */ uint8_t ConstCoordinate;
};

// Size: 0x1e0
class UMaterialExpressionMaterialXRange : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput InputLow;
    /* 0x0100 */ FExpressionInput InputHigh;
    /* 0x0128 */ FExpressionInput TargetLow;
    /* 0x0150 */ FExpressionInput TargetHigh;
    /* 0x0178 */ FExpressionInput Gamma;
    /* 0x01a0 */ FExpressionInput clamp;
    /* 0x01c8 */ float ConstInputLow;
    /* 0x01cc */ float ConstInputHigh;
    /* 0x01d0 */ float ConstTargetLow;
    /* 0x01d4 */ float ConstTargetHigh;
    /* 0x01d8 */ float ConstGamma;
    /* 0x01dc */ bool bConstClamp;
};

// Size: 0x188
class UMaterialExpressionMaterialXRemap : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput InputLow;
    /* 0x0100 */ FExpressionInput InputHigh;
    /* 0x0128 */ FExpressionInput TargetLow;
    /* 0x0150 */ FExpressionInput TargetHigh;
    /* 0x0178 */ float InputLowDefault;
    /* 0x017c */ float InputHighDefault;
    /* 0x0180 */ float TargetLowDefault;
    /* 0x0184 */ float TargetHighDefault;
};

// Size: 0x108
class UMaterialExpressionMaterialXRotate2D : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FExpressionInput RotationAngle;
    /* 0x0100 */ float ConstRotationAngle;
};

// Size: 0x130
class UMaterialExpressionMaterialXScreen : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput A;
    /* 0x00d8 */ FExpressionInput B;
    /* 0x0100 */ FExpressionInput Alpha;
    /* 0x0128 */ float ConstAlpha;
};

// Size: 0x158
class UMaterialExpressionMaterialXSplitLeftRight : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput A;
    /* 0x0100 */ FExpressionInput B;
    /* 0x0128 */ FExpressionInput Center;
    /* 0x0150 */ float ConstCenter;
    /* 0x0154 */ uint8_t ConstCoordinate;
};

// Size: 0x158
class UMaterialExpressionMaterialXSplitTopBottom : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Coordinates;
    /* 0x00d8 */ FExpressionInput A;
    /* 0x0100 */ FExpressionInput B;
    /* 0x0128 */ FExpressionInput Center;
    /* 0x0150 */ float ConstCenter;
    /* 0x0154 */ uint8_t ConstCoordinate;
};

// Size: 0xe8
class UMaterialExpressionMaterialXSwizzle : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
    /* 0x00d8 */ FString Channels;
};

// Size: 0x238
class UMaterialExpressionMaterialXTextureSampleParameterBlur : public UMaterialExpressionTextureSampleParameter2D {
    /* 0x0228 */ EMAterialXTextureSampleBlurKernel KernelSize;
    /* 0x022c */ float FilterSize;
    /* 0x0230 */ float FilterOffset;
    /* 0x0234 */ EMaterialXTextureSampleBlurFilter Filter;
};

// Size: 0xd8
class UMaterialExpressionMaterialXUnpremult : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput Input;
};

// Size: 0x80
class UInterchangeResultMeshError : public UInterchangeResultError {
    /* 0x0070 */ FString MeshName;
};

// Size: 0x90
class UInterchangeResultMeshError_Generic : public UInterchangeResultMeshError {
    /* 0x0080 */ FText Text;
};

// Size: 0x80
class UInterchangeResultMeshWarning : public UInterchangeResultWarning {
    /* 0x0070 */ FString MeshName;
};

// Size: 0x90
class UInterchangeResultMeshWarning_Generic : public UInterchangeResultMeshWarning {
    /* 0x0080 */ FText Text;
};

// Size: 0x88
class UInterchangeResultMeshWarning_TooManyUVs : public UInterchangeResultMeshWarning {
    /* 0x0080 */ int32_t ExcessUVs;
};

// Size: 0x90
class UInterchangeResultTextureDisplay : public UInterchangeResultDisplay_Generic {
    /* 0x0080 */ FString TextureName;
};

// Size: 0xa0
class UInterchangeResultTextureDisplay_TextureFileDoNotExist : public UInterchangeResultTextureDisplay {
    /* 0x0090 */ FString MaterialName;
};

// Size: 0x80
class UInterchangeResultTextureWarning : public UInterchangeResultWarning {
    /* 0x0070 */ FString TextureName;
};

enum class EInterchangeAnimatedProperty {
    None = 0,
    Visibility = 1,
    MAX = 2,
};

enum class EInterchangeAnimationPayLoadType {
    NONE = 0,
    CURVE = 1,
    MORPHTARGETCURVE = 2,
    STEPCURVE = 3,
    BAKED = 4,
    MORPHTARGETCURVEWEIGHTINSTANCE = 5,
    EInterchangeAnimationPayLoadType_MAX = 6,
};

enum class EInterchangeCameraProjectionType {
    Perspective = 0,
    Orthographic = 1,
    EInterchangeCameraProjectionType_MAX = 2,
};

enum class EInterchangeLightUnits {
    Unitless = 0,
    Candelas = 1,
    Lumens = 2,
    EV = 3,
    EInterchangeLightUnits_MAX = 4,
};

enum class EInterchangeMeshCollision {
    Box = 0,
    Sphere = 1,
    Capsule = 2,
    Convex10DOP_X = 3,
    Convex10DOP_Y = 4,
    Convex10DOP_Z = 5,
    Convex18DOP = 6,
    Convex26DOP = 7,
    None = 255,
    EInterchangeMeshCollision_MAX = 256,
};

enum class EInterchangeMeshPayLoadType {
    NONE = 0,
    STATIC = 1,
    SKELETAL = 2,
    MORPHTARGET = 3,
    ANIMATED = 4,
    EInterchangeMeshPayLoadType_MAX = 5,
};

enum class EInterchangeMotionVectorsHandling {
    NoMotionVectors = 0,
    ImportVelocitiesAsMotionVectors = 1,
    CalculateMotionVectorsDuringImport = 2,
    EInterchangeMotionVectorsHandling_MAX = 3,
};

enum class EInterchangePropertyTracks {
    AffectDistanceFieldLighting = 0,
    AffectDynamicIndirectLighting = 1,
    AffectIndirectLightingWhileHidden = 2,
    AutoActivate = 3,
    BodyInstanceAngularDamping = 4,
    BodyInstancebEnableGravity = 5,
    BodyInstancebNotifyRigidBodyCollision = 6,
    BodyInstancebSimulatePhysics = 7,
    BodyInstancebUpdateKinematicFromSimulation = 8,
    BodyInstancebUseCCD = 9,
    BodyInstanceLinearDamping = 10,
    BodyInstanceMassScale = 11,
    BoundsScale = 12,
    CastContactShadow = 13,
    CastHiddenShadow = 14,
    CastInsetShadow = 15,
    CastShadow = 16,
    CustomDepthStencilValue = 17,
    CustomDepthStencilWriteMask = 18,
    DefaultUpVector = 19,
    DrawDebug = 20,
    EmissiveLightSource = 21,
    ExcludeFromLightAttachmentGroup = 22,
    HiddenInGame = 23,
    HiddenInSceneCapture = 24,
    Holdout = 25,
    LightAttachmentsAsGroup = 26,
    Mobility = 27,
    OnlyOwnerSee = 28,
    OwnerNoSee = 29,
    ReceivesDecals = 30,
    RenderCustomDepth = 31,
    RenderInDepthPass = 32,
    RenderInMainPass = 33,
    SingleSampleShadowFromStationaryLights = 34,
    TranslucencySortDistanceOffset = 35,
    VisibleInRayTracing = 36,
    VisibleInSceneCaptureOnly = 37,
    ActorHiddenInGame = 38,
    LightAffectGlobalIllumination = 39,
    LightAffectReflection = 40,
    LightAffectTranslucentLighting = 41,
    LightAtmosphereSunDiskColorScale = 42,
    LightAtmosphereSunLight = 43,
    LightAtmosphereSunLightIndex = 44,
    LightAttenuationRadius = 45,
    LightBarnDoorAngle = 46,
    LightBarnDoorLength = 47,
    LightBloomMaxBrightness = 48,
    LightBloomScale = 49,
    LightBloomThreshold = 50,
    LightBloomTint = 51,
    LightCascadeDistributionExponent = 52,
    LightCascadeTransitionFraction = 53,
    LightCastDeepShadow = 54,
    LightCastShadows = 55,
    LightCastVolumetricShadow = 56,
    LightCloudAmbientOcclusionStrength = 57,
    LightCloudScatteredLuminanceScale = 58,
    LightCloudShadowOnAtmosphereStrength = 59,
    LightCloudShadowOnSurfaceStrength = 60,
    LightCloudShadowStrength = 61,
    LightColor = 62,
    LightDynamicShadowCascades = 63,
    LightDynamicShadowDistanceMovableLight = 64,
    LightDynamicShadowDistanceStationaryLight = 65,
    LightEnableLightShaftBloom = 66,
    LightEnableLightShaftOcclusion = 67,
    LightFalloffExponent = 68,
    LightForceCachedShadowsForMovablePrimitives = 69,
    LightForwardShadingPriority = 70,
    LightFunctionFadeDistance = 71,
    LightFunctionScale = 72,
    LightIESBrightnessScale = 73,
    LightIndirectLightingIntensity = 74,
    LightInnerConeAngle = 75,
    LightIntensity = 76,
    LightIntensityUnits = 77,
    LightInverseExposureBlend = 78,
    LightLowerHemisphereColor = 79,
    LightmassSettingsLightSourceAngle = 80,
    LightMinOcclusion = 81,
    LightModulatedShadowColor = 82,
    LightOcclusionDepthRange = 83,
    LightOcclusionExponent = 84,
    LightOcclusionMaskDarkness = 85,
    LightOcclusionTint = 86,
    LightOuterConeAngle = 87,
    LightSamplesPerPixel = 88,
    LightShadowAmount = 89,
    LightShadowBias = 90,
    LightShadowCascadeBiasDistribution = 91,
    LightShadowDistanceFadeoutFraction = 92,
    LightShadowSlopeBias = 93,
    LightShadowSourceAngleFactor = 94,
    LightShaftOverrideDirection = 95,
    LightSoftSourceRadius = 96,
    LightSourceAngle = 97,
    LightSourceCubemapAngle = 98,
    LightSourceHeight = 99,
    LightSourceLength = 100,
    LightSourceRadius = 101,
    LightSourceSoftAngle = 102,
    LightSourceWidth = 103,
    LightSpecularScale = 104,
    LightDiffuseScale = 105,
    LightTemperature = 106,
    LightTransmission = 107,
    LightUseIESBrightness = 108,
    LightUseInverseSquaredFalloff = 109,
    LightUseTemperature = 110,
    LightVolumetricScatteringIntensity = 111,
    CameraAspectRatio = 112,
    CameraAspectRatioAxisConstraint = 113,
    CameraAutoCalculateOrthoPlanes = 114,
    CameraAutoPlaneShift = 115,
    CameraConstrainAspectRatio = 116,
    CameraCurrentAperture = 117,
    CameraCurrentFocalLength = 118,
    CameraCustomNearClippingPlane = 119,
    CameraFieldOfView = 120,
    CameraFilmbackSensorAspectRatio = 121,
    CameraFilmbackSensorHeight = 122,
    CameraFilmbackSensorWidth = 123,
    CameraFocusSettingsFocusOffset = 124,
    CameraFocusSettingsManualFocusDistance = 125,
    CameraFocusSettingsTrackingFocusSettingsRelativeOffset = 126,
    CameraOrthoFarClipPlane = 127,
    CameraOrthoNearClipPlane = 128,
    CameraOrthoWidth = 129,
    CameraOverrideAspectRatioAxisConstraint = 130,
    CameraPostProcessBlendWeight = 131,
    CameraPostProcessSettingsAmbientCubemapIntensity = 132,
    CameraPostProcessSettingsAmbientCubemapTint = 133,
    CameraPostProcessSettingsAmbientOcclusionBias = 134,
    CameraPostProcessSettingsAmbientOcclusionFadeDistance = 135,
    CameraPostProcessSettingsAmbientOcclusionFadeRadius = 136,
    CameraPostProcessSettingsAmbientOcclusionIntensity = 137,
    CameraPostProcessSettingsAmbientOcclusionMipBlend = 138,
    CameraPostProcessSettingsAmbientOcclusionMipScale = 139,
    CameraPostProcessSettingsAmbientOcclusionMipThreshold = 140,
    CameraPostProcessSettingsAmbientOcclusionPower = 141,
    CameraPostProcessSettingsAmbientOcclusionQuality = 142,
    CameraPostProcessSettingsAmbientOcclusionRadius = 143,
    CameraPostProcessSettingsAmbientOcclusionStaticFraction = 144,
    CameraPostProcessSettingsAmbientOcclusionTemporalBlendWeight = 145,
    CameraPostProcessSettingsAutoExposureBias = 146,
    CameraPostProcessSettingsAutoExposureHighPercent = 147,
    CameraPostProcessSettingsAutoExposureLowPercent = 148,
    CameraPostProcessSettingsAutoExposureMaxBrightness = 149,
    CameraPostProcessSettingsAutoExposureMinBrightness = 150,
    CameraPostProcessSettingsAutoExposureSpeedDown = 151,
    CameraPostProcessSettingsAutoExposureSpeedUp = 152,
    CameraPostProcessSettingsBloom1Size = 153,
    CameraPostProcessSettingsBloom1Tint = 154,
    CameraPostProcessSettingsBloom2Size = 155,
    CameraPostProcessSettingsBloom2Tint = 156,
    CameraPostProcessSettingsBloom3Size = 157,
    CameraPostProcessSettingsBloom3Tint = 158,
    CameraPostProcessSettingsBloom4Size = 159,
    CameraPostProcessSettingsBloom4Tint = 160,
    CameraPostProcessSettingsBloom5Size = 161,
    CameraPostProcessSettingsBloom5Tint = 162,
    CameraPostProcessSettingsBloom6Size = 163,
    CameraPostProcessSettingsBloom6Tint = 164,
    CameraPostProcessSettingsBloomConvolutionBufferScale = 165,
    CameraPostProcessSettingsBloomConvolutionCenterUV = 166,
    CameraPostProcessSettingsBloomConvolutionPreFilterMax = 167,
    CameraPostProcessSettingsBloomConvolutionPreFilterMin = 168,
    CameraPostProcessSettingsBloomConvolutionPreFilterMult = 169,
    CameraPostProcessSettingsBloomConvolutionScatterDispersion = 170,
    CameraPostProcessSettingsBloomConvolutionSize = 171,
    CameraPostProcessSettingsBloomDirtMaskIntensity = 172,
    CameraPostProcessSettingsBloomDirtMaskTint = 173,
    CameraPostProcessSettingsBloomIntensity = 174,
    CameraPostProcessSettingsBloomSizeScale = 175,
    CameraPostProcessSettingsBloomThreshold = 176,
    CameraPostProcessSettingsBlueCorrection = 177,
    CameraPostProcessSettingsChromaticAberrationStartOffset = 178,
    CameraPostProcessSettingsColorContrast = 179,
    CameraPostProcessSettingsColorContrastHighlights = 180,
    CameraPostProcessSettingsColorContrastMidtones = 181,
    CameraPostProcessSettingsColorContrastShadows = 182,
    CameraPostProcessSettingsColorCorrectionHighlightsMax = 183,
    CameraPostProcessSettingsColorCorrectionHighlightsMin = 184,
    CameraPostProcessSettingsColorCorrectionShadowsMax = 185,
    CameraPostProcessSettingsColorGain = 186,
    CameraPostProcessSettingsColorGainHighlights = 187,
    CameraPostProcessSettingsColorGainMidtones = 188,
    CameraPostProcessSettingsColorGainShadows = 189,
    CameraPostProcessSettingsColorGamma = 190,
    CameraPostProcessSettingsColorGammaHighlights = 191,
    CameraPostProcessSettingsColorGammaMidtones = 192,
    CameraPostProcessSettingsColorGammaShadows = 193,
    CameraPostProcessSettingsColorGradingIntensity = 194,
    CameraPostProcessSettingsColorOffset = 195,
    CameraPostProcessSettingsColorOffsetHighlights = 196,
    CameraPostProcessSettingsColorOffsetMidtones = 197,
    CameraPostProcessSettingsColorOffsetShadows = 198,
    CameraPostProcessSettingsColorSaturation = 199,
    CameraPostProcessSettingsColorSaturationHighlights = 200,
    CameraPostProcessSettingsColorSaturationMidtones = 201,
    CameraPostProcessSettingsColorSaturationShadows = 202,
    CameraPostProcessSettingsDepthOfFieldBladeCount = 203,
    CameraPostProcessSettingsDepthOfFieldDepthBlurAmount = 204,
    CameraPostProcessSettingsDepthOfFieldDepthBlurRadius = 205,
    CameraPostProcessSettingsDepthOfFieldFarBlurSize = 206,
    CameraPostProcessSettingsDepthOfFieldFarTransitionRegion = 207,
    CameraPostProcessSettingsDepthOfFieldFocalDistance = 208,
    CameraPostProcessSettingsDepthOfFieldFocalRegion = 209,
    CameraPostProcessSettingsDepthOfFieldFstop = 210,
    CameraPostProcessSettingsDepthOfFieldMinFstop = 211,
    CameraPostProcessSettingsDepthOfFieldNearBlurSize = 212,
    CameraPostProcessSettingsDepthOfFieldNearTransitionRegion = 213,
    CameraPostProcessSettingsDepthOfFieldOcclusion = 214,
    CameraPostProcessSettingsDepthOfFieldScale = 215,
    CameraPostProcessSettingsDepthOfFieldSkyFocusDistance = 216,
    CameraPostProcessSettingsDepthOfFieldUseHairDepth = 217,
    CameraPostProcessSettingsDepthOfFieldVignetteSize = 218,
    CameraPostProcessSettingsDynamicGlobalIlluminationMethod = 219,
    CameraPostProcessSettingsExpandGamut = 220,
    CameraPostProcessSettingsFilmBlackClip = 221,
    CameraPostProcessSettingsFilmGrainHighlightsMax = 222,
    CameraPostProcessSettingsFilmGrainHighlightsMin = 223,
    CameraPostProcessSettingsFilmGrainIntensity = 224,
    CameraPostProcessSettingsFilmGrainIntensityHighlights = 225,
    CameraPostProcessSettingsFilmGrainIntensityMidtones = 226,
    CameraPostProcessSettingsFilmGrainIntensityShadows = 227,
    CameraPostProcessSettingsFilmGrainShadowsMax = 228,
    CameraPostProcessSettingsFilmGrainTexelSize = 229,
    CameraPostProcessSettingsFilmShoulder = 230,
    CameraPostProcessSettingsFilmSlope = 231,
    CameraPostProcessSettingsFilmToe = 232,
    CameraPostProcessSettingsFilmWhiteClip = 233,
    CameraPostProcessSettingsHistogramLogMax = 234,
    CameraPostProcessSettingsHistogramLogMin = 235,
    CameraPostProcessSettingsIndirectLightingColor = 236,
    CameraPostProcessSettingsIndirectLightingIntensity = 237,
    CameraPostProcessSettingsLensFlareBokehSize = 238,
    CameraPostProcessSettingsLensFlareIntensity = 239,
    CameraPostProcessSettingsLensFlareThreshold = 240,
    CameraPostProcessSettingsLensFlareTint = 241,
    CameraPostProcessSettingsLocalExposureBlurredLuminanceBlend = 242,
    CameraPostProcessSettingsLocalExposureBlurredLuminanceKernelSizePercent = 243,
    CameraPostProcessSettingsLocalExposureDetailStrength = 244,
    CameraPostProcessSettingsLocalExposureHighlightContrastScale = 245,
    CameraPostProcessSettingsLocalExposureHighlightThreshold = 246,
    CameraPostProcessSettingsLocalExposureMiddleGreyBias = 247,
    CameraPostProcessSettingsLocalExposureShadowContrastScale = 248,
    CameraPostProcessSettingsLocalExposureShadowThreshold = 249,
    CameraPostProcessSettingsLumenDiffuseColorBoost = 250,
    CameraPostProcessSettingsLumenFinalGatherLightingUpdateSpeed = 251,
    CameraPostProcessSettingsLumenFinalGatherQuality = 252,
    CameraPostProcessSettingsLumenFinalGatherScreenTraces = 253,
    CameraPostProcessSettingsLumenFrontLayerTranslucencyReflections = 254,
    CameraPostProcessSettingsLumenFullSkylightLeakingDistance = 255,
    CameraPostProcessSettingsLumenMaxReflectionBounces = 256,
    CameraPostProcessSettingsLumenMaxRefractionBounces = 257,
    CameraPostProcessSettingsLumenMaxRoughnessToTraceReflections = 258,
    CameraPostProcessSettingsLumenMaxTraceDistance = 259,
    CameraPostProcessSettingsLumenRayLightingMode = 260,
    CameraPostProcessSettingsLumenReflectionQuality = 261,
    CameraPostProcessSettingsLumenReflectionsScreenTraces = 262,
    CameraPostProcessSettingsLumenSceneDetail = 263,
    CameraPostProcessSettingsLumenSceneLightingQuality = 264,
    CameraPostProcessSettingsLumenSceneLightingUpdateSpeed = 265,
    CameraPostProcessSettingsLumenSceneViewDistance = 266,
    CameraPostProcessSettingsLumenSkylightLeaking = 267,
    CameraPostProcessSettingsLumenSkylightLeakingTint = 268,
    CameraPostProcessSettingsMotionBlurAmount = 269,
    CameraPostProcessSettingsMotionBlurMax = 270,
    CameraPostProcessSettingsMotionBlurPerObjectSize = 271,
    CameraPostProcessSettingsPathTracingMaxBounces = 272,
    CameraPostProcessSettingsPathTracingMaxPathIntensity = 273,
    CameraPostProcessSettingsRayTracingAO = 274,
    CameraPostProcessSettingsRayTracingAOIntensity = 275,
    CameraPostProcessSettingsRayTracingAORadius = 276,
    CameraPostProcessSettingsRayTracingAOSamplesPerPixel = 277,
    CameraPostProcessSettingsRayTracingTranslucencyMaxRoughness = 278,
    CameraPostProcessSettingsRayTracingTranslucencyRefraction = 279,
    CameraPostProcessSettingsRayTracingTranslucencyRefractionRays = 280,
    CameraPostProcessSettingsRayTracingTranslucencySamplesPerPixel = 281,
    CameraPostProcessSettingsRayTracingTranslucencyShadows = 282,
    CameraPostProcessSettingsReflectionMethod = 283,
    CameraPostProcessSettingsSceneColorTint = 284,
    CameraPostProcessSettingsSceneFringeIntensity = 285,
    CameraPostProcessSettingsScreenSpaceReflectionIntensity = 286,
    CameraPostProcessSettingsScreenSpaceReflectionMaxRoughness = 287,
    CameraPostProcessSettingsScreenSpaceReflectionQuality = 288,
    CameraPostProcessSettingsSharpen = 289,
    CameraPostProcessSettingsTemperatureType = 290,
    CameraPostProcessSettingsToneCurveAmount = 291,
    CameraPostProcessSettingsTranslucencyType = 292,
    CameraPostProcessSettingsVignetteIntensity = 293,
    CameraPostProcessSettingsWhiteTemp = 294,
    CameraPostProcessSettingsWhiteTint = 295,
    CameraProjectionMode = 296,
    CameraUpdateOrthoPlanes = 297,
    CameraUseCameraHeightAsViewTarget = 298,
    CameraUseFieldOfViewForLOD = 299,
    MeshOverlayMaterialMaxDrawDistance = 300,
    SkinnedMeshCapsuleIndirectShadowMinVisibility = 301,
    SkinnedMeshCastCapsuleDirectShadow = 302,
    SkinnedMeshCastCapsuleIndirectShadow = 303,
    SkinnedMeshRenderStatic = 304,
    SkinnedMeshVisibilityBasedAnimTickOption = 305,
    SkeletalMesh = 306,
    SkeletalMeshAllowClothActors = 307,
    SkeletalMeshAnimationMode = 308,
    SkeletalMeshClothBlendWeight = 309,
    SkeletalMeshClothMaxDistanceScale = 310,
    StaticMeshDistanceFieldSelfShadowBias = 311,
    StaticMeshEvaluateWorldPositionOffset = 312,
    StaticMeshEvaluateWorldPositionOffsetInRayTracing = 313,
    StaticMeshForcedLodModel = 314,
    StaticMeshReverseCulling = 315,
    StaticMeshWorldPositionOffsetDisableDistance = 316,
    StaticMesh = 317,
    HeterogeneousVolumeFrame = 318,
    None = -1,
    Visibility = 38,
    EInterchangePropertyTracks_MAX = 319,
};

enum class EInterchangeTextureColorSpace {
    TCS_None = 0,
    TCS_sRGB = 1,
    TCS_Rec2020 = 2,
    TCS_ACESAP0 = 3,
    TCS_ACESAP1 = 4,
    TCS_P3DCI = 5,
    TCS_P3D65 = 6,
    TCS_REDWideGamut = 7,
    TCS_SonySGamut3 = 8,
    TCS_SonySGamut3Cine = 9,
    TCS_AlexaWideGamut = 10,
    TCS_CanonCinemaGamut = 11,
    TCS_GoProProtuneNative = 12,
    TCS_PanasonicVGamut = 13,
    TCS_Custom = 99,
    TCS_MAX = 100,
};

enum class EInterchangeTextureFilterMode {
    Nearest = 0,
    Bilinear = 1,
    Trilinear = 2,
    Default = 3,
    EInterchangeTextureFilterMode_MAX = 4,
};

enum class EInterchangeTextureWrapMode {
    Wrap = 0,
    Clamp = 1,
    Mirror = 2,
    EInterchangeTextureWrapMode_MAX = 3,
};

enum class EVolumeGridElementType {
    Unknown = 0,
    Half = 1,
    Float = 2,
    Double = 3,
    EVolumeGridElementType_MAX = 4,
};

// Size: 0x18
struct FInterchangeAnimationPayLoadKey {
    /* 0x0000 */ FString UniqueID;
    /* 0x0010 */ EInterchangeAnimationPayLoadType Type;
};

// Size: 0x70
class UInterchangeAnimationTrackBaseNode : public UInterchangeBaseNode {

    bool GetCustomCompletionMode(int32_t& AttributeValue) const;
    bool SetCustomCompletionMode(const int32_t& AttributeValue);
};

// Size: 0xd0
class UInterchangeAnimationTrackNode : public UInterchangeAnimationTrackBaseNode {

    bool GetCustomActorDependencyUid(FString& DependencyUid) const;
    bool GetCustomAnimationPayloadKey(FInterchangeAnimationPayLoadKey& AnimationPayLoadKey) const;
    bool GetCustomFrameCount(int32_t& AttributeValue) const;
    bool GetCustomPropertyTrack(EInterchangePropertyTracks& PropertyTrack) const;
    bool SetCustomActorDependencyUid(FString DependencyUid);
    bool SetCustomAnimationPayloadKey(FString InUniqueId, const EInterchangeAnimationPayLoadType& InType);
    bool SetCustomFrameCount(const int32_t& AttributeValue);
    bool SetCustomPropertyTrack(EInterchangePropertyTracks PropertyTrack);
};

// Size: 0xb0
class UInterchangeAnimationTrackSetInstanceNode : public UInterchangeAnimationTrackBaseNode {

    bool GetCustomDuration(int32_t& AttributeValue) const;
    bool GetCustomStartFrame(int32_t& AttributeValue) const;
    bool GetCustomTimeScale(float& AttributeValue) const;
    bool GetCustomTrackSetDependencyUid(FString& AttributeValue) const;
    bool SetCustomDuration(const int32_t& AttributeValue);
    bool SetCustomStartFrame(const int32_t& AttributeValue);
    bool SetCustomTimeScale(const float& AttributeValue);
    bool SetCustomTrackSetDependencyUid(FString AttributeValue);
};

// Size: 0x90
class UInterchangeAnimationTrackSetNode : public UInterchangeBaseNode {

    bool AddCustomAnimationTrackUid(FString AnimationTrackUid);
    void GetCustomAnimationTrackUid(const int32_t Index, FString& OutAnimationTrackUid) const;
    int32_t GetCustomAnimationTrackUidCount() const;
    void GetCustomAnimationTrackUids(TArray<FString>& OutAnimationTrackUids) const;
    bool GetCustomFrameRate(float& AttributeValue) const;
    bool RemoveCustomAnimationTrackUid(FString AnimationTrackUid);
    bool SetCustomFrameRate(const float& AttributeValue);
};

// Size: 0xa0
class UInterchangeBaseLightNode : public UInterchangeBaseNode {

    bool GetCustomIntensity(float& AttributeValue) const;
    bool GetCustomLightColor(FLinearColor& AttributeValue) const;
    bool GetCustomTemperature(float& AttributeValue) const;
    bool GetCustomUseTemperature(bool& AttributeValue) const;
    bool SetCustomIntensity(float AttributeValue);
    bool SetCustomLightColor(const FLinearColor& AttributeValue);
    bool SetCustomTemperature(float AttributeValue);
    bool SetCustomUseTemperature(bool AttributeValue);
};

// Size: 0x90
class UInterchangeDecalMaterialNode : public UInterchangeShaderNode {
};

// Size: 0x90
class UInterchangeDecalNode : public UInterchangeBaseNode {

    bool GetCustomDecalMaterialPathName(FString& AttributeValue) const;
    bool GetCustomDecalSize(FVector& AttributeValue) const;
    bool GetCustomSortOrder(int32_t& AttributeValue) const;
    bool SetCustomDecalMaterialPathName(FString AttributeValue);
    bool SetCustomDecalSize(const FVector& AttributeValue);
    bool SetCustomSortOrder(const int32_t& AttributeValue);
};

// Size: 0xa0
class UInterchangeDirectionalLightNode : public UInterchangeBaseLightNode {
};

// Size: 0x80
class UInterchangeFunctionCallShaderNode : public UInterchangeShaderNode {

    bool GetCustomMaterialFunction(FString& AttributeValue) const;
    bool SetCustomMaterialFunction(FString AttributeValue);
};

// Size: 0x238
class UInterchangeGeometryCacheNode : public UInterchangeMeshNode {

    bool GetCustomEndFrame(int32_t& AttributeValue) const;
    bool GetCustomFrameRate(double& AttributeValue) const;
    bool GetCustomHasConstantTopology(bool& AttributeValue) const;
    bool GetCustomStartFrame(int32_t& AttributeValue) const;
    bool SetCustomEndFrame(const int32_t& AttributeValue);
    bool SetCustomFrameRate(const double& AttributeValue);
    bool SetCustomHasConstantTopology(const bool& AttributeValue);
    bool SetCustomStartFrame(const int32_t& AttributeValue);
};

// Size: 0x100
class UInterchangeLightNode : public UInterchangeBaseLightNode {

    bool GetCustomAttenuationRadius(float& AttributeValue) const;
    bool GetCustomIESBrightnessScale(float& AttributeValue) const;
    bool GetCustomIESTexture(FString& AttributeValue) const;
    bool GetCustomIntensityUnits(EInterchangeLightUnits& AttributeValue) const;
    bool GetCustomRotation(FRotator& AttributeValue) const;
    bool GetCustomUseIESBrightness(bool& AttributeValue) const;
    bool SetCustomAttenuationRadius(float AttributeValue);
    bool SetCustomIESBrightnessScale(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomIESTexture(FString AttributeValue);
    bool SetCustomIntensityUnits(const EInterchangeLightUnits& AttributeValue);
    bool SetCustomRotation(const FRotator& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomUseIESBrightness(const bool& AttributeValue, bool bAddApplyDelegate);
};

// Size: 0x70
class UInterchangeMaterialInstanceNode : public UInterchangeBaseNode {

    bool AddScalarParameterValue(FString ParameterName, float AttributeValue);
    bool AddStaticSwitchParameterValue(FString ParameterName, bool AttributeValue);
    bool AddTextureParameterValue(FString ParameterName, FString AttributeValue);
    bool AddVectorParameterValue(FString ParameterName, const FLinearColor& AttributeValue);
    bool GetCustomParent(FString& AttributeValue) const;
    bool GetScalarParameterValue(FString ParameterName, float& AttributeValue) const;
    bool GetStaticSwitchParameterValue(FString ParameterName, bool& AttributeValue) const;
    bool GetTextureParameterValue(FString ParameterName, FString& AttributeValue) const;
    bool GetVectorParameterValue(FString ParameterName, FLinearColor& AttributeValue) const;
    bool SetCustomParent(FString AttributeValue) const;
};

// Size: 0x70
class UInterchangeMaterialReferenceNode : public UInterchangeBaseNode {

    bool GetCustomContentPath(FString& AttributeValue) const;
    bool SetCustomContentPath(FString AttributeValue) const;
};

// Size: 0x1f8
class UInterchangeMeshNode : public UInterchangeBaseNode {

    bool GetCustomBoundingBox(FBox& AttributeValue) const;
    bool GetCustomCollisionType(EInterchangeMeshCollision& AttributeValue) const;
    bool GetCustomHasSmoothGroup(bool& AttributeValue) const;
    bool GetCustomHasVertexBinormal(bool& AttributeValue) const;
    bool GetCustomHasVertexColor(bool& AttributeValue) const;
    bool GetCustomHasVertexNormal(bool& AttributeValue) const;
    bool GetCustomHasVertexTangent(bool& AttributeValue) const;
    bool GetCustomPolygonCount(int32_t& AttributeValue) const;
    bool GetCustomUVCount(int32_t& AttributeValue) const;
    bool GetCustomVertexCount(int32_t& AttributeValue) const;
    int32_t GetMorphTargetDependeciesCount() const;
    void GetMorphTargetDependencies(TArray<FString>& OutDependencies) const;
    void GetMorphTargetDependency(const int32_t Index, FString& OutDependency) const;
    bool GetMorphTargetName(FString& OutMorphTargetName) const;
    void GetSceneInstanceUid(const int32_t Index, FString& OutDependency) const;
    void GetSceneInstanceUids(TArray<FString>& OutDependencies) const;
    int32_t GetSceneInstanceUidsCount() const;
    int32_t GetSkeletonDependeciesCount() const;
    void GetSkeletonDependencies(TArray<FString>& OutDependencies) const;
    void GetSkeletonDependency(const int32_t Index, FString& OutDependency) const;
    void GetSlotMaterialDependencies(TMap<FString, FString>& OutMaterialDependencies) const;
    bool GetSlotMaterialDependencyUid(FString SlotName, FString& OutMaterialDependency) const;
    bool IsMorphTarget() const;
    bool IsSkinnedMesh() const;
    bool RemoveMorphTargetDependencyUid(FString DependencyUid);
    bool RemoveSceneInstanceUid(FString DependencyUid);
    bool RemoveSkeletonDependencyUid(FString DependencyUid);
    bool RemoveSlotMaterialDependencyUid(FString SlotName);
    bool SetCustomBoundingBox(const FBox& AttributeValue);
    bool SetCustomCollisionType(EInterchangeMeshCollision AttributeValue);
    bool SetCustomHasSmoothGroup(const bool& AttributeValue);
    bool SetCustomHasVertexBinormal(const bool& AttributeValue);
    bool SetCustomHasVertexColor(const bool& AttributeValue);
    bool SetCustomHasVertexNormal(const bool& AttributeValue);
    bool SetCustomHasVertexTangent(const bool& AttributeValue);
    bool SetCustomPolygonCount(const int32_t& AttributeValue);
    bool SetCustomUVCount(const int32_t& AttributeValue);
    bool SetCustomVertexCount(const int32_t& AttributeValue);
    bool SetMorphTarget(const bool bIsMorphTarget);
    bool SetMorphTargetDependencyUid(FString DependencyUid);
    bool SetMorphTargetName(FString MorphTargetName);
    void SetPayLoadKey(FString PayloadKey, const EInterchangeMeshPayLoadType& PayLoadType);
    bool SetSceneInstanceUid(FString DependencyUid);
    bool SetSkeletonDependencyUid(FString DependencyUid);
    bool SetSkinnedMesh(const bool bIsSkinnedMesh);
    bool SetSlotMaterialDependencyUid(FString SlotName, FString MaterialDependencyUid);
};

// Size: 0x18
struct FInterchangeMeshPayLoadKey {
    /* 0x0000 */ FString UniqueID;
    /* 0x0010 */ EInterchangeMeshPayLoadType Type;
    /* 0x0014 */ int32_t FrameNumber;
};

// Size: 0xa0
class UInterchangePhysicalCameraNode : public UInterchangeBaseNode {

    bool GetCustomEnableDepthOfField(bool& AttributeValue) const;
    bool GetCustomFocalLength(float& AttributeValue) const;
    bool GetCustomSensorHeight(float& AttributeValue) const;
    bool GetCustomSensorWidth(float& AttributeValue) const;
    bool SetCustomEnableDepthOfField(const bool& AttributeValue);
    bool SetCustomFocalLength(const float& AttributeValue);
    bool SetCustomSensorHeight(const float& AttributeValue);
    bool SetCustomSensorWidth(const float& AttributeValue);
};

// Size: 0x120
class UInterchangePointLightNode : public UInterchangeLightNode {

    bool GetCustomLightFalloffExponent(float& AttributeValue) const;
    bool GetCustomUseInverseSquaredFalloff(bool& AttributeValue) const;
    bool SetCustomLightFalloffExponent(float AttributeValue);
    bool SetCustomUseInverseSquaredFalloff(bool AttributeValue);
};

// Size: 0x120
class UInterchangeRectLightNode : public UInterchangeLightNode {

    bool GetCustomSourceHeight(float& AttributeValue) const;
    bool GetCustomSourceWidth(float& AttributeValue) const;
    bool SetCustomSourceHeight(float AttributeValue);
    bool SetCustomSourceWidth(float AttributeValue);
};

// Size: 0x490
class UInterchangeSceneNode : public UInterchangeBaseNode {

    bool AddSpecializedType(FString SpecializedType);
    bool GetAnimationCurveTypeForCurveName(FString CurveName, EInterchangeAnimationPayLoadType& OutCurveAnimationType) const;
    bool GetCustomActorVisibility(bool& bOutIsVisible) const;
    bool GetCustomAnimationAssetUidToPlay(FString& AttributeValue) const;
    bool GetCustomAssetInstanceUid(FString& AttributeValue) const;
    bool GetCustomBindPoseGlobalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& GlobalOffsetTransform, FTransform& AttributeValue, bool bForceRecache) const;
    bool GetCustomBindPoseLocalTransform(FTransform& AttributeValue) const;
    bool GetCustomComponentVisibility(bool& bOutIsVisible) const;
    bool GetCustomGeometricTransform(FTransform& AttributeValue) const;
    bool GetCustomGlobalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& GlobalOffsetTransform, FTransform& AttributeValue, bool bForceRecache) const;
    bool GetCustomHasBindPose(bool& bHasBindPose) const;
    bool GetCustomLocalTransform(FTransform& AttributeValue) const;
    bool GetCustomPivotNodeTransform(FTransform& AttributeValue) const;
    bool GetCustomTimeZeroGlobalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& GlobalOffsetTransform, FTransform& AttributeValue, bool bForceRecache) const;
    bool GetCustomTimeZeroLocalTransform(FTransform& AttributeValue) const;
    bool GetGlobalBindPoseReferenceForMeshUID(FString MeshUid, FMatrix& GlobalBindPoseReference) const;
    void GetMorphTargetCurveWeights(TMap<FString, float>& OutMorphTargetCurveWeights) const;
    void GetSlotMaterialDependencies(TMap<FString, FString>& OutMaterialDependencies) const;
    bool GetSlotMaterialDependencyUid(FString SlotName, FString& OutMaterialDependency) const;
    void GetSpecializedType(const int32_t Index, FString& OutSpecializedType) const;
    int32_t GetSpecializedTypeCount() const;
    void GetSpecializedTypes(TArray<FString>& OutSpecializedTypes) const;
    bool IsSpecializedTypeContains(FString SpecializedType) const;
    bool RemoveSlotMaterialDependencyUid(FString SlotName);
    bool RemoveSpecializedType(FString SpecializedType);
    bool SetAnimationCurveTypeForCurveName(FString CurveName, const EInterchangeAnimationPayLoadType& AnimationCurveType);
    bool SetCustomActorVisibility(bool bInIsVisible);
    bool SetCustomAnimationAssetUidToPlay(FString AttributeValue);
    bool SetCustomAssetInstanceUid(FString AttributeValue);
    bool SetCustomBindPoseLocalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& AttributeValue, bool bResetCache);
    bool SetCustomComponentVisibility(bool bInIsVisible);
    bool SetCustomGeometricTransform(const FTransform& AttributeValue);
    bool SetCustomHasBindPose(const bool& bHasBindPose);
    bool SetCustomLocalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& AttributeValue, bool bResetCache);
    bool SetCustomPivotNodeTransform(const FTransform& AttributeValue);
    bool SetCustomTimeZeroLocalTransform(const UInterchangeBaseNodeContainer* BaseNodeContainer, const FTransform& AttributeValue, bool bResetCache);
    void SetGlobalBindPoseReferenceForMeshUIDs(const TMap<FString, FMatrix>& GlobalBindPoseReferenceForMeshUIDs);
    bool SetMorphTargetCurveWeight(FString MorphTargetName, const float& Weight);
    bool SetSlotMaterialDependencyUid(FString SlotName, FString MaterialDependencyUid);
};

// Size: 0x80
class UInterchangeSceneVariantSetsNode : public UInterchangeBaseNode {

    bool AddCustomVariantSetUid(FString VariantUid);
    void GetCustomVariantSetUid(const int32_t Index, FString& OutVariantUid) const;
    int32_t GetCustomVariantSetUidCount() const;
    void GetCustomVariantSetUids(TArray<FString>& OutVariantUids) const;
    bool RemoveCustomVariantSetUid(FString VariantUid);
};

// Size: 0xe0
class UInterchangeShaderGraphNode : public UInterchangeShaderNode {

    bool GetCustomBlendMode(int32_t& AttributeValue) const;
    bool GetCustomDisplacementCenterMode(float& AttributeValue) const;
    bool GetCustomIsAShaderFunction(bool& AttributeValue) const;
    bool GetCustomOpacityMaskClipValue(float& AttributeValue) const;
    bool GetCustomScreenSpaceReflections(bool& AttributeValue) const;
    bool GetCustomTwoSided(bool& AttributeValue) const;
    bool GetCustomTwoSidedTransmission(bool& AttributeValue) const;
    bool SetCustomBlendMode(int32_t AttributeValue);
    bool SetCustomDisplacementCenterMode(float AttributeValue);
    bool SetCustomIsAShaderFunction(const bool& AttributeValue);
    bool SetCustomOpacityMaskClipValue(const float& AttributeValue, bool bAddApplyDelegate);
    bool SetCustomScreenSpaceReflections(const bool& AttributeValue);
    bool SetCustomTwoSided(const bool& AttributeValue);
    bool SetCustomTwoSidedTransmission(const bool& AttributeValue);
};

// Size: 0x70
class UInterchangeShaderNode : public UInterchangeBaseNode {

    bool AddFloatInput(FString InputName, const float& AttributeValue, bool bIsAParameter);
    bool AddLinearColorInput(FString InputName, const FLinearColor& AttributeValue, bool bIsAParameter);
    bool AddStringInput(FString InputName, FString AttributeValue, bool bIsAParameter);
    bool GetCustomShaderType(FString& AttributeValue) const;
    bool SetCustomShaderType(FString AttributeValue);
};

// Size: 0x28
class UInterchangeShaderPortsAPI : public UObject {

    static bool ConnectDefaultOuputToInput(UInterchangeBaseNode* InterchangeNode, FString InputName, FString ExpressionUid);
    static bool ConnectOuputToInputByIndex(UInterchangeBaseNode* InterchangeNode, FString InputName, FString ExpressionUid, int32_t OutputIndex);
    static bool ConnectOuputToInputByName(UInterchangeBaseNode* InterchangeNode, FString InputName, FString ExpressionUid, FString OutputName);
    static void GatherInputs(const UInterchangeBaseNode* InterchangeNode, TArray<FString>& OutInputNames);
    static bool GetInputConnection(const UInterchangeBaseNode* InterchangeNode, FString InputName, FString& OutExpressionUid, FString& OutputName);
    static bool HasInput(const UInterchangeBaseNode* InterchangeNode, const FName& InInputName);
    static bool HasParameter(const UInterchangeBaseNode* InterchangeNode, const FName& InInputName);
    static bool IsAParameter(FString AttributeKey);
    static bool IsAnInput(FString AttributeKey);
    static FString MakeInputConnectionKey(FString InputName);
    static FString MakeInputName(FString InputKey);
    static FString MakeInputParameterKey(FString InputName);
    static FString MakeInputValueKey(FString InputName);
};

// Size: 0x2b0
class UInterchangeSkeletalAnimationTrackNode : public UInterchangeAnimationTrackBaseNode {

    bool GetCustomAnimationSampleRate(double& SampleRate) const;
    bool GetCustomAnimationStartTime(double& StartTime) const;
    bool GetCustomAnimationStopTime(double& StopTime) const;
    bool GetCustomSkeletonNodeUid(FString& AttributeValue) const;
    bool GetCustomSourceTimelineAnimationStartTime(double& StartTime) const;
    bool GetCustomSourceTimelineAnimationStopTime(double& StopTime) const;
    void GetMorphTargetNodeAnimationPayloadKeys(TMap<FString, FString>& OutMorphTargetNodeAnimationPayloadKeyUids, TMap<FString, uint8_t>& OutMorphTargetNodeAnimationPayloadKeyTypes) const;
    void GetSceneNodeAnimationPayloadKeys(TMap<FString, FString>& OutSceneNodeAnimationPayloadKeyUids, TMap<FString, uint8_t>& OutSceneNodeAnimationPayloadKeyTypes) const;
    bool IsNodeAnimatedWithBakedCurve(FString SceneNodeUid) const;
    bool SetAnimationPayloadKeyForMorphTargetNodeUid(FString MorphTargetNodeUid, FString InUniqueId, const EInterchangeAnimationPayLoadType& InType);
    bool SetAnimationPayloadKeyForSceneNodeUid(FString SceneNodeUid, FString InUniqueId, const EInterchangeAnimationPayLoadType& InType);
    bool SetCustomAnimationSampleRate(const double& SampleRate);
    bool SetCustomAnimationStartTime(const double& StartTime);
    bool SetCustomAnimationStopTime(const double& StopTime);
    bool SetCustomSkeletonNodeUid(FString AttributeValue);
    bool SetCustomSourceTimelineAnimationStartTime(const double& StartTime);
    bool SetCustomSourceTimelineAnimationStopTime(const double& StopTime);
};

// Size: 0x80
class UInterchangeSpecularProfileNode : public UInterchangeBaseNode {

    bool GetCustomFormat(uint8_t& Format) const;
    bool GetCustomTexture(FString& TextureUid) const;
    bool SetCustomFormat(uint8_t Format);
    bool SetCustomTexture(FString TextureUid);
};

// Size: 0x140
class UInterchangeSpotLightNode : public UInterchangePointLightNode {

    bool GetCustomInnerConeAngle(float& AttributeValue) const;
    bool GetCustomOuterConeAngle(float& AttributeValue) const;
    bool SetCustomInnerConeAngle(float AttributeValue);
    bool SetCustomOuterConeAngle(float AttributeValue);
};

// Size: 0xc0
class UInterchangeStandardCameraNode : public UInterchangeBaseNode {

    bool GetCustomAspectRatio(float& AttributeValue) const;
    bool GetCustomFarClipPlane(float& AttributeValue) const;
    bool GetCustomFieldOfView(float& AttributeValue) const;
    bool GetCustomNearClipPlane(float& AttributeValue) const;
    bool GetCustomProjectionMode(EInterchangeCameraProjectionType& AttributeValue) const;
    bool GetCustomWidth(float& AttributeValue) const;
    bool SetCustomAspectRatio(const float& AttributeValue);
    bool SetCustomFarClipPlane(const float& AttributeValue);
    bool SetCustomFieldOfView(const float& AttributeValue);
    bool SetCustomNearClipPlane(const float& AttributeValue);
    bool SetCustomProjectionMode(const EInterchangeCameraProjectionType& AttributeValue);
    bool SetCustomWidth(const float& AttributeValue);
};

// Size: 0xa0
class UInterchangeTexture2DArrayNode : public UInterchangeTextureNode {
};

// Size: 0x138
class UInterchangeTexture2DNode : public UInterchangeTextureNode {

    bool GetCustomWrapU(EInterchangeTextureWrapMode& AttributeValue) const;
    bool GetCustomWrapV(EInterchangeTextureWrapMode& AttributeValue) const;
    TMap<int32_t, FString> GetSourceBlocks() const;
    bool SetCustomWrapU(const EInterchangeTextureWrapMode& AttributeValue);
    bool SetCustomWrapV(const EInterchangeTextureWrapMode& AttributeValue);
};

// Size: 0x138
class UInterchangeTextureBlurNode : public UInterchangeTexture2DNode {
};

// Size: 0xa0
class UInterchangeTextureCubeArrayNode : public UInterchangeTextureNode {
};

// Size: 0xa0
class UInterchangeTextureCubeNode : public UInterchangeTextureNode {
};

// Size: 0xa0
class UInterchangeTextureLightProfileNode : public UInterchangeTextureNode {
};

// Size: 0xa0
class UInterchangeTextureNode : public UInterchangeBaseNode {

    bool GetCustomColorSpace(EInterchangeTextureColorSpace& AttributeValue) const;
    bool GetCustomFilter(EInterchangeTextureFilterMode& AttributeValue) const;
    bool GetCustomSRGB(bool& AttributeValue) const;
    bool GetCustombFlipGreenChannel(bool& AttributeValue) const;
    bool SetCustomColorSpace(const EInterchangeTextureColorSpace& AttributeValue);
    bool SetCustomFilter(const EInterchangeTextureFilterMode& AttributeValue);
    bool SetCustomSRGB(const bool& AttributeValue);
    bool SetCustombFlipGreenChannel(const bool& AttributeValue);
    void SetPayLoadKey(FString PayloadKey);
};

// Size: 0xe0
class UInterchangeTransformAnimationTrackNode : public UInterchangeAnimationTrackNode {

    bool GetCustomUsedChannels(int32_t& AttributeValue) const;
    bool SetCustomUsedChannels(const int32_t& AttributeValue);
};

// Size: 0xa0
class UInterchangeVariantSetNode : public UInterchangeBaseNode {

    bool AddCustomDependencyUid(FString DependencyUid);
    void GetCustomDependencyUid(const int32_t Index, FString& OutDependencyUid) const;
    int32_t GetCustomDependencyUidCount() const;
    void GetCustomDependencyUids(TArray<FString>& OutDependencyUids) const;
    bool GetCustomDisplayText(FString& AttributeValue) const;
    bool GetCustomVariantsPayloadKey(FString& PayloadKey) const;
    bool RemoveCustomDependencyUid(FString DependencyUid);
    bool SetCustomDisplayText(FString AttributeValue);
    bool SetCustomVariantsPayloadKey(FString PayloadKey);
};

// Size: 0xc0
class UInterchangeVolumeGridNode : public UInterchangeBaseNode {

    bool GetCustomElementType(EVolumeGridElementType& AttributeValue) const;
    bool GetCustomGridActiveAABBMax(FIntVector& AttributeValue) const;
    bool GetCustomGridActiveAABBMin(FIntVector& AttributeValue) const;
    bool GetCustomGridActiveDimensions(FIntVector& AttributeValue) const;
    bool GetCustomGridTransform(FTransform& AttributeValue) const;
    bool GetCustomNumComponents(int32_t& NumComponents) const;
    bool SetCustomElementType(const EVolumeGridElementType& AttributeValue);
    bool SetCustomGridActiveAABBMax(const FIntVector& AttributeValue);
    bool SetCustomGridActiveAABBMin(const FIntVector& AttributeValue);
    bool SetCustomGridActiveDimensions(const FIntVector& AttributeValue);
    bool SetCustomGridTransform(const FTransform& AttributeValue);
    bool SetCustomNumComponents(const int32_t& NumComponents);
};

// Size: 0xc0
class UInterchangeVolumeNode : public UInterchangeBaseNode {

    bool AddCustomFrameIndexInAnimation(int32_t Index);
    bool AddCustomGridDependency(FString DependencyUid);
    bool GetCustomAnimationID(FString& AttributeValue) const;
    bool GetCustomFileName(FString& AttributeValue) const;
    void GetCustomFrameIndexInAnimation(int32_t IndexIndex, int32_t& OutIndex) const;
    void GetCustomFrameIndicesInAnimation(TArray<int32_t>& OutAnimationIndices) const;
    void GetCustomGridDependecies(TArray<FString>& OutDependencies) const;
    int32_t GetCustomGridDependeciesCount() const;
    void GetCustomGridDependency(const int32_t Index, FString& OutDependency) const;
    bool RemoveCustomFrameIndexInAnimation(int32_t Index);
    bool RemoveCustomGridDependency(FString DependencyUid);
    bool SetCustomAnimationID(FString AttributeValue);
    bool SetCustomFileName(FString AttributeValue);
};

// Size: 0xa0
class UInterchangeVolumeTextureNode : public UInterchangeTextureNode {
};

enum class EInterchangeAnimationRange {
    Timeline = 0,
    Animated = 1,
    SetRange = 2,
    MAX = 3,
};

enum class EInterchangeForceMeshType {
    IFMT_None = 0,
    IFMT_StaticMesh = 1,
    IFMT_SkeletalMesh = 2,
    IFMT_MAX = 3,
};

enum class EInterchangeMaterialImportOption {
    ImportAsMaterials = 0,
    ImportAsMaterialInstances = 1,
    EInterchangeMaterialImportOption_MAX = 2,
};

enum class EInterchangeMaterialSearchLocation {
    Local = 0,
    UnderParent = 1,
    UnderRoot = 2,
    AllAssets = 3,
    DoNotSearch = 4,
    EInterchangeMaterialSearchLocation_MAX = 5,
};

enum class EInterchangeSceneHierarchyType {
    CreateLevelActors = 0,
    CreateLevelInstanceActor = 1,
    CreatePackedActor = 2,
    EInterchangeSceneHierarchyType_MAX = 3,
};

enum class EInterchangeVertexColorImportOption {
    IVCIO_Replace = 0,
    IVCIO_Ignore = 1,
    IVCIO_Override = 2,
    IVCIO_MAX = 3,
};

// Size: 0x90
class UGLTFPipelineSettings : public UDeveloperSettings {
    /* 0x0038 */ TMap<FString, FSoftObjectPath> MaterialParents;
};

// Size: 0x140
class UInterchangeGLTFPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
};

// Size: 0x198
class UInterchangeGenericAnimationPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ TWeakObjectPtr<UInterchangeGenericCommonSkeletalMeshesAndAnimationsProperties> CommonSkeletalMeshesAndAnimationsProperties;
    /* 0x0130 */ TWeakObjectPtr<UInterchangeGenericCommonMeshesProperties> CommonMeshesProperties;
    /* 0x0138 */ bool bImportAnimations;
    /* 0x0139 */ bool bImportBoneTracks;
    /* 0x013a */ EInterchangeAnimationRange AnimationRange;
    /* 0x013c */ FInt32Interval FrameImportRange;
    /* 0x0144 */ bool bUse30HzToBakeBoneAnimation;
    /* 0x0148 */ int32_t CustomBoneAnimationSampleRate;
    /* 0x014c */ bool bSnapToClosestFrameBoundary;
    /* 0x014d */ bool bImportCustomAttribute;
    /* 0x014e */ bool bAddCurveMetadataToSkeleton;
    /* 0x014f */ bool bSetMaterialDriveParameterOnCustomAttribute;
    /* 0x0150 */ TArray<FString> MaterialCurveSuffixes;
    /* 0x0160 */ bool bRemoveCurveRedundantKeys;
    /* 0x0161 */ bool bDoNotImportCurveWithZero;
    /* 0x0162 */ bool bDeleteExistingNonCurveCustomAttributes;
    /* 0x0163 */ bool bDeleteExistingCustomAttributeCurves;
    /* 0x0164 */ bool bDeleteExistingMorphTargetCurves;
    /* 0x0168 */ FString SourceAnimationName;
    /* 0x0178 */ bool bSceneImport;
};

// Size: 0x2b0
class UInterchangeGenericAssetsPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
    /* 0x0138 */ EReimportStrategyFlags ReimportStrategy;
    /* 0x0139 */ bool bUseSourceNameForAsset;
    /* 0x013a */ bool bSceneNameSubFolder;
    /* 0x013b */ bool bAssetTypeSubFolders;
    /* 0x0140 */ FString AssetName;
    /* 0x0150 */ FVector ImportOffsetTranslation;
    /* 0x0168 */ FRotator ImportOffsetRotation;
    /* 0x0180 */ float ImportOffsetUniformScale;
    /* 0x0188 */ UInterchangeGenericCommonMeshesProperties* CommonMeshesProperties;
    /* 0x0190 */ UInterchangeGenericCommonSkeletalMeshesAndAnimationsProperties* CommonSkeletalMeshesAndAnimationsProperties;
    /* 0x0198 */ UInterchangeGenericMeshPipeline* MeshPipeline;
    /* 0x01a0 */ UInterchangeGenericAnimationPipeline* AnimationPipeline;
    /* 0x01a8 */ UInterchangeGenericMaterialPipeline* MaterialPipeline;
    /* 0x01b0 */ FSoftObjectPath ContentPathExistingSkeleton;
    /* 0x01d0 */ bool bImportOnlyAnimationAdjusted;
};

// Size: 0x140
class UInterchangeGenericCommonMeshesProperties : public UInterchangePipelineBase {
    /* 0x0128 */ EInterchangeForceMeshType ForceAllMeshAsType;
    /* 0x0129 */ bool bAutoDetectMeshType;
    /* 0x012a */ bool bImportLods;
    /* 0x012b */ bool bBakeMeshes;
    /* 0x012c */ bool bBakePivotMeshes;
    /* 0x012d */ bool bKeepSectionsSeparate;
    /* 0x012e */ EInterchangeVertexColorImportOption VertexColorImportOption;
    /* 0x0130 */ FColor VertexOverrideColor;
    /* 0x0134 */ bool bImportSockets;
    /* 0x0135 */ bool bRecomputeNormals;
    /* 0x0136 */ bool bRecomputeTangents;
    /* 0x0137 */ bool bUseMikkTSpace;
    /* 0x0138 */ bool bComputeWeightedNormals;
    /* 0x0139 */ bool bUseHighPrecisionTangentBasis;
    /* 0x013a */ bool bUseFullPrecisionUVs;
    /* 0x013b */ bool bUseBackwardsCompatibleF16TruncUVs;
    /* 0x013c */ bool bRemoveDegenerates;
};

// Size: 0x138
class UInterchangeGenericCommonSkeletalMeshesAndAnimationsProperties : public UInterchangePipelineBase {
    /* 0x0128 */ bool bImportOnlyAnimations;
    /* 0x012c */ TWeakObjectPtr<USkeleton> Skeleton;
    /* 0x0134 */ bool bImportMeshesInBoneHierarchy;
    /* 0x0135 */ bool bUseT0AsRefPose;
    /* 0x0136 */ bool bAddCurveMetadataToSkeleton;
    /* 0x0137 */ bool bConvertStaticsWithMorphTargetsToSkeletals;
};

// Size: 0x160
class UInterchangeGenericLevelPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
    /* 0x0138 */ EReimportStrategyFlags ReimportPropertyStrategy;
    /* 0x0139 */ EInterchangeSceneHierarchyType SceneHierarchyType;
    /* 0x013a */ bool bDeleteMissingActors;
    /* 0x013b */ bool bForceReimportDeletedActors;
    /* 0x013c */ bool bForceReimportDeletedAssets;
    /* 0x013d */ bool bDeleteMissingAssets;
    /* 0x013e */ bool bUsePhysicalInsteadOfStandardPerspectiveCamera;
};

// Size: 0x1c8
class UInterchangeGenericMaterialPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
    /* 0x0138 */ bool bImportMaterials;
    /* 0x0139 */ EInterchangeMaterialSearchLocation SearchLocation;
    /* 0x0140 */ FString AssetName;
    /* 0x0150 */ EInterchangeMaterialImportOption MaterialImport;
    /* 0x0151 */ bool bIdentifyDuplicateMaterials;
    /* 0x0152 */ bool bCreateMaterialInstanceForParent;
    /* 0x0158 */ FSoftObjectPath ParentMaterial;
    /* 0x0178 */ UInterchangeGenericTexturePipeline* TexturePipeline;
    /* 0x0180 */ UInterchangeSparseVolumeTexturePipeline* SparseVolumeTexturePipeline;
    /* 0x0188 */ bool bOverrideDisplacement;
    /* 0x018c */ float OverrideDisplacementCenter;
    /* 0x0190 */ UInterchangeBaseNodeContainer* BaseNodeContainer;
};

// Size: 0x240
class UInterchangeGenericMeshPipeline : public UInterchangePipelineBase {
    /* 0x0128 */ TWeakObjectPtr<UInterchangeGenericCommonMeshesProperties> CommonMeshesProperties;
    /* 0x0130 */ TWeakObjectPtr<UInterchangeGenericCommonSkeletalMeshesAndAnimationsProperties> CommonSkeletalMeshesAndAnimationsProperties;
    /* 0x0138 */ bool bImportStaticMeshes;
    /* 0x0139 */ bool bCombineStaticMeshes;
    /* 0x013c */ FName LODGroup;
    /* 0x0144 */ bool bAutoComputeLODScreenSizes;
    /* 0x0148 */ TArray<float> LODScreenSizes;
    /* 0x0158 */ bool bImportCollision;
    /* 0x0159 */ bool bCollision;
    /* 0x015a */ bool bImportCollisionAccordingToMeshName;
    /* 0x015b */ bool bOneConvexHullPerUCX;
    /* 0x015c */ EInterchangeMeshCollision Collision;
    /* 0x015d */ bool bForceCollisionPrimitiveGeneration;
    /* 0x015e */ bool bBuildNanite;
    /* 0x015f */ bool bBuildReversedIndexBuffer;
    /* 0x0160 */ bool bGenerateLightmapUVs;
    /* 0x0161 */ bool bGenerateDistanceFieldAsIfTwoSided;
    /* 0x0162 */ bool bSupportFaceRemap;
    /* 0x0164 */ int32_t MinLightmapResolution;
    /* 0x0168 */ int32_t SrcLightmapIndex;
    /* 0x016c */ int32_t DstLightmapIndex;
    /* 0x0170 */ FVector BuildScale3D;
    /* 0x0188 */ float DistanceFieldResolutionScale;
    /* 0x018c */ TWeakObjectPtr<UStaticMesh> DistanceFieldReplacementMesh;
    /* 0x0194 */ int32_t MaxLumenMeshCards;
    /* 0x0198 */ bool bImportSkeletalMeshes;
    /* 0x0199 */ EInterchangeSkeletalMeshContentType SkeletalMeshImportContentType;
    /* 0x019a */ EInterchangeSkeletalMeshContentType LastSkeletalMeshImportContentType;
    /* 0x019b */ bool bCombineSkeletalMeshes;
    /* 0x019c */ bool bImportMorphTargets;
    /* 0x019d */ bool bMergeMorphTargetsWithSameName;
    /* 0x019e */ bool bImportVertexAttributes;
    /* 0x019f */ bool bUpdateSkeletonReferencePose;
    /* 0x01a0 */ bool bCreatePhysicsAsset;
    /* 0x01a4 */ TWeakObjectPtr<UPhysicsAsset> PhysicsAsset;
    /* 0x01ac */ bool bUseHighPrecisionSkinWeights;
    /* 0x01b0 */ float ThresholdPosition;
    /* 0x01b4 */ float ThresholdTangentNormal;
    /* 0x01b8 */ float ThresholdUV;
    /* 0x01bc */ float MorphThresholdPosition;
    /* 0x01c0 */ int32_t BoneInfluenceLimit;
    /* 0x01c4 */ bool bImportGeometryCaches;
    /* 0x01c5 */ bool bFlattenTracks;
    /* 0x01c8 */ float CompressedPositionPrecision;
    /* 0x01cc */ int32_t CompressedTextureCoordinatesNumberOfBits;
    /* 0x01d0 */ bool bOverrideTimeRange;
    /* 0x01d4 */ int32_t FrameStart;
    /* 0x01d8 */ int32_t FrameEnd;
    /* 0x01dc */ EInterchangeMotionVectorsHandling MotionVectors;
    /* 0x01dd */ bool bApplyConstantTopologyOptimizations;
    /* 0x01de */ bool bStoreImportedVertexNumbers;
    /* 0x01df */ bool bOptimizeIndexBuffers;

    bool GetCombineSkeletalMeshes() const;
    void SetCombineSkeletalMeshes(bool InbCombineSkeletalMeshes);
};

// Size: 0x190
class UInterchangeGenericTexturePipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
    /* 0x0138 */ bool bImportTextures;
    /* 0x0140 */ FString AssetName;
    /* 0x0150 */ bool bAllowNonPowerOfTwo;
    /* 0x0158 */ UInterchangeBaseNodeContainer* BaseNodeContainer;
};

// Size: 0x10
struct FInterchangeLodSceneNodeContainer {
    /* 0x0000 */ TArray<UInterchangeSceneNode*> SceneNodes;
};

// Size: 0x130
class UInterchangeMaterialXPipeline : public UInterchangePipelineBase {
};

// Size: 0x38
struct FInterchangeMeshGeometry {
    /* 0x0000 */ FString MeshUid;
    /* 0x0010 */ UInterchangeMeshNode* MeshNode;
    /* 0x0018 */ TArray<FString> ReferencingMeshInstanceUids;
    /* 0x0028 */ TArray<FString> AttachedSocketUids;
};

// Size: 0x80
struct FInterchangeMeshInstance {
    /* 0x0000 */ FString MeshInstanceUid;
    /* 0x0010 */ UInterchangeSceneNode* LodGroupNode;
    /* 0x0018 */ bool bReferenceSkinnedMesh;
    /* 0x0019 */ bool bReferenceMorphTarget;
    /* 0x001a */ bool bHasMorphTargets;
    /* 0x001b */ bool bIsAnimated;
    /* 0x0020 */ TMap<int32_t, FInterchangeLodSceneNodeContainer> SceneNodePerLodIndex;
    /* 0x0070 */ TArray<FString> ReferencingMeshGeometryUids;
};

// Size: 0x128
class UInterchangePipelineMeshesUtilities : public UObject {

    static UInterchangePipelineMeshesUtilities* CreateInterchangePipelineMeshesUtilities(UInterchangeBaseNodeContainer* BaseNodeContainer);
    void GetAllGeometryCacheGeometry(TArray<FString>& MeshGeometryUids) const;
    void GetAllGeometryCacheInstance(TArray<FString>& MeshInstanceUids) const;
    void GetAllMeshGeometry(TArray<FString>& MeshGeometryUids) const;
    void GetAllMeshGeometryNotInstanced(TArray<FString>& MeshGeometryUids) const;
    void GetAllMeshInstanceUids(TArray<FString>& MeshInstanceUids) const;
    void GetAllMeshInstanceUidsUsingMeshGeometryUid(FString MeshGeometryUid, TArray<FString>& MeshInstanceUids) const;
    void GetAllSkinnedMeshGeometry(TArray<FString>& MeshGeometryUids) const;
    void GetAllSkinnedMeshInstance(TArray<FString>& MeshInstanceUids) const;
    void GetAllStaticMeshGeometry(TArray<FString>& MeshGeometryUids) const;
    void GetAllStaticMeshInstance(TArray<FString>& MeshInstanceUids) const;
    FInterchangeMeshGeometry GetMeshGeometryByUid(FString MeshGeometryUid) const;
    FString GetMeshGeometrySkeletonRootUid(FString MeshGeometryUid) const;
    FInterchangeMeshInstance GetMeshInstanceByUid(FString MeshInstanceUid) const;
    FString GetMeshInstanceSkeletonRootUid(FString MeshInstanceUid) const;
    bool IsValidMeshGeometryUid(FString MeshGeometryUid) const;
    bool IsValidMeshInstanceUid(FString MeshInstanceUid) const;
    void SetContext(const FInterchangePipelineMeshesUtilitiesContext& Context) const;
};

// Size: 0x7
struct FInterchangePipelineMeshesUtilitiesContext {
    /* 0x0000 */ bool bConvertStaticMeshToSkeletalMesh;
    /* 0x0001 */ bool bConvertSkeletalMeshToStaticMesh;
    /* 0x0002 */ bool bConvertStaticsWithMorphTargetsToSkeletals;
    /* 0x0003 */ bool bImportMeshesInBoneHierarchy;
    /* 0x0004 */ bool bQueryGeometryOnlyIfNoInstance;
    /* 0x0005 */ bool bIgnoreStaticMeshes;
    /* 0x0006 */ bool bIgnoreGeometryCaches;
};

// Size: 0x158
class UInterchangeSparseVolumeTexturePipeline : public UInterchangePipelineBase {
    /* 0x0128 */ FString PipelineDisplayName;
    /* 0x0138 */ bool bImportSparseVolumeTextures;
    /* 0x0139 */ bool bImportAnimatedSparseVolumeTextures;
    /* 0x0140 */ FString AssetName;
    /* 0x0150 */ UInterchangeBaseNodeContainer* BaseNodeContainer;
};

// Size: 0x178
class UMaterialXPipelineSettings : public UDeveloperSettings {
    /* 0x0038 */ TMap<EInterchangeMaterialXShaders, FSoftObjectPath> PredefinedSurfaceShaders;
    /* 0x0088 */ TMap<EInterchangeMaterialXBSDF, FSoftObjectPath> PredefinedBSDF;
    /* 0x00d8 */ TMap<EInterchangeMaterialXEDF, FSoftObjectPath> PredefinedEDF;
    /* 0x0128 */ TMap<EInterchangeMaterialXVDF, FSoftObjectPath> PredefinedVDF;
};

// Size: 0x60
class UAlwaysRelevantNetObjectFilter : public UNetObjectFilter {
};

// Size: 0x28
class UAlwaysRelevantNetObjectFilterConfig : public UNetObjectFilterConfig {
};

// Size: 0x40
struct FArrayPropertyNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint16_t MaxElementCount;
    /* 0x0012 */ uint16_t ElementCountBitCount;
    /* 0x0018 */ FFieldPath Property;
};

// Size: 0x18
struct FBitfieldNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint8_t BitMask;
};

// Size: 0x10
struct FBoolNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x68
class UChunkedDataStream : public UDataStream {
    /* 0x0060 */ UIrisObjectReferencePackageMap* PackageMap;
};

// Size: 0x50
class UDataStream : public UObject {
};

// Size: 0x20
struct FDataStreamDefinition {
    /* 0x0000 */ FName DataStreamName;
    /* 0x0008 */ FName ClassName;
    /* 0x0010 */ UClass* Class;
    /* 0x0018 */ EDataStreamSendStatus DefaultSendStatus;
    /* 0x0019 */ bool bAutoCreate;
    /* 0x001a */ bool bDynamicCreate;
};

// Size: 0x40
class UDataStreamDefinitions : public UObject {
    /* 0x0028 */ TArray<FDataStreamDefinition> DataStreamDefinitions;
};

// Size: 0x58
class UDataStreamManager : public UDataStream {
};

// Size: 0x10
struct FDateTimeNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FDoubleNetSerializerConfig : public FNetSerializerConfig {
};

enum class EDataStreamSendStatus {
    Pause = 0,
    Send = 1,
    EDataStreamSendStatus_MAX = 2,
};

enum class ENetObjectCountLimiterMode {
    RoundRobin = 0,
    Fill = 1,
    ENetObjectCountLimiterMode_MAX = 2,
};

// Size: 0x20
struct FEnumInt16NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int16_t LowerBound;
    /* 0x0012 */ int16_t UpperBound;
    /* 0x0014 */ uint8_t BitCount;
};

// Size: 0x28
struct FEnumInt32NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int32_t LowerBound;
    /* 0x0014 */ int32_t UpperBound;
    /* 0x0018 */ uint8_t BitCount;
};

// Size: 0x30
struct FEnumInt64NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int64_t LowerBound;
    /* 0x0018 */ int64_t UpperBound;
    /* 0x0020 */ uint8_t BitCount;
};

// Size: 0x20
struct FEnumInt8NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int8_t LowerBound;
    /* 0x0011 */ int8_t UpperBound;
    /* 0x0012 */ uint8_t BitCount;
};

// Size: 0x20
struct FEnumUint16NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint16_t LowerBound;
    /* 0x0012 */ uint16_t UpperBound;
    /* 0x0014 */ uint8_t BitCount;
};

// Size: 0x28
struct FEnumUint32NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint32_t LowerBound;
    /* 0x0014 */ uint32_t UpperBound;
    /* 0x0018 */ uint8_t BitCount;
};

// Size: 0x30
struct FEnumUint64NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint64_t LowerBound;
    /* 0x0018 */ uint64_t UpperBound;
    /* 0x0020 */ uint8_t BitCount;
};

// Size: 0x20
struct FEnumUint8NetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint8_t LowerBound;
    /* 0x0011 */ uint8_t UpperBound;
    /* 0x0012 */ uint8_t BitCount;
};

// Size: 0x68
class UFieldOfViewNetObjectPrioritizer : public ULocationBasedNetObjectPrioritizer {
};

// Size: 0x58
class UFieldOfViewNetObjectPrioritizerConfig : public UNetObjectPrioritizerConfig {
    /* 0x0028 */ float InnerSphereRadius;
    /* 0x002c */ float InnerSpherePriority;
    /* 0x0030 */ float OuterSphereRadius;
    /* 0x0034 */ float OuterSpherePriority;
    /* 0x0038 */ float ConeFieldOfViewDegrees;
    /* 0x003c */ float InnerConeLength;
    /* 0x0040 */ float ConeLength;
    /* 0x0044 */ float MinConePriority;
    /* 0x0048 */ float MaxConePriority;
    /* 0x004c */ float LineOfSightWidth;
    /* 0x0050 */ float LineOfSightPriority;
    /* 0x0054 */ float OutsidePriority;
};

// Size: 0x30
struct FFieldPathNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ FFieldPath Property;
};

// Size: 0x18
struct FFieldPathNetSerializerSerializationHelper {
    /* 0x0000 */ TWeakObjectPtr<UStruct> Owner;
    /* 0x0008 */ TArray<FName> PropertyPath;
};

// Size: 0x60
class UFilterOutNetObjectFilter : public UNetObjectFilter {
};

// Size: 0x28
class UFilterOutNetObjectFilterConfig : public UNetObjectFilterConfig {
};

// Size: 0x10
struct FFloatNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FGuidNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x168
struct FInstancedStructNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ TArray<TSoftObjectPtr<UScriptStruct>> SupportedTypes;
};

// Size: 0x18
struct FInt16RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int16_t LowerBound;
    /* 0x0012 */ int16_t UpperBound;
    /* 0x0014 */ uint8_t BitCount;
};

// Size: 0x20
struct FInt32RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int32_t LowerBound;
    /* 0x0014 */ int32_t UpperBound;
    /* 0x0018 */ uint8_t BitCount;
};

// Size: 0x28
struct FInt64RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int64_t LowerBound;
    /* 0x0018 */ int64_t UpperBound;
    /* 0x0020 */ uint8_t BitCount;
};

// Size: 0x18
struct FInt8RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int8_t LowerBound;
    /* 0x0011 */ int8_t UpperBound;
    /* 0x0012 */ uint8_t BitCount;
};

// Size: 0x18
struct FIntNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint8_t BitCount;
};

// Size: 0x120
struct FIrisFastArraySerializer : public FFastArraySerializer {
    /* 0x010c */ uint32_t ChangeMaskStorage[4];
};

// Size: 0x100
class UIrisObjectReferencePackageMap : public UPackageMap {
};

// Size: 0x38
struct FLastResortPropertyNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ FFieldPath Property;
    /* 0x0030 */ bool bExcludeFromDefaultStateHash;
};

// Size: 0x60
class ULocationBasedNetObjectPrioritizer : public UNetObjectPrioritizer {
};

// Size: 0x10
struct FNameAsNetTokenNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FNameNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x38
class UNetBlobHandler : public UObject {
};

// Size: 0x8
struct FNetBlobHandlerDefinition {
    /* 0x0000 */ FName ClassName;
};

// Size: 0x38
class UNetBlobHandlerDefinitions : public UObject {
    /* 0x0028 */ TArray<FNetBlobHandlerDefinition> NetBlobHandlerDefinitions;
};

// Size: 0x38
class UNetObjectBlobHandler : public UNetBlobHandler {
};

// Size: 0xa8
class UNetObjectConnectionFilter : public UNetObjectFilter {
};

// Size: 0x30
class UNetObjectConnectionFilterConfig : public UNetObjectFilterConfig {
    /* 0x0028 */ uint16_t MaxObjectCount;
};

// Size: 0x90
class UNetObjectCountLimiter : public UNetObjectPrioritizer {
};

// Size: 0x40
class UNetObjectCountLimiterConfig : public UNetObjectPrioritizerConfig {
    /* 0x0028 */ ENetObjectCountLimiterMode Mode;
    /* 0x002c */ uint32_t MaxObjectCount;
    /* 0x0030 */ float Priority;
    /* 0x0034 */ float OwningConnectionPriority;
    /* 0x0038 */ bool bEnableOwnedObjectsFastLane;
};

// Size: 0x38
class UNetObjectFactory : public UObject {
};

// Size: 0x60
class UNetObjectFilter : public UObject {
};

// Size: 0x28
class UNetObjectFilterConfig : public UObject {
};

// Size: 0x18
struct FNetObjectFilterDefinition {
    /* 0x0000 */ FName FilterName;
    /* 0x0008 */ FName ClassName;
    /* 0x0010 */ FName ConfigClassName;
};

// Size: 0x38
class UNetObjectFilterDefinitions : public UObject {
    /* 0x0028 */ TArray<FNetObjectFilterDefinition> NetObjectFilterDefinitions;
};

// Size: 0x188
class UNetObjectGridFilter : public UNetObjectFilter {
};

// Size: 0x50
class UNetObjectGridFilterConfig : public UNetObjectFilterConfig {
    /* 0x0028 */ uint32_t ViewPosRelevancyFrameCount;
    /* 0x002c */ uint16_t DefaultFrameCountBeforeCulling;
    /* 0x0030 */ float CellSizeX;
    /* 0x0034 */ float CellSizeY;
    /* 0x0038 */ float DefaultCullDistance;
    /* 0x003c */ bool bUseExactCullDistance;
    /* 0x0040 */ TArray<FNetObjectGridFilterProfile> FilterProfiles;
};

// Size: 0xc
struct FNetObjectGridFilterProfile {
    /* 0x0000 */ FName FilterProfileName;
    /* 0x0008 */ uint16_t FrameCountBeforeCulling;
};

// Size: 0x190
class UNetObjectGridWorldLocFilter : public UNetObjectGridFilter {
};

// Size: 0x28
class UNetObjectPrioritizer : public UObject {
};

// Size: 0x28
class UNetObjectPrioritizerConfig : public UObject {
};

// Size: 0x28
struct FNetObjectPrioritizerDefinition {
    /* 0x0000 */ FName PrioritizerName;
    /* 0x0008 */ FName ClassName;
    /* 0x0010 */ UClass* Class;
    /* 0x0018 */ FName ConfigClassName;
    /* 0x0020 */ UClass* ConfigClass;
};

// Size: 0x38
class UNetObjectPrioritizerDefinitions : public UObject {
    /* 0x0028 */ TArray<FNetObjectPrioritizerDefinition> NetObjectPrioritizerDefinitions;
};

// Size: 0x40
class UNetRPCHandler : public UNetBlobHandler {
};

// Size: 0x28
struct FNetRoleNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ int32_t RelativeInternalOffsetToOtherRole;
    /* 0x0014 */ int32_t RelativeExternalOffsetToOtherRole;
    /* 0x0018 */ uint8_t LowerBound;
    /* 0x0019 */ uint8_t UpperBound;
    /* 0x001a */ uint8_t BitCount;
    /* 0x001b */ uint8_t AutonomousProxyValue;
    /* 0x001c */ uint8_t SimulatedProxyValue;
};

// Size: 0x10
struct FNetSerializerConfig {
};

// Size: 0xa0
class UNetTokenDataStream : public UDataStream {
};

// Size: 0x18
struct FNetTokenStoreTypeIdPair {
    /* 0x0000 */ FString StoreTypeName;
    /* 0x0010 */ uint32_t TypeID;
};

// Size: 0x38
class UNetTokenTypeIdConfig : public UObject {
    /* 0x0028 */ TArray<FNetTokenStoreTypeIdPair> ReservedTypeIds;
};

// Size: 0x60
class UNopNetObjectFilter : public UNetObjectFilter {
};

// Size: 0x28
class UNopNetObjectFilterConfig : public UNetObjectFilterConfig {
};

// Size: 0x10
struct FNopNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FObjectNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0xc
struct FObjectReplicatedBridgeCriticalClassConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ bool bDisconnectOnProtocolMismatch;
};

// Size: 0x640
class UObjectReplicationBridge : public UReplicationBridge {
    /* 0x0580 */ TArray<UNetObjectFactory*> NetObjectFactories;
};

// Size: 0xb0
class UObjectReplicationBridgeConfig : public UObject {
    /* 0x0028 */ TArray<FObjectReplicationBridgePollConfig> PollConfigs;
    /* 0x0038 */ TArray<FObjectReplicationBridgeFilterConfig> FilterConfigs;
    /* 0x0048 */ TArray<FObjectReplicationBridgePrioritizerConfig> PrioritizerConfigs;
    /* 0x0058 */ TArray<FObjectReplicationBridgeDeltaCompressionConfig> DeltaCompressionConfigs;
    /* 0x0068 */ TArray<FObjectReplicatedBridgeCriticalClassConfig> CriticalClassConfigs;
    /* 0x0078 */ bool bAllClassesCritical;
    /* 0x0080 */ TArray<FObjectReplicationBridgeTypeStatsConfig> TypeStatsConfigs;
    /* 0x0090 */ FName DefaultSpatialFilterName;
    /* 0x0098 */ FName RequiredNetDriverChannelClassName;
    /* 0x00a0 */ TArray<FName> CriticalActorClasses;
};

// Size: 0xc
struct FObjectReplicationBridgeDeltaCompressionConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ bool bEnableDeltaCompression;
};

// Size: 0x1c
struct FObjectReplicationBridgeFilterConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ FName DynamicFilterName;
    /* 0x0010 */ FName FilterProfile;
    /* 0x0018 */ bool bForceEnableOnAllInstances;
};

// Size: 0x10
struct FObjectReplicationBridgePollConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ float PollFrequency;
    /* 0x000c */ bool bIncludeSubclasses;
};

// Size: 0x14
struct FObjectReplicationBridgePrioritizerConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ FName PrioritizerName;
    /* 0x0010 */ bool bForceEnableOnAllInstances;
};

// Size: 0x14
struct FObjectReplicationBridgeTypeStatsConfig {
    /* 0x0000 */ FName ClassName;
    /* 0x0008 */ FName TypeStatsName;
    /* 0x0010 */ bool bIncludeInMinimalCSVStats;
};

// Size: 0xc
struct FObjectScopeHysteresisProfile {
    /* 0x0000 */ FName FilterProfileName;
    /* 0x0008 */ uint8_t HysteresisFrameCount;
};

// Size: 0x10
struct FPackedInt32NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FPackedInt64NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FPackedUint32NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FPackedUint64NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x150
class UPartialNetObjectAttachmentHandler : public USequentialPartialNetBlobHandler {
};

// Size: 0x40
class UPartialNetObjectAttachmentHandlerConfig : public USequentialPartialNetBlobHandlerConfig {
    /* 0x0030 */ uint32_t BitCountSplitThreshold;
    /* 0x0034 */ uint32_t ClientUnreliableBitCountSplitThreshold;
    /* 0x0038 */ uint32_t ServerUnreliableBitCountSplitThreshold;
};

// Size: 0x28
struct FPolymorphicArrayStructNetSerializerConfig : public FPolymorphicStructNetSerializerConfig {
};

// Size: 0x28
struct FPolymorphicStructNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x30
struct FRemoteObjectReferenceNetSerializationHelper {
    /* 0x0000 */ FRemoteObjectId ObjectId;
    /* 0x0008 */ FRemoteServerId ServerId;
    /* 0x0010 */ FRemoteObjectPathName Path;
};

// Size: 0x10
struct FRemoteObjectReferenceNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x168
class UReplicationBridge : public UObject {
};

// Size: 0x60
class UReplicationDataStream : public UDataStream {
};

// Size: 0x40
class UReplicationFilteringConfig : public UObject {
    /* 0x0028 */ bool bEnableObjectScopeHysteresis;
    /* 0x0029 */ uint8_t DefaultHysteresisFrameCount;
    /* 0x002a */ uint8_t HysteresisUpdateConnectionThrottling;
    /* 0x0030 */ TArray<FObjectScopeHysteresisProfile> HysteresisProfiles;
};

// Size: 0x8
struct FReplicationStateDescriptorClassPushModelConfig {
    /* 0x0000 */ FName ClassName;
};

// Size: 0x50
class UReplicationStateDescriptorConfig : public UObject {
    /* 0x0028 */ TArray<FSupportsStructNetSerializerConfig> SupportsStructNetSerializerList;
    /* 0x0038 */ TArray<FReplicationStateDescriptorClassPushModelConfig> EnsureFullyPushModelClassNames;
    /* 0x0048 */ bool bEnsureAllClassesAreFullyPushModel;
};

// Size: 0x58
class UReplicationSystem : public UObject {
    /* 0x0038 */ UReplicationBridge* ReplicationBridge;
};

// Size: 0x10
struct FRotator3dNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FRotator3fNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FRotatorAsByteNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FRotatorAsShortNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FRotatorNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x18
struct FScriptInterfaceNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ UClass* InterfaceClass;
};

// Size: 0x48
class USequentialPartialNetBlobHandler : public UNetBlobHandler {
};

// Size: 0x30
class USequentialPartialNetBlobHandlerConfig : public UObject {
    /* 0x0028 */ uint32_t MaxPartBitCount;
    /* 0x002c */ uint32_t MaxPartCount;
};

// Size: 0x10
struct FSoftClassPathNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FSoftObjectNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FSoftObjectPathNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x68
class USphereNetObjectPrioritizer : public ULocationBasedNetObjectPrioritizer {
};

// Size: 0x40
class USphereNetObjectPrioritizerConfig : public UNetObjectPrioritizerConfig {
    /* 0x0028 */ float InnerRadius;
    /* 0x002c */ float OuterRadius;
    /* 0x0030 */ float InnerPriority;
    /* 0x0034 */ float OuterPriority;
    /* 0x0038 */ float OutsidePriority;
};

// Size: 0xa0
class USphereWithOwnerBoostNetObjectPrioritizer : public USphereNetObjectPrioritizer {
};

// Size: 0x48
class USphereWithOwnerBoostNetObjectPrioritizerConfig : public USphereNetObjectPrioritizerConfig {
    /* 0x0040 */ float OwnerPriorityBoost;
};

// Size: 0x10
struct FStringNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x18
struct FStructNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0xc
struct FSupportsStructNetSerializerConfig {
    /* 0x0000 */ FName StructName;
    /* 0x0008 */ bool bCanUseStructNetSerializer;
};

// Size: 0x18
struct FUint16RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint16_t LowerBound;
    /* 0x0012 */ uint16_t UpperBound;
    /* 0x0014 */ uint8_t BitCount;
};

// Size: 0x20
struct FUint32RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint32_t LowerBound;
    /* 0x0014 */ uint32_t UpperBound;
    /* 0x0018 */ uint8_t BitCount;
};

// Size: 0x28
struct FUint64RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint64_t LowerBound;
    /* 0x0018 */ uint64_t UpperBound;
    /* 0x0020 */ uint8_t BitCount;
};

// Size: 0x18
struct FUint8RangeNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint8_t LowerBound;
    /* 0x0011 */ uint8_t UpperBound;
    /* 0x0012 */ uint8_t BitCount;
};

// Size: 0x18
struct FUintNetSerializerConfig : public FNetSerializerConfig {
    /* 0x0010 */ uint8_t BitCount;
};

// Size: 0x10
struct FUnitQuat4dNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FUnitQuat4fNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FUnitQuatNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVector3dNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVector3fNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVectorNetQuantize100NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVectorNetQuantize10NetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVectorNetQuantizeNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVectorNetQuantizeNormalNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FVectorNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x10
struct FWeakObjectNetSerializerConfig : public FNetSerializerConfig {
};

// Size: 0x60
class UWorldLocationsConfig : public UObject {
    /* 0x0028 */ FVector MinPos;
    /* 0x0040 */ FVector MaxPos;
    /* 0x0058 */ float MaxNetCullDistance;
};

// Size: 0x20
struct FJsonObjectWrapper {
    /* 0x0000 */ FString JsonString;
};

// Size: 0x28
class UJsonUtilitiesDummyObject : public UObject {
};

// Size: 0x2b0
class AControlPointMeshActor : public AActor {
    /* 0x02a8 */ UControlPointMeshComponent* ControlPointMeshComponent;
};

// Size: 0x620
class UControlPointMeshComponent : public UStaticMeshComponent {
    /* 0x0610 */ float VirtualTextureMainPassMaxDrawDistance;
};

enum class EGrassScaling {
    Uniform = 0,
    Free = 1,
    LockXY = 2,
    EGrassScaling_MAX = 3,
};

enum class EHeightmapRTType {
    HeightmapRT_CombinedAtlas = 0,
    HeightmapRT_CombinedNonAtlas = 1,
    HeightmapRT_Scratch1 = 2,
    HeightmapRT_Scratch2 = 3,
    HeightmapRT_Scratch3 = 4,
    HeightmapRT_Mip1 = 5,
    HeightmapRT_Mip2 = 6,
    HeightmapRT_Mip3 = 7,
    HeightmapRT_Mip4 = 8,
    HeightmapRT_Mip5 = 9,
    HeightmapRT_Mip6 = 10,
    HeightmapRT_Mip7 = 11,
    HeightmapRT_Count = 12,
    HeightmapRT_MAX = 13,
};

enum class ELandscapeBlendMode {
    LSBM_AdditiveBlend = 0,
    LSBM_AlphaBlend = 1,
    LSBM_MAX = 2,
};

enum class ELandscapeClearMode {
    Clear_Weightmap = 1,
    Clear_Heightmap = 2,
    Clear_All = 3,
    Clear_MAX = 4,
};

enum class ELandscapeCustomizedCoordType {
    LCCT_None = 0,
    LCCT_CustomUV0 = 1,
    LCCT_CustomUV1 = 2,
    LCCT_CustomUV2 = 3,
    LCCT_WeightMapUV = 4,
    LCCT_MAX = 5,
};

enum class ELandscapeDirtyingMode {
    Auto = 0,
    InLandscapeModeOnly = 1,
    InLandscapeModeAndUserTriggeredChanges = 2,
    ELandscapeDirtyingMode_MAX = 3,
};

enum class ELandscapeGizmoSnapType {
    None = 0,
    Component = 1,
    Texel = 2,
    ELandscapeGizmoSnapType_MAX = 3,
};

enum class ELandscapeGizmoType {
    LGT_None = 0,
    LGT_Height = 1,
    LGT_Weight = 2,
    LGT_MAX = 3,
};

enum class ELandscapeHLODMeshSourceLODPolicy {
    AutomaticLOD = 0,
    SpecificLOD = 1,
    LowestDetailLOD = 2,
    ELandscapeHLODMeshSourceLODPolicy_MAX = 3,
};

enum class ELandscapeHLODTextureSizePolicy {
    AutomaticSize = 0,
    SpecificSize = 1,
    ELandscapeHLODTextureSizePolicy_MAX = 2,
};

enum class ELandscapeImportAlphamapType {
    Additive = 0,
    Layered = 1,
    ELandscapeImportAlphamapType_MAX = 2,
};

enum class ELandscapeLODFalloff {
    Linear = 0,
    SquareRoot = 1,
    ELandscapeLODFalloff_MAX = 2,
};

enum class ELandscapeLayerBlendType {
    LB_WeightBlend = 0,
    LB_AlphaBlend = 1,
    LB_HeightBlend = 2,
    LB_MAX = 3,
};

enum class ELandscapeLayerDisplayMode {
    Default = 0,
    Alphabetical = 1,
    UserSpecific = 2,
    ELandscapeLayerDisplayMode_MAX = 3,
};

enum class ELandscapeLayerPaintingRestriction {
    None = 0,
    UseMaxLayers = 1,
    ExistingOnly = 2,
    UseComponentAllowList = 3,
    ELandscapeLayerPaintingRestriction_MAX = 4,
};

enum class ELandscapeResizeMode {
    Resample = 0,
    Clip = 1,
    Expand = 2,
    ELandscapeResizeMode_MAX = 3,
};

enum class ELandscapeTextureType {
    Unknown = 0,
    Heightmap = 1,
    Weightmap = 2,
    ELandscapeTextureType_MAX = 3,
};

enum class ELandscapeTextureUsage {
    Unknown = 0,
    EditLayerData = 1,
    FinalData = 2,
    ELandscapeTextureUsage_MAX = 3,
};

enum class ELandscapeToolTargetType {
    Heightmap = 0,
    Weightmap = 1,
    Visibility = 2,
    Invalid = 3,
    Count = 3,
    ELandscapeToolTargetType_MAX = 4,
};

enum class ERTDrawingType {
    RTAtlas = 0,
    RTAtlasToNonAtlas = 1,
    RTNonAtlasToAtlas = 2,
    RTNonAtlas = 3,
    RTMips = 4,
    ERTDrawingType_MAX = 5,
};

enum class ESplineModulationColorMask {
    Red = 0,
    Green = 1,
    Blue = 2,
    Alpha = 3,
    ESplineModulationColorMask_MAX = 4,
};

enum class ETerrainCoordMappingType {
    TCMT_Auto = 0,
    TCMT_XY = 1,
    TCMT_XZ = 2,
    TCMT_YZ = 3,
    TCMT_MAX = 4,
};

enum class EWeightmapRTType {
    WeightmapRT_Scratch_RGBA = 0,
    WeightmapRT_Scratch1 = 1,
    WeightmapRT_Scratch2 = 2,
    WeightmapRT_Scratch3 = 3,
    WeightmapRT_Mip0 = 4,
    WeightmapRT_Mip1 = 5,
    WeightmapRT_Mip2 = 6,
    WeightmapRT_Mip3 = 7,
    WeightmapRT_Mip4 = 8,
    WeightmapRT_Mip5 = 9,
    WeightmapRT_Mip6 = 10,
    WeightmapRT_Mip7 = 11,
    WeightmapRT_Count = 12,
    WeightmapRT_MAX = 13,
};

// Size: 0x1
struct FForeignControlPointData {
};

// Size: 0x1
struct FForeignSplineSegmentData {
};

// Size: 0x1
struct FForeignWorldSplineData {
};

// Size: 0x50
struct FGizmoSelectData {
};

// Size: 0x38
struct FGrassInput {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ ULandscapeGrassType* GrassType;
    /* 0x0010 */ FExpressionInput Input;
};

// Size: 0x1b8
struct FGrassVariety {
    /* 0x0000 */ UStaticMesh* GrassMesh;
    /* 0x0008 */ TArray<UMaterialInterface*> OverrideMaterials;
    /* 0x0018 */ FPerPlatformFloat GrassDensity;
    /* 0x0020 */ FPerQualityLevelFloat GrassDensityQuality;
    /* 0x0088 */ bool bUseGrid;
    /* 0x008c */ float PlacementJitter;
    /* 0x0090 */ FPerPlatformInt StartCullDistance;
    /* 0x0098 */ FPerQualityLevelInt StartCullDistanceQuality;
    /* 0x0100 */ FPerPlatformInt EndCullDistance;
    /* 0x0108 */ FPerQualityLevelInt EndCullDistanceQuality;
    /* 0x0170 */ int32_t MinLOD;
    /* 0x0174 */ FFloatInterval AllowedDensityRange;
    /* 0x017c */ EGrassScaling Scaling;
    /* 0x0180 */ FFloatInterval ScaleX;
    /* 0x0188 */ FFloatInterval ScaleY;
    /* 0x0190 */ FFloatInterval ScaleZ;
    /* 0x0198 */ bool bWeightAttenuatesMaxScale;
    /* 0x019c */ float MaxScaleWeightAttenuation;
    /* 0x01a0 */ bool RandomRotation;
    /* 0x01a1 */ bool AlignToSurface;
    /* 0x01a2 */ bool bUseLandscapeLightmap;
    /* 0x01a3 */ FLightingChannels LightingChannels;
    /* 0x01a4 */ bool bReceivesDecals;
    /* 0x01a5 */ bool bAffectDistanceFieldLighting;
    /* 0x01a6 */ bool bCastDynamicShadow;
    /* 0x01a7 */ bool bCastContactShadow;
    /* 0x01a8 */ bool bKeepInstanceBufferCPUCopy;
    /* 0x01ac */ uint32_t InstanceWorldPositionOffsetDisableDistance;
    /* 0x01b0 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
};

// Size: 0x8
struct FHeightmapData {
    /* 0x0000 */ UTexture2D* Texture;
};

// Size: 0x58
struct FHeightmapTextureEdgeSnapshot {
};

// Size: 0x7c0
class ALandscape : public ALandscapeProxy {

    TArray<FName> GetTargetLayerNames(bool bInIncludeVisibilityLayer) const;
    bool RenderHeightmap(FTransform InWorldTransform, FBox2D InExtents, UTextureRenderTarget2D* OutRenderTarget);
    bool RenderWeightmap(FTransform InWorldTransform, FBox2D InExtents, FName InWeightmapLayerName, UTextureRenderTarget2D* OutRenderTarget);
    bool RenderWeightmaps(FTransform InWorldTransform, FBox2D InExtents, const TArray<FName>& InWeightmapLayerNames, UTextureRenderTarget* OutRenderTarget);
};

// Size: 0x2c8
class ALandscapeBlueprintBrushBase : public AActor {
    /* 0x02a8 */ bool UpdateOnPropertyChange;
    /* 0x02a9 */ bool AffectHeightmap;
    /* 0x02aa */ bool AffectWeightmap;
    /* 0x02ab */ bool AffectVisibilityLayer;
    /* 0x02b0 */ TArray<FName> AffectedWeightmapLayers;
    /* 0x02c0 */ bool bUsePowerOfTwoRenderTarget;

    void GetBlueprintRenderDependencies(TArray<UObject*>& OutStreamableAssets);
    void Initialize(const FTransform& InLandscapeTransform, const FIntPoint& InLandscapeSize, const FIntPoint& InLandscapeRenderTargetSize);
    UTextureRenderTarget2D* Render(bool InIsHeightmap, UTextureRenderTarget2D* InCombinedResult, const FName& InWeightmapLayerName);
    UTextureRenderTarget2D* RenderLayer(const FLandscapeBrushParameters& InParameters);
    void RequestLandscapeUpdate(bool bInUserTriggered);
};

// Size: 0x80
struct FLandscapeBrushParameters {
    /* 0x0000 */ FTransform RenderAreaWorldTransform;
    /* 0x0060 */ FIntPoint RenderAreaSize;
    /* 0x0068 */ UTextureRenderTarget2D* CombinedResult;
    /* 0x0070 */ ELandscapeToolTargetType LayerType;
    /* 0x0074 */ FName WeightmapLayerName;
};

// Size: 0x28
class ILandscapeBrushRenderCallAdapter_GlobalMergeLegacySupport : public UInterface {
};

// Size: 0x730
class ULandscapeComponent : public UPrimitiveComponent {
    /* 0x0520 */ int32_t SectionBaseX;
    /* 0x0524 */ int32_t SectionBaseY;
    /* 0x0528 */ int32_t ComponentSizeQuads;
    /* 0x052c */ int32_t SubsectionSizeQuads;
    /* 0x0530 */ int32_t NumSubsections;
    /* 0x0538 */ UMaterialInterface* OverrideMaterial;
    /* 0x0540 */ UMaterialInterface* OverrideHoleMaterial;
    /* 0x0548 */ TArray<UMaterialInstanceConstant*> MaterialInstances;
    /* 0x0558 */ TArray<UMaterialInstanceDynamic*> MaterialInstancesDynamic;
    /* 0x0568 */ TArray<int8_t> LODIndexToMaterialIndex;
    /* 0x0578 */ UTexture2D* XYOffsetmapTexture;
    /* 0x0580 */ FVector4 WeightmapScaleBias;
    /* 0x05a0 */ float WeightmapSubsectionOffset;
    /* 0x05b0 */ FVector4 HeightmapScaleBias;
    /* 0x05d0 */ FBox CachedLocalBox;
    /* 0x0608 */ TArray<double> MipToMipMaxDeltas;
    /* 0x0618 */ ULandscapeHeightfieldCollisionComponent* CollisionComponentRef;
    /* 0x0620 */ bool bUserTriggeredChangeRequested;
    /* 0x0621 */ bool bNaniteActive;
    /* 0x0628 */ UTexture2D* HeightmapTexture;
    /* 0x0630 */ TArray<FWeightmapLayerAllocationInfo> WeightmapLayerAllocations;
    /* 0x0640 */ TArray<UTexture2D*> WeightmapTextures;
    /* 0x0650 */ TArray<FLandscapePerLODMaterialOverride> PerLODOverrideMaterials;
    /* 0x0660 */ TArray<ULandscapeGrassType*> GrassTypes;
    /* 0x0680 */ FGuid MapBuildDataId;
    /* 0x0690 */ int32_t CollisionMipLevel;
    /* 0x0694 */ int32_t SimpleCollisionMipLevel;
    /* 0x0698 */ float NegativeZBoundsExtension;
    /* 0x069c */ float PositiveZBoundsExtension;
    /* 0x06a0 */ float StaticLightingResolution;
    /* 0x06a4 */ int32_t ForcedLOD;
    /* 0x06a8 */ int32_t LODBias;
    /* 0x06ac */ FGuid StateId;
    /* 0x06c0 */ ULandscapeHeightmapTextureEdgeFixup* RegisteredEdgeFixup;
    /* 0x06d0 */ TArray<UMaterialInterface*> MobileMaterialInterfaces;
    /* 0x06e0 */ TArray<UTexture2D*> MobileWeightmapTextures;
    /* 0x06f0 */ UTexture2DArray* MobileWeightmapTextureArray;
    /* 0x06f8 */ TArray<FWeightmapLayerAllocationInfo> MobileWeightmapLayerAllocations;

    float EditorGetPaintLayerWeightAtLocation(const FVector& InLocation, ULandscapeLayerInfoObject* PaintLayer);
    float EditorGetPaintLayerWeightByNameAtLocation(const FVector& InLocation, const FName InPaintLayerName);
    UMaterialInstanceDynamic* GetMaterialInstanceDynamic(int32_t InIndex) const;
    void SetForcedLOD(int32_t InForcedLOD);
    void SetLODBias(int32_t InLODBias);
};

// Size: 0x10
struct FLandscapeComponentMaterialOverride {
    /* 0x0000 */ FPerPlatformInt LODIndex;
    /* 0x0008 */ UMaterialInterface* Material;
};

// Size: 0x28
class ULandscapeDefaultEditLayerRenderer : public UObject {
};

// Size: 0x30
class ULandscapeEditLayer : public ULandscapeEditLayerPersistent {
};

// Size: 0x28
class ULandscapeEditLayerBase : public UObject {
};

// Size: 0x8
struct FLandscapeEditLayerMergeRenderBlackboardItem {
};

// Size: 0x30
class ULandscapeEditLayerPersistent : public ULandscapeEditLayerBase {
};

// Size: 0x28
class ULandscapeEditLayerProcedural : public ULandscapeEditLayerBase {
};

// Size: 0x28
class ILandscapeEditLayerRenderer : public UInterface {
};

// Size: 0x30
class ULandscapeEditLayerSplines : public ULandscapeEditLayerPersistent {
};

// Size: 0x40
class ULandscapeEditResourcesSubsystem : public UEngineSubsystem {
    /* 0x0030 */ TArray<ULandscapeScratchRenderTarget*> ScratchRenderTargets;
};

// Size: 0x38
struct FLandscapeEditToolRenderData {
    /* 0x0000 */ UMaterialInterface* ToolMaterial;
    /* 0x0008 */ UMaterialInterface* GizmoMaterial;
    /* 0x0010 */ int32_t SelectedType;
    /* 0x0014 */ int32_t DebugChannelR;
    /* 0x0018 */ int32_t DebugChannelG;
    /* 0x001c */ int32_t DebugChannelB;
    /* 0x0020 */ UTexture2D* DataTexture;
    /* 0x0028 */ UTexture2D* LayerContributionTexture;
    /* 0x0030 */ UTexture2D* DirtyTexture;
};

// Size: 0x1
struct FLandscapeEditorLayerSettings {
};

// Size: 0x2f8
class ALandscapeGizmoActiveActor : public ALandscapeGizmoActor {
};

// Size: 0x2a8
class ALandscapeGizmoActor : public AActor {
};

// Size: 0x520
class ULandscapeGizmoRenderComponent : public UPrimitiveComponent {
};

// Size: 0x60
class ULandscapeGrassType : public UObject {
    /* 0x0028 */ TArray<FGrassVariety> GrassVarieties;
    /* 0x0038 */ bool bEnableDensityScaling;
    /* 0x003c */ uint32_t StateHash;
    /* 0x0040 */ UStaticMesh* GrassMesh;
    /* 0x0048 */ float GrassDensity;
    /* 0x004c */ float PlacementJitter;
    /* 0x0050 */ int32_t StartCullDistance;
    /* 0x0054 */ int32_t EndCullDistance;
    /* 0x0058 */ bool RandomRotation;
    /* 0x0059 */ bool AlignToSurface;
};

// Size: 0x28
class ULandscapeHLODBuilder : public UHLODBuilder {
};

// Size: 0x620
class ULandscapeHeightfieldCollisionComponent : public UPrimitiveComponent {
    /* 0x0520 */ TArray<ULandscapeLayerInfoObject*> ComponentLayerInfos;
    /* 0x0530 */ int32_t SectionBaseX;
    /* 0x0534 */ int32_t SectionBaseY;
    /* 0x0538 */ int32_t CollisionSizeQuads;
    /* 0x053c */ float CollisionScale;
    /* 0x0540 */ int32_t SimpleCollisionSizeQuads;
    /* 0x0548 */ TArray<uint8_t> CollisionQuadFlags;
    /* 0x0558 */ FGuid HeightfieldGuid;
    /* 0x0568 */ FBox CachedLocalBox;
    /* 0x05a0 */ ULandscapeComponent* RenderComponentRef;
    /* 0x05b8 */ TArray<UPhysicalMaterial*> CookedPhysicalMaterials;

    ULandscapeComponent* GetRenderComponent() const;
};

// Size: 0x28
class ULandscapeHeightmapNormalsEditLayerRenderer : public UObject {
};

// Size: 0x90
class ULandscapeHeightmapTextureEdgeFixup : public UAssetUserData {
};

// Size: 0x1
struct FLandscapeImportLayerInfo {
};

// Size: 0x200
class ULandscapeInfo : public UObject {
    /* 0x0028 */ TWeakObjectPtr<ALandscape> LandscapeActor;
    /* 0x0030 */ FGuid LandscapeGuid;
    /* 0x0040 */ int32_t ComponentSizeQuads;
    /* 0x0044 */ int32_t SubsectionSizeQuads;
    /* 0x0048 */ int32_t ComponentNumSubsections;
    /* 0x00f0 */ TArray<TWeakObjectPtr<ALandscapeStreamingProxy>> StreamingProxies;
};

// Size: 0x10
struct FLandscapeInfoLayerSettings {
    /* 0x0000 */ ULandscapeLayerInfoObject* LayerInfoObj;
    /* 0x0008 */ FName LayerName;
};

// Size: 0x80
class ULandscapeInfoMap : public UObject {
};

// Size: 0xd0
class ULandscapeLODStreamingProxy_DEPRECATED : public UStreamableRenderAsset {
};

// Size: 0x98
struct FLandscapeLayer {
    /* 0x0008 */ FGuid Guid;
    /* 0x0018 */ FName Name;
    /* 0x0020 */ bool bVisible;
    /* 0x0021 */ bool bLocked;
    /* 0x0024 */ float HeightmapAlpha;
    /* 0x0028 */ float WeightmapAlpha;
    /* 0x002c */ uint8_t BlendMode;
    /* 0x0030 */ TArray<FLandscapeLayerBrush> Brushes;
    /* 0x0040 */ TMap<ULandscapeLayerInfoObject*, bool> WeightmapLayerAllocationBlend;
    /* 0x0090 */ ULandscapeEditLayerBase* EditLayer;
};

// Size: 0x8
struct FLandscapeLayerBrush {
};

// Size: 0x38
struct FLandscapeLayerComponentData {
    /* 0x0000 */ FHeightmapData HeightmapData;
    /* 0x0008 */ FWeightmapData WeightmapData;
};

// Size: 0x50
class ULandscapeLayerInfoObject : public UObject {
    /* 0x0028 */ FName LayerName;
    /* 0x0030 */ UPhysicalMaterial* PhysMaterial;
    /* 0x0038 */ float Hardness;
    /* 0x003c */ FLinearColor LayerUsageDebugColor;
};

// Size: 0x310
class ULandscapeMaterialInstanceConstant : public UMaterialInstanceConstant {
    /* 0x02f8 */ TArray<FLandscapeMaterialTextureStreamingInfo> TextureStreamingInfo;
    /* 0x0308 */ bool bIsLayerThumbnail;
    /* 0x0308 */ bool bDisableTessellation;
    /* 0x0308 */ bool bMobile;
    /* 0x0308 */ bool bEditorToolUsage;
};

// Size: 0xc
struct FLandscapeMaterialTextureStreamingInfo {
    /* 0x0000 */ FName TextureName;
    /* 0x0008 */ float TexelFactor;
};

// Size: 0x630
class ULandscapeMeshCollisionComponent : public ULandscapeHeightfieldCollisionComponent {
    /* 0x0618 */ FGuid MeshGuid;
};

// Size: 0x2b0
class ALandscapeMeshProxyActor : public AActor {
    /* 0x02a8 */ ULandscapeMeshProxyComponent* LandscapeMeshProxyComponent;
};

// Size: 0x680
class ULandscapeMeshProxyComponent : public UStaticMeshComponent {
    /* 0x0610 */ FGuid LandscapeGuid;
    /* 0x0620 */ TArray<FIntPoint> ProxyComponentBases;
    /* 0x0630 */ TArray<FVector> ProxyComponentCentersObjectSpace;
    /* 0x0640 */ FVector ComponentXVectorObjectSpace;
    /* 0x0658 */ FVector ComponentYVectorObjectSpace;
    /* 0x0670 */ int32_t ComponentResolution;
    /* 0x0674 */ int8_t ProxyLOD;
    /* 0x0678 */ uint32_t LODGroupKey;
};

// Size: 0x640
class ULandscapeNaniteComponent : public UStaticMeshComponent {
    /* 0x0610 */ FGuid ProxyContentId;
    /* 0x0620 */ bool bEnabled;
    /* 0x0628 */ TArray<ULandscapeComponent*> SourceLandscapeComponents;
};

// Size: 0x10
struct FLandscapePerLODMaterialOverride {
    /* 0x0000 */ int32_t LODIndex;
    /* 0x0008 */ UMaterialInterface* Material;
};

// Size: 0x7c0
class ALandscapeProxy : public APartitionActor {
    /* 0x02b0 */ ULandscapeSplinesComponent* SplineComponent;
    /* 0x02b8 */ FGuid LandscapeGuid;
    /* 0x02c8 */ FGuid OriginalLandscapeGuid;
    /* 0x02d8 */ bool bEnableNanite;
    /* 0x02e0 */ TArray<FLandscapePerLODMaterialOverride> PerLODOverrideMaterials;
    /* 0x02f0 */ bool bDisableRuntimeGrassMapGeneration;
    /* 0x02f4 */ FIntPoint LandscapeSectionOffset;
    /* 0x02fc */ int32_t MaxLODLevel;
    /* 0x0300 */ float LOD0ScreenSize;
    /* 0x0304 */ uint32_t LODGroupKey;
    /* 0x0308 */ float LOD0DistributionSetting;
    /* 0x030c */ float LODDistributionSetting;
    /* 0x0310 */ FPerQualityLevelFloat ScalableLOD0ScreenSize;
    /* 0x0378 */ FPerQualityLevelFloat ScalableLOD0DistributionSetting;
    /* 0x03e0 */ FPerQualityLevelFloat ScalableLODDistributionSetting;
    /* 0x0448 */ bool bUseScalableLODSettings;
    /* 0x044c */ float LODBlendRange;
    /* 0x0450 */ int32_t StaticLightingLOD;
    /* 0x0458 */ UPhysicalMaterial* DefaultPhysMaterial;
    /* 0x0460 */ float StreamingDistanceMultiplier;
    /* 0x0468 */ UMaterialInterface* LandscapeMaterial;
    /* 0x0470 */ UMaterialInterface* LandscapeHoleMaterial;
    /* 0x0478 */ TArray<URuntimeVirtualTexture*> RuntimeVirtualTextures;
    /* 0x0488 */ bool bSetCreateRuntimeVirtualTextureVolumes;
    /* 0x0489 */ bool bVirtualTextureRenderWithQuad;
    /* 0x048a */ bool bVirtualTextureRenderWithQuadHQ;
    /* 0x048c */ int32_t VirtualTextureNumLods;
    /* 0x0490 */ int32_t VirtualTextureLodBias;
    /* 0x0494 */ ERuntimeVirtualTextureMainPassType VirtualTextureRenderPassType;
    /* 0x0498 */ float NegativeZBoundsExtension;
    /* 0x049c */ float PositiveZBoundsExtension;
    /* 0x04a0 */ TArray<ULandscapeComponent*> LandscapeComponents;
    /* 0x04b0 */ TArray<ULandscapeHeightfieldCollisionComponent*> CollisionComponents;
    /* 0x04c0 */ TArray<UHierarchicalInstancedStaticMeshComponent*> FoliageComponents;
    /* 0x04d0 */ ULandscapeNaniteComponent* NaniteComponent;
    /* 0x04d8 */ TArray<ULandscapeNaniteComponent*> NaniteComponents;
    /* 0x054c */ float GrassTypesMaxDiscardDistance;
    /* 0x0560 */ float StaticLightingResolution;
    /* 0x0564 */ bool CastShadow;
    /* 0x0564 */ bool bCastDynamicShadow;
    /* 0x0564 */ bool bCastStaticShadow;
    /* 0x0565 */ EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehavior;
    /* 0x0566 */ bool bCastContactShadow;
    /* 0x0568 */ bool bCastFarShadow;
    /* 0x056c */ bool bCastHiddenShadow;
    /* 0x0570 */ bool bCastShadowAsTwoSided;
    /* 0x0574 */ bool bAffectDistanceFieldLighting;
    /* 0x0574 */ bool bAffectDynamicIndirectLighting;
    /* 0x0574 */ bool bAffectIndirectLightingWhileHidden;
    /* 0x0575 */ FLightingChannels LightingChannels;
    /* 0x0578 */ bool bUseMaterialPositionOffsetInStaticLighting;
    /* 0x057c */ float NonNaniteVirtualShadowMapConstantDepthBias;
    /* 0x0580 */ float NonNaniteVirtualShadowMapInvalidationHeightErrorThreshold;
    /* 0x0584 */ float NonNaniteVirtualShadowMapInvalidationScreenSizeLimit;
    /* 0x0588 */ bool bHoldout;
    /* 0x058c */ bool bRenderCustomDepth;
    /* 0x0590 */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x0594 */ int32_t CustomDepthStencilValue;
    /* 0x0598 */ float LDMaxDrawDistance;
    /* 0x059c */ FLightmassPrimitiveSettings LightmassSettings;
    /* 0x05b4 */ int32_t CollisionMipLevel;
    /* 0x05b8 */ int32_t SimpleCollisionMipLevel;
    /* 0x05c0 */ FBodyInstance BodyInstance;
    /* 0x0740 */ bool bGenerateOverlapEvents;
    /* 0x0740 */ bool bBakeMaterialPositionOffsetIntoCollision;
    /* 0x0748 */ ULandscapeSubsystem* RegisteredToSubsystem;
    /* 0x0750 */ int32_t ComponentSizeQuads;
    /* 0x0754 */ int32_t SubsectionSizeQuads;
    /* 0x0758 */ int32_t NumSubsections;
    /* 0x075c */ bool bUsedForNavigation;
    /* 0x075c */ bool bFillCollisionUnderLandscapeForNavmesh;
    /* 0x0760 */ ENavDataGatheringMode NavigationGeometryGatheringMode;
    /* 0x0761 */ bool bUseDynamicMaterialInstance;
    /* 0x0762 */ bool bUseLandscapeForCullingInvisibleHLODVertices;
    /* 0x0763 */ bool bHasLayersContent;
    /* 0x0766 */ bool bUseCompressedHeightmapStorage;
    /* 0x0767 */ bool bStripPhysicsWhenCookedClient;
    /* 0x0768 */ bool bStripPhysicsWhenCookedServer;
    /* 0x0769 */ bool bStripGrassWhenCookedClient;
    /* 0x076a */ bool bStripGrassWhenCookedServer;
    /* 0x0770 */ TMap<FName, FLandscapeTargetLayerSettings> TargetLayers;

    void ChangeComponentScreenSizeToUseSubSections(float InComponentScreenSizeToUseSubSections);
    void ChangeLODDistanceFactor(float InLODDistanceFactor);
    void EditorApplySpline(USplineComponent* InSplineComponent, float StartWidth, float EndWidth, float StartSideFalloff, float EndSideFalloff, float StartRoll, float EndRoll, int32_t NumSubdivisions, bool bRaiseHeights, bool bLowerHeights, ULandscapeLayerInfoObject* PaintLayer, FName EditLayerName);
    void EditorSetLandscapeMaterial(UMaterialInterface* NewLandscapeMaterial);
    ALandscape* GetLandscapeActor();
    bool LandscapeExportHeightmapToRenderTarget(UTextureRenderTarget2D* InRenderTarget, bool InExportHeightIntoRGChannel, bool InExportLandscapeProxies);
    void SetLandscapeMaterialScalarParameterValue(FName ParameterName, float Value);
    void SetLandscapeMaterialTextureParameterValue(FName ParameterName, UTexture* Value);
    void SetLandscapeMaterialVectorParameterValue(FName ParameterName, FLinearColor Value);
    void SetVirtualTextureRenderPassType(ERuntimeVirtualTextureMainPassType InType);
};

// Size: 0x10
struct FLandscapeProxyMaterialOverride {
    /* 0x0000 */ FPerPlatformInt LODIndex;
    /* 0x0008 */ UMaterialInterface* Material;
};

// Size: 0x78
class ULandscapeScratchRenderTarget : public UObject {
    /* 0x0028 */ UTextureRenderTarget* RenderTarget;
};

// Size: 0xc8
class ULandscapeSettings : public UDeveloperSettings {
    /* 0x0038 */ int32_t MaxNumberOfLayers;
    /* 0x003c */ bool bShowDialogForAutomaticLayerCreation;
    /* 0x0040 */ int32_t MaxComponents;
    /* 0x0044 */ uint32_t MaxImageImportCacheSizeMegaBytes;
    /* 0x0048 */ float PaintStrengthGamma;
    /* 0x004c */ bool bDisablePaintingStartupSlowdown;
    /* 0x004d */ ELandscapeDirtyingMode LandscapeDirtyingMode;
    /* 0x0050 */ int32_t SideResolutionLimit;
    /* 0x0058 */ TSoftObjectPtr<UMaterialInterface> DefaultLandscapeMaterial;
    /* 0x0080 */ TSoftObjectPtr<ULandscapeLayerInfoObject> DefaultLayerInfoObject;
    /* 0x00a8 */ float BrushSizeUIMax;
    /* 0x00ac */ float BrushSizeClampMax;
    /* 0x00b0 */ int32_t HLODMaxTextureSize;
    /* 0x00b4 */ bool bShouldUpdateEditLayersDuringInteractiveChanges;
    /* 0x00b5 */ bool bRestrictiveMode;
    /* 0x00b8 */ float SplineIconWorldZOffset;
    /* 0x00bc */ float SplineIconScale;
    /* 0x00c0 */ bool bDisplayTargetLayerThumbnails;
    /* 0x00c1 */ bool bDisableTemporalAntiAliasingInLandscapeMode;
};

// Size: 0x2c0
class ALandscapeSplineActor : public AActor {
    /* 0x02b0 */ FGuid LandscapeGuid;
};

// Size: 0x10
struct FLandscapeSplineConnection {
    /* 0x0000 */ ULandscapeSplineSegment* Segment;
    /* 0x0008 */ bool End;
};

// Size: 0xd8
class ULandscapeSplineControlPoint : public UObject {
    /* 0x0028 */ FVector Location;
    /* 0x0040 */ FRotator Rotation;
    /* 0x0058 */ float Width;
    /* 0x005c */ float LayerWidthRatio;
    /* 0x0060 */ float SideFalloff;
    /* 0x0064 */ float LeftSideFalloffFactor;
    /* 0x0068 */ float RightSideFalloffFactor;
    /* 0x006c */ float LeftSideLayerFalloffFactor;
    /* 0x0070 */ float RightSideLayerFalloffFactor;
    /* 0x0074 */ float EndFalloff;
    /* 0x0078 */ TArray<FLandscapeSplineConnection> ConnectedSegments;
    /* 0x0088 */ TArray<FLandscapeSplineInterpPoint> points;
    /* 0x0098 */ FBox Bounds;
    /* 0x00d0 */ UControlPointMeshComponent* LocalMeshComponent;
};

// Size: 0x28
class ILandscapeSplineInterface : public UInterface {
};

// Size: 0xe0
struct FLandscapeSplineInterpPoint {
    /* 0x0000 */ FVector Center;
    /* 0x0018 */ FVector Left;
    /* 0x0030 */ FVector Right;
    /* 0x0048 */ FVector FalloffLeft;
    /* 0x0060 */ FVector FalloffRight;
    /* 0x0078 */ FVector LayerLeft;
    /* 0x0090 */ FVector LayerRight;
    /* 0x00a8 */ FVector LayerFalloffLeft;
    /* 0x00c0 */ FVector LayerFalloffRight;
    /* 0x00d8 */ float StartEndFalloff;
};

// Size: 0x58
struct FLandscapeSplineMeshEntry {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ TArray<UMaterialInterface*> MaterialOverrides;
    /* 0x0018 */ bool bCenterH;
    /* 0x0020 */ FVector2D CenterAdjust;
    /* 0x0030 */ bool bScaleToWidth;
    /* 0x0030 */ bool bNoZScaling;
    /* 0x0038 */ FVector Scale;
    /* 0x0050 */ uint8_t Orientation;
    /* 0x0051 */ uint8_t ForwardAxis;
    /* 0x0052 */ uint8_t UpAxis;
};

enum class LandscapeSplineMeshOrientation {
    LSMO_XUp = 0,
    LSMO_YUp = 1,
    LSMO_MAX = 2,
};

// Size: 0x2b8
class ALandscapeSplineMeshesActor : public APartitionActor {
    /* 0x02a8 */ TArray<UStaticMeshComponent*> StaticMeshComponents;
};

// Size: 0xc8
class ULandscapeSplineSegment : public UObject {
    /* 0x0028 */ FLandscapeSplineSegmentConnection Connections[2];
    /* 0x0058 */ FInterpCurveVector SplineInfo;
    /* 0x0070 */ TArray<FLandscapeSplineInterpPoint> points;
    /* 0x0080 */ FBox Bounds;
    /* 0x00b8 */ TArray<USplineMeshComponent*> LocalMeshComponents;
};

// Size: 0x18
struct FLandscapeSplineSegmentConnection {
    /* 0x0000 */ ULandscapeSplineControlPoint* ControlPoint;
    /* 0x0008 */ float TangentLen;
    /* 0x000c */ FName SocketName;
};

// Size: 0x550
class ULandscapeSplinesComponent : public UPrimitiveComponent {
    /* 0x0520 */ TArray<ULandscapeSplineControlPoint*> ControlPoints;
    /* 0x0530 */ TArray<ULandscapeSplineSegment*> Segments;
    /* 0x0540 */ TArray<UMeshComponent*> CookedForeignMeshComponents;

    TArray<USplineMeshComponent*> GetSplineMeshComponents();
};

// Size: 0x838
class ALandscapeStreamingProxy : public ALandscapeProxy {
    /* 0x07c0 */ TSoftObjectPtr<ALandscape> LandscapeActorRef;
    /* 0x07e8 */ TSet<FName> OverriddenSharedProperties;
};

// Size: 0x128
class ULandscapeSubsystem : public UTickableWorldSubsystem {
    /* 0x0090 */ TSet<ALandscapeStreamingProxy*> StreamingProxiesNeedingReregister;
    /* 0x00e8 */ TArray<ALandscape*> LandscapeActors;
    /* 0x00f8 */ TArray<ALandscapeProxy*> Proxies;
};

// Size: 0x8
struct FLandscapeTargetLayerSettings {
    /* 0x0000 */ ULandscapeLayerInfoObject* LayerInfoObj;
};

// Size: 0x38
struct FLandscapeTexture2DMipMap {
    /* 0x0000 */ int32_t SizeX;
    /* 0x0004 */ int32_t SizeY;
    /* 0x0008 */ bool bCompressed;
};

// Size: 0xa0
class ULandscapeTextureHash : public UAssetUserData {
    /* 0x0028 */ FGuid TextureHashGUID;
    /* 0x0038 */ FGuid LastSourceID;
    /* 0x0048 */ ELandscapeTextureType TextureType;
    /* 0x0049 */ ELandscapeTextureUsage TextureUsage;
};

// Size: 0x38
class ULandscapeTextureMipEdgeOverrideFactory : public UTextureMipDataProviderFactory {
};

// Size: 0x68
class ULandscapeTextureStorageProviderFactory : public UTextureAllMipDataProviderFactory {
};

// Size: 0x58
class ULandscapeWeightmapUsage : public UObject {
    /* 0x0028 */ ULandscapeComponent* ChannelUsage[4];
    /* 0x0048 */ FGuid LayerGuid;
};

// Size: 0x28
class ULandscapeWeightmapWeightBlendedLayersRenderer : public UObject {
};

// Size: 0x88
struct FLayerBlendInput {
    /* 0x0000 */ FName LayerName;
    /* 0x0008 */ uint8_t BlendType;
    /* 0x0010 */ FExpressionInput LayerInput;
    /* 0x0038 */ FExpressionInput HeightInput;
    /* 0x0060 */ float PreviewWeight;
    /* 0x0068 */ FVector ConstLayerInput;
    /* 0x0080 */ float ConstHeightInput;
};

// Size: 0xc0
class UMaterialExpressionLandscapeGrassOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ TArray<FGrassInput> GrassTypes;
};

// Size: 0xc0
class UMaterialExpressionLandscapeLayerBlend : public UMaterialExpression {
    /* 0x00b0 */ TArray<FLayerBlendInput> Layers;
};

// Size: 0xc8
class UMaterialExpressionLandscapeLayerCoords : public UMaterialExpression {
    /* 0x00b0 */ uint8_t MappingType;
    /* 0x00b1 */ uint8_t CustomUVType;
    /* 0x00b4 */ float MappingScale;
    /* 0x00b8 */ float MappingRotation;
    /* 0x00bc */ float MappingPanU;
    /* 0x00c0 */ float MappingPanV;
};

// Size: 0xc0
class UMaterialExpressionLandscapeLayerSample : public UMaterialExpression {
    /* 0x00b0 */ FName ParameterName;
    /* 0x00b8 */ float PreviewWeight;
};

// Size: 0x110
class UMaterialExpressionLandscapeLayerSwitch : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput LayerUsed;
    /* 0x00d8 */ FExpressionInput LayerNotUsed;
    /* 0x0100 */ FName ParameterName;
    /* 0x0108 */ bool PreviewUsed;
};

// Size: 0x128
class UMaterialExpressionLandscapeLayerWeight : public UMaterialExpression {
    /* 0x00b0 */ FExpressionInput base;
    /* 0x00d8 */ FExpressionInput Layer;
    /* 0x0100 */ FName ParameterName;
    /* 0x0108 */ float PreviewWeight;
    /* 0x0110 */ FVector ConstBase;
};

// Size: 0xc0
class UMaterialExpressionLandscapePhysicalMaterialOutput : public UMaterialExpressionCustomOutput {
    /* 0x00b0 */ TArray<FPhysicalMaterialInput> Inputs;
};

// Size: 0xb0
class UMaterialExpressionLandscapeVisibilityMask : public UMaterialExpression {
};

// Size: 0x30
struct FPhysicalMaterialInput {
    /* 0x0000 */ UPhysicalMaterial* PhysicalMaterial;
    /* 0x0008 */ FExpressionInput Input;
};

// Size: 0x30
struct FWeightmapData {
    /* 0x0000 */ TArray<UTexture2D*> Textures;
    /* 0x0010 */ TArray<FWeightmapLayerAllocationInfo> LayerAllocations;
    /* 0x0020 */ TArray<ULandscapeWeightmapUsage*> TextureUsages;
};

// Size: 0x10
struct FWeightmapLayerAllocationInfo {
    /* 0x0000 */ ULandscapeLayerInfoObject* LayerInfo;
    /* 0x0008 */ uint8_t WeightmapTextureIndex;
    /* 0x0009 */ uint8_t WeightmapTextureChannel;
};

// Size: 0x58
class UAnimSequenceLevelSequenceLink : public UAssetUserData {
    /* 0x0028 */ FGuid SkelTrackGuid;
    /* 0x0038 */ FSoftObjectPath PathToLevelSequence;
};

// Size: 0x1
struct FBoundActorProxy {
};

// Size: 0xa0
class UDefaultLevelSequenceInstanceData : public UObject {
    /* 0x0030 */ AActor* TransformOriginActor;
    /* 0x0040 */ FTransform TransformOrigin;
};

// Size: 0x10
struct FLegacyLazyObjectPtrFragment {
    /* 0x0000 */ FGuid LazyObjectId;
};

// Size: 0xa8
class ULegacyLevelSequenceDirectorBlueprint : public UBlueprint {
};

// Size: 0xa0
class ULevelSequence : public UMovieSceneSequence {
    /* 0x0070 */ UMovieScene* MovieScene;
    /* 0x0078 */ FUpgradedLevelSequenceBindingReferences BindingReferences;
    /* 0x0088 */ UClass* DirectorClass;
    /* 0x0090 */ TArray<UAssetUserData*> AssetUserData;

    UObject* CopyMetaData(UObject* InMetaData);
    UObject* FindMetaDataByClass(UClass* InClass) const;
    UObject* FindOrAddMetaDataByClass(UClass* InClass);
    void RemoveMetaDataByClass(UClass* InClass);
};

// Size: 0x350
class ALevelSequenceActor : public AActor {
    /* 0x02c0 */ FMovieSceneSequencePlaybackSettings PlaybackSettings;
    /* 0x02e8 */ ULevelSequencePlayer* SequencePlayer;
    /* 0x02f0 */ ULevelSequence* LevelSequenceAsset;
    /* 0x02f8 */ FLevelSequenceCameraSettings CameraSettings;
    /* 0x0300 */ ULevelSequenceBurnInOptions* BurnInOptions;
    /* 0x0308 */ UMovieSceneBindingOverrides* BindingOverrides;
    /* 0x0310 */ bool bAutoPlay;
    /* 0x0310 */ bool bOverrideInstanceData;
    /* 0x0310 */ bool bReplicatePlayback;
    /* 0x0318 */ UObject* DefaultInstanceData;
    /* 0x0320 */ ULevelSequenceBurnIn* BurnInInstance;
    /* 0x0328 */ bool bShowBurnin;
    /* 0x032c */ FWorldPartitionResolveData WorldPartitionResolveData;

    void AddBinding(FMovieSceneObjectBindingID Binding, AActor* Actor, bool bAllowBindingsFromAsset);
    void AddBindingByTag(FName BindingTag, AActor* Actor, bool bAllowBindingsFromAsset);
    FMovieSceneObjectBindingID FindNamedBinding(FName Tag) const;
    TArray<FMovieSceneObjectBindingID> FindNamedBindings(FName Tag) const;
    ULevelSequence* GetSequence() const;
    ULevelSequencePlayer* GetSequencePlayer() const;
    void HideBurnin();
    void OnLevelSequenceLoaded__DelegateSignature();
    void RemoveBinding(FMovieSceneObjectBindingID Binding, AActor* Actor);
    void RemoveBindingByTag(FName Tag, AActor* Actor);
    void ResetBinding(FMovieSceneObjectBindingID Binding);
    void ResetBindings();
    void SetBinding(FMovieSceneObjectBindingID Binding, const TArray<AActor*>& Actors, bool bAllowBindingsFromAsset);
    void SetBindingByTag(FName BindingTag, const TArray<AActor*>& Actors, bool bAllowBindingsFromAsset);
    void SetReplicatePlayback(bool ReplicatePlayback);
    void SetSequence(ULevelSequence* InSequence);
    void ShowBurnin();
};

// Size: 0x38
class ULevelSequenceAnimSequenceLink : public UAssetUserData {
    /* 0x0028 */ TArray<FLevelSequenceAnimSequenceLinkItem> AnimSequenceLinks;
};

// Size: 0x80
struct FLevelSequenceAnimSequenceLinkItem {
    /* 0x0000 */ FGuid SkelTrackGuid;
    /* 0x0010 */ FSoftObjectPath PathToAnimSequence;
    /* 0x0030 */ bool bExportTransforms;
    /* 0x0031 */ bool bExportMorphTargets;
    /* 0x0032 */ bool bExportAttributeCurves;
    /* 0x0033 */ bool bExportMaterialCurves;
    /* 0x0034 */ EAnimInterpolationType Interpolation;
    /* 0x0035 */ uint8_t CurveInterpolation;
    /* 0x0036 */ bool bRecordInWorldSpace;
    /* 0x0037 */ bool bEvaluateAllSkeletalMeshComponents;
    /* 0x0038 */ TArray<FString> IncludeAnimationNames;
    /* 0x0048 */ TArray<FString> ExcludeAnimationNames;
    /* 0x0058 */ FFrameNumber WarmUpFrames;
    /* 0x005c */ FFrameNumber DelayBeforeStart;
    /* 0x0060 */ bool bUseCustomTimeRange;
    /* 0x0064 */ FFrameNumber CustomStartFrame;
    /* 0x0068 */ FFrameNumber CustomEndFrame;
    /* 0x006c */ FFrameRate CustomDisplayRate;
    /* 0x0074 */ bool bUseCustomFrameRate;
    /* 0x0078 */ FFrameRate CustomFrameRate;
};

// Size: 0x40
struct FLevelSequenceBindingReference {
    /* 0x0000 */ FString PackageName;
    /* 0x0010 */ FSoftObjectPath ExternalObjectPath;
    /* 0x0030 */ FString ObjectPath;
};

// Size: 0x10
struct FLevelSequenceBindingReferenceArray {
    /* 0x0000 */ TArray<FLevelSequenceBindingReference> References;
};

// Size: 0xf0
struct FLevelSequenceBindingReferences {
    /* 0x0000 */ TMap<FGuid, FLevelSequenceBindingReferenceArray> BindingIdToReferences;
    /* 0x0050 */ TSet<FGuid> AnimSequenceInstances;
    /* 0x00a0 */ TSet<FGuid> PostProcessInstances;
};

// Size: 0x3f0
class ULevelSequenceBurnIn : public UUserWidget {
    /* 0x0340 */ FLevelSequencePlayerSnapshot FrameInformation;
    /* 0x03e8 */ ALevelSequenceActor* LevelSequenceActor;

    UClass* GetSettingsClass() const;
    void SetSettings(UObject* InSettings);
};

// Size: 0x28
class ULevelSequenceBurnInInitSettings : public UObject {
};

// Size: 0x58
class ULevelSequenceBurnInOptions : public UObject {
    /* 0x0028 */ bool bUseBurnIn;
    /* 0x0030 */ FSoftClassPath BurnInClass;
    /* 0x0050 */ ULevelSequenceBurnInInitSettings* Settings;

    void SetBurnIn(FSoftClassPath InBurnInClass);
};

// Size: 0x2
struct FLevelSequenceCameraSettings {
    /* 0x0000 */ bool bOverrideAspectRatioAxisConstraint;
    /* 0x0001 */ uint8_t AspectRatioAxisConstraint;
};

// Size: 0x48
class ULevelSequenceDirector : public UObject {
    /* 0x0028 */ int32_t SubSequenceID;
    /* 0x002c */ TWeakObjectPtr<UMovieSceneEntitySystemLinker> WeakLinker;
    /* 0x0034 */ uint16_t InstanceId;
    /* 0x0036 */ uint16_t InstanceSerial;
    /* 0x0038 */ ULevelSequencePlayer* Player;
    /* 0x0040 */ int32_t MovieScenePlayerIndex;

    AActor* GetBoundActor(FMovieSceneObjectBindingID ObjectBinding);
    TArray<AActor*> GetBoundActors(FMovieSceneObjectBindingID ObjectBinding);
    UObject* GetBoundObject(FMovieSceneObjectBindingID ObjectBinding);
    TArray<UObject*> GetBoundObjects(FMovieSceneObjectBindingID ObjectBinding);
    FQualifiedFrameTime GetCurrentTime() const;
    FQualifiedFrameTime GetRootSequenceTime() const;
    UMovieSceneSequence* GetSequence();
    void OnCreated();
};

// Size: 0x20
struct FLevelSequenceLegacyObjectReference {
};

// Size: 0x2d0
class ALevelSequenceMediaController : public AActor {
    /* 0x02b0 */ ALevelSequenceActor* Sequence;
    /* 0x02b8 */ UMediaComponent* MediaComponent;
    /* 0x02c0 */ float ServerStartTimeSeconds;

    UMediaComponent* GetMediaComponent() const;
    ALevelSequenceActor* GetSequence() const;
    void OnRep_ServerStartTimeSeconds();
    void Play();
    void SynchronizeToServer(float DesyncThresholdSeconds);
};

// Size: 0x30
struct FLevelSequenceObject {
    /* 0x0000 */ TLazyObjectPtr<UObject> ObjectOrOwner;
    /* 0x0018 */ FString ComponentName;
    /* 0x0028 */ TWeakObjectPtr<UObject> CachedComponent;
};

// Size: 0x50
struct FLevelSequenceObjectReferenceMap {
};

// Size: 0x588
class ULevelSequencePlayer : public UMovieSceneSequencePlayer {
    /* 0x0478 */ FMulticastInlineDelegate OnCameraCut;

    static ULevelSequencePlayer* CreateLevelSequencePlayer(UObject* WorldContextObject, ULevelSequence* LevelSequence, FMovieSceneSequencePlaybackSettings Settings, ALevelSequenceActor*& OutActor);
    UCameraComponent* GetActiveCameraComponent() const;
};

// Size: 0xa8
struct FLevelSequencePlayerSnapshot {
    /* 0x0000 */ FString RootName;
    /* 0x0010 */ FQualifiedFrameTime RootTime;
    /* 0x0020 */ FQualifiedFrameTime SourceTime;
    /* 0x0030 */ FString CurrentShotName;
    /* 0x0040 */ FQualifiedFrameTime CurrentShotLocalTime;
    /* 0x0050 */ FQualifiedFrameTime CurrentShotSourceTime;
    /* 0x0060 */ FString SourceTimecode;
    /* 0x0070 */ TSoftObjectPtr<UCameraComponent> CameraComponent;
    /* 0x0098 */ ULevelSequence* ActiveShot;
    /* 0x00a0 */ FMovieSceneSequenceID ShotID;
};

// Size: 0x68
class ULevelSequenceProjectSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bDefaultLockEngineToDisplayRate;
    /* 0x0040 */ FString DefaultDisplayRate;
    /* 0x0050 */ FString DefaultTickResolution;
    /* 0x0060 */ EUpdateClockSource DefaultClockSource;
};

// Size: 0x28
class ULevelSequenceShotMetaDataLibrary : public UBlueprintFunctionLibrary {

    static void ClearFavoriteRating(ULevelSequence* InLevelSequence);
    static void ClearIsFlagged(ULevelSequence* InLevelSequence);
    static void ClearIsNoGood(ULevelSequence* InLevelSequence);
    static void ClearIsRecorded(ULevelSequence* InLevelSequence);
    static void ClearIsSubSequence(ULevelSequence* InLevelSequence);
    static bool GetFavoriteRating(const ULevelSequence* InLevelSequence, int32_t& OutFavoriteRating);
    static FName GetFavoriteRatingAssetTag();
    static bool GetFavoriteRatingByAssetData(const FAssetData& InAssetData, int32_t& OutFavoriteRating);
    static bool GetIsFlagged(const ULevelSequence* InLevelSequence, bool& bOutIsFlagged);
    static FName GetIsFlaggedAssetTag();
    static bool GetIsFlaggedByAssetData(const FAssetData& InAssetData, bool& bOutIsFlagged);
    static bool GetIsNoGood(const ULevelSequence* InLevelSequence, bool& bOutNoGood);
    static FName GetIsNoGoodAssetTag();
    static bool GetIsNoGoodByAssetData(const FAssetData& InAssetData, bool& bOutNoGood);
    static bool GetIsRecorded(const ULevelSequence* InLevelSequence, bool& bOutIsRecorded);
    static FName GetIsRecordedAssetTag();
    static bool GetIsRecordedByAssetData(const FAssetData& InAssetData, bool& bOutIsRecorded);
    static bool GetIsSubSequence(const ULevelSequence* InLevelSequence, bool& bOutIsSubSequence);
    static FName GetIsSubSequenceAssetTag();
    static bool GetIsSubSequenceByAssetData(const FAssetData& InAssetData, bool& bOutIsSubSequence);
    static bool HasFavoriteRating(const ULevelSequence* InLevelSequence);
    static bool HasFavoriteRatingByAssetData(const FAssetData& InAssetData);
    static bool HasIsFlagged(const ULevelSequence* InLevelSequence);
    static bool HasIsFlaggedByAssetData(const FAssetData& InAssetData);
    static bool HasIsNoGood(const ULevelSequence* InLevelSequence);
    static bool HasIsNoGoodByAssetData(const FAssetData& InAssetData);
    static bool HasIsRecorded(const ULevelSequence* InLevelSequence);
    static bool HasIsRecordedByAssetData(const FAssetData& InAssetData);
    static bool HasIsSubSequence(const ULevelSequence* InLevelSequence);
    static bool HasIsSubSequenceByAssetData(const FAssetData& InAssetData);
    static void SetFavoriteRating(ULevelSequence* InLevelSequence, int32_t InFavoriteRating);
    static void SetIsFlagged(ULevelSequence* InLevelSequence, bool bInIsFlagged);
    static void SetIsNoGood(ULevelSequence* InLevelSequence, bool bInIsNoGood);
    static void SetIsRecorded(ULevelSequence* InLevelSequence, bool bInIsRecorded);
    static void SetIsSubSequence(ULevelSequence* InLevelSequence, bool bInIsSubSequence);
};

// Size: 0x350
class AReplicatedLevelSequenceActor : public ALevelSequenceActor {
};

// Size: 0x10
struct FUpgradedLevelSequenceBindingReferences : public FMovieSceneBindingReferences {
};

// Size: 0x160
struct FCachedSubjectFrame {
};

enum class ELiveLinkCameraProjectionMode {
    Perspective = 0,
    Orthographic = 1,
    ELiveLinkCameraProjectionMode_MAX = 2,
};

enum class ELiveLinkSourceMode {
    Latest = 0,
    EngineTime = 1,
    Timecode = 2,
    ELiveLinkSourceMode_MAX = 3,
};

enum class ELiveLinkSubjectState {
    Connected = 0,
    Unresponsive = 1,
    Disconnected = 2,
    InvalidOrDisabled = 3,
    Paused = 4,
    Unknown = 5,
    ELiveLinkSubjectState_MAX = 6,
};

// Size: 0xb0
struct FLiveLinkAnimationFrameData : public FLiveLinkBaseFrameData {
    /* 0x00a0 */ TArray<FTransform> Transforms;
};

// Size: 0x28
class ULiveLinkAnimationRole : public ULiveLinkBasicRole {
};

// Size: 0x8
struct FLiveLinkBaseBlueprintData {
};

// Size: 0xa0
struct FLiveLinkBaseFrameData {
    /* 0x0000 */ FLiveLinkWorldTime WorldTime;
    /* 0x0010 */ FLiveLinkMetaData MetaData;
    /* 0x0070 */ TArray<float> PropertyValues;
};

// Size: 0x10
struct FLiveLinkBaseStaticData {
    /* 0x0000 */ TArray<FName> PropertyNames;
};

// Size: 0xb8
struct FLiveLinkBasicBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkBaseStaticData StaticData;
    /* 0x0018 */ FLiveLinkBaseFrameData FrameData;
};

// Size: 0x28
class ULiveLinkBasicRole : public ULiveLinkRole {
};

// Size: 0x150
struct FLiveLinkCameraBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkCameraStaticData StaticData;
    /* 0x0030 */ FLiveLinkCameraFrameData FrameData;
};

// Size: 0x120
struct FLiveLinkCameraFrameData : public FLiveLinkTransformFrameData {
    /* 0x0100 */ float FieldOfView;
    /* 0x0104 */ float AspectRatio;
    /* 0x0108 */ float FocalLength;
    /* 0x010c */ float Aperture;
    /* 0x0110 */ float FocusDistance;
    /* 0x0114 */ ELiveLinkCameraProjectionMode ProjectionMode;
    /* 0x0118 */ float FilmBackWidth;
    /* 0x011c */ float FilmBackHeight;
};

// Size: 0x28
class ULiveLinkCameraRole : public ULiveLinkTransformRole {
};

// Size: 0x28
struct FLiveLinkCameraStaticData : public FLiveLinkTransformStaticData {
    /* 0x0018 */ bool bIsFieldOfViewSupported;
    /* 0x0019 */ bool bIsAspectRatioSupported;
    /* 0x001a */ bool bIsFocalLengthSupported;
    /* 0x001b */ bool bIsProjectionModeSupported;
    /* 0x001c */ float FilmBackWidth;
    /* 0x0020 */ float FilmBackHeight;
    /* 0x0024 */ bool bIsApertureSupported;
    /* 0x0025 */ bool bIsFocusDistanceSupported;
    /* 0x0026 */ bool bIsDepthOfFieldSupported;
    /* 0x0027 */ bool bIsDynamicFilmbackSupported;
};

// Size: 0x28
class ULiveLinkController : public UObject {
};

// Size: 0x50
struct FLiveLinkCurveConversionSettings {
    /* 0x0000 */ TMap<FString, FSoftObjectPath> CurveConversionAssetMap;
};

// Size: 0xc
struct FLiveLinkCurveElement {
    /* 0x0000 */ FName CurveName;
    /* 0x0008 */ float CurveValue;
};

// Size: 0x100
class ULiveLinkCurveRemapSettings : public ULiveLinkSourceSettings {
    /* 0x00b0 */ FLiveLinkCurveConversionSettings CurveConversionSettings;
};

// Size: 0x30
class ULiveLinkDefaultSourceSettings : public UObject {
    /* 0x0028 */ int32_t DefaultSourceFrameBufferSize;
};

// Size: 0x30
class ULiveLinkDefaultSubjectSettings : public UObject {
    /* 0x0028 */ bool bRebroadcastSubjectsByDefault;
    /* 0x0029 */ bool bAllowEditingRebroadcastProperty;
};

// Size: 0xb0
struct FLiveLinkFloatAnimationFrameData : public FLiveLinkBaseFrameData {
    /* 0x00a0 */ TArray<FTransform3f> Transforms;
};

// Size: 0x90
struct FLiveLinkFrameData {
    /* 0x0000 */ TArray<FTransform> Transforms;
    /* 0x0010 */ TArray<FLiveLinkCurveElement> CurveElements;
    /* 0x0020 */ FLiveLinkWorldTime WorldTime;
    /* 0x0030 */ FLiveLinkMetaData MetaData;
};

// Size: 0x28
class ULiveLinkFrameInterpolationProcessor : public UObject {
};

// Size: 0x28
class ULiveLinkFramePreProcessor : public UObject {
};

// Size: 0x8
struct FLiveLinkFrameRate : public FFrameRate {
};

// Size: 0x28
class ULiveLinkFrameTranslator : public UObject {
};

// Size: 0x138
struct FLiveLinkGamepadInputDeviceBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkGamepadInputDeviceStaticData StaticData;
    /* 0x0018 */ FLiveLinkGamepadInputDeviceFrameData FrameData;
};

// Size: 0x120
struct FLiveLinkGamepadInputDeviceFrameData : public FLiveLinkBaseFrameData {
    /* 0x00a0 */ float LeftAnalogX;
    /* 0x00a4 */ float LeftAnalogY;
    /* 0x00a8 */ float RightAnalogX;
    /* 0x00ac */ float RightAnalogY;
    /* 0x00b0 */ float LeftTriggerAnalog;
    /* 0x00b4 */ float RightTriggerAnalog;
    /* 0x00b8 */ float LeftThumb;
    /* 0x00bc */ float RightThumb;
    /* 0x00c0 */ float SpecialLeft;
    /* 0x00c4 */ float SpecialLeft_X;
    /* 0x00c8 */ float SpecialLeft_Y;
    /* 0x00cc */ float SpecialRight;
    /* 0x00d0 */ float FaceButtonBottom;
    /* 0x00d4 */ float FaceButtonRight;
    /* 0x00d8 */ float FaceButtonLeft;
    /* 0x00dc */ float FaceButtonTop;
    /* 0x00e0 */ float LeftShoulder;
    /* 0x00e4 */ float RightShoulder;
    /* 0x00e8 */ float LeftTriggerThreshold;
    /* 0x00ec */ float RightTriggerThreshold;
    /* 0x00f0 */ float DPadUp;
    /* 0x00f4 */ float DPadDown;
    /* 0x00f8 */ float DPadRight;
    /* 0x00fc */ float DPadLeft;
    /* 0x0100 */ float LeftStickUp;
    /* 0x0104 */ float LeftStickDown;
    /* 0x0108 */ float LeftStickRight;
    /* 0x010c */ float LeftStickLeft;
    /* 0x0110 */ float RightStickUp;
    /* 0x0114 */ float RightStickDown;
    /* 0x0118 */ float RightStickRight;
    /* 0x011c */ float RightStickLeft;
};

// Size: 0x10
struct FLiveLinkGamepadInputDeviceStaticData : public FLiveLinkBaseStaticData {
};

// Size: 0x28
class ULiveLinkInputDeviceRole : public ULiveLinkBasicRole {
};

// Size: 0x8
struct FLiveLinkInterpolationSettings {
    /* 0x0000 */ bool bUseInterpolation;
    /* 0x0004 */ float InterpolationOffset;
};

// Size: 0x160
struct FLiveLinkLightBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkLightStaticData StaticData;
    /* 0x0030 */ FLiveLinkLightFrameData FrameData;
};

// Size: 0x130
struct FLiveLinkLightFrameData : public FLiveLinkTransformFrameData {
    /* 0x0100 */ float temperature;
    /* 0x0104 */ float Intensity;
    /* 0x0108 */ FColor LightColor;
    /* 0x010c */ float InnerConeAngle;
    /* 0x0110 */ float OuterConeAngle;
    /* 0x0114 */ float AttenuationRadius;
    /* 0x0118 */ float SourceRadius;
    /* 0x011c */ float SoftSourceRadius;
    /* 0x0120 */ float SourceLength;
};

// Size: 0x28
class ULiveLinkLightRole : public ULiveLinkTransformRole {
};

// Size: 0x28
struct FLiveLinkLightStaticData : public FLiveLinkTransformStaticData {
    /* 0x0018 */ bool bIsTemperatureSupported;
    /* 0x0019 */ bool bIsIntensitySupported;
    /* 0x001a */ bool bIsLightColorSupported;
    /* 0x001b */ bool bIsInnerConeAngleSupported;
    /* 0x001c */ bool bIsOuterConeAngleSupported;
    /* 0x001d */ bool bIsAttenuationRadiusSupported;
    /* 0x001e */ bool bIsSourceLenghtSupported;
    /* 0x001f */ bool bIsSourceRadiusSupported;
    /* 0x0020 */ bool bIsSoftSourceRadiusSupported;
};

// Size: 0xe0
struct FLiveLinkLocatorBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkLocatorStaticData StaticData;
    /* 0x0030 */ FLiveLinkLocatorFrameData FrameData;
};

// Size: 0xb0
struct FLiveLinkLocatorFrameData : public FLiveLinkBaseFrameData {
    /* 0x00a0 */ TArray<FVector> Locators;
};

// Size: 0x28
class ULiveLinkLocatorRole : public ULiveLinkBasicRole {
};

// Size: 0x28
struct FLiveLinkLocatorStaticData : public FLiveLinkBaseStaticData {
    /* 0x0010 */ TArray<FName> LocatorNames;
    /* 0x0020 */ bool bUnlabelledData;
};

// Size: 0x60
struct FLiveLinkMetaData {
    /* 0x0000 */ TMap<FName, FString> StringMetaData;
    /* 0x0050 */ FQualifiedFrameTime SceneTime;
};

// Size: 0x20
struct FLiveLinkRefSkeleton {
    /* 0x0000 */ TArray<FName> BoneNames;
    /* 0x0010 */ TArray<int32_t> BoneParents;
};

// Size: 0x28
class ULiveLinkRole : public UObject {
};

// Size: 0x30
struct FLiveLinkSkeletonStaticData : public FLiveLinkBaseStaticData {
    /* 0x0010 */ TArray<FName> BoneNames;
    /* 0x0020 */ TArray<int32_t> BoneParents;
};

// Size: 0x60
struct FLiveLinkSourceBufferManagementSettings {
    /* 0x0000 */ bool bValidEngineTimeEnabled;
    /* 0x0004 */ float ValidEngineTime;
    /* 0x0008 */ float EngineTimeOffset;
    /* 0x0010 */ double EngineTimeClockOffset;
    /* 0x0018 */ double SmoothEngineTimeOffset;
    /* 0x0020 */ bool bGenerateSubFrame;
    /* 0x0024 */ FFrameRate DetectedFrameRate;
    /* 0x002c */ bool bUseTimecodeSmoothLatest;
    /* 0x0030 */ FFrameRate SourceTimecodeFrameRate;
    /* 0x0038 */ bool bValidTimecodeFrameEnabled;
    /* 0x003c */ int32_t ValidTimecodeFrame;
    /* 0x0040 */ float TimecodeFrameOffset;
    /* 0x0048 */ double TimecodeClockOffset;
    /* 0x0050 */ int32_t LatestOffset;
    /* 0x0054 */ int32_t MaxNumberOfFrameToBuffered;
    /* 0x0058 */ bool bKeepAtLeastOneFrame;
};

// Size: 0x10
struct FLiveLinkSourceDebugInfo {
    /* 0x0000 */ FLiveLinkSubjectName SubjectName;
    /* 0x0008 */ int32_t SnapshotIndex;
    /* 0x000c */ int32_t NumberOfBufferAtSnapshot;
};

// Size: 0x28
class ULiveLinkSourceFactory : public UObject {
};

// Size: 0x18
struct FLiveLinkSourceHandle {
};

// Size: 0x28
struct FLiveLinkSourcePreset {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ ULiveLinkSourceSettings* Settings;
    /* 0x0018 */ FText SourceType;
};

// Size: 0xb0
class ULiveLinkSourceSettings : public UObject {
    /* 0x0028 */ ELiveLinkSourceMode Mode;
    /* 0x0030 */ FLiveLinkSourceBufferManagementSettings BufferSettings;
    /* 0x0090 */ FString ConnectionString;
    /* 0x00a0 */ UClass* Factory;
    /* 0x00a8 */ FLiveLinkSubjectName ParentSubject;
};

// Size: 0x18
struct FLiveLinkSubjectKey {
    /* 0x0000 */ FGuid Source;
    /* 0x0010 */ FLiveLinkSubjectName SubjectName;
};

// Size: 0x8
struct FLiveLinkSubjectName {
    /* 0x0000 */ FName Name;
};

// Size: 0x38
struct FLiveLinkSubjectPreset {
    /* 0x0000 */ FLiveLinkSubjectKey Key;
    /* 0x0018 */ UClass* Role;
    /* 0x0020 */ ULiveLinkSubjectSettings* Settings;
    /* 0x0028 */ ULiveLinkVirtualSubject* VirtualSubject;
    /* 0x0030 */ bool bEnabled;
};

// Size: 0x80
class ULiveLinkSubjectRemapper : public UObject {
    /* 0x0028 */ TMap<FName, FName> BoneNameMap;
};

// Size: 0x10
struct FLiveLinkSubjectRepresentation {
    /* 0x0000 */ FLiveLinkSubjectName Subject;
    /* 0x0008 */ UClass* Role;
};

// Size: 0xa0
class ULiveLinkSubjectSettings : public UObject {
    /* 0x0028 */ TArray<ULiveLinkFramePreProcessor*> PreProcessors;
    /* 0x0038 */ ULiveLinkFrameInterpolationProcessor* InterpolationProcessor;
    /* 0x0040 */ TArray<ULiveLinkFrameTranslator*> Translators;
    /* 0x0050 */ ULiveLinkSubjectRemapper* Remapper;
    /* 0x0058 */ UClass* Role;
    /* 0x0060 */ FFrameRate FrameRate;
    /* 0x0068 */ bool bRebroadcastSubject;
    /* 0x006c */ FName OriginalSourceName;
    /* 0x0074 */ FLiveLinkSubjectKey Key;
    /* 0x0098 */ bool bAllowModifyingRebroadcast;
};

// Size: 0x18
struct FLiveLinkTime {
    /* 0x0000 */ double WorldTime;
    /* 0x0008 */ FQualifiedFrameTime SceneTime;
};

// Size: 0x10
struct FLiveLinkTimeCode : public FLiveLinkTimeCode_Base_DEPRECATED {
};

// Size: 0x10
struct FLiveLinkTimeCode_Base_DEPRECATED {
    /* 0x0000 */ int32_t Seconds;
    /* 0x0004 */ int32_t Frames;
    /* 0x0008 */ FLiveLinkFrameRate FrameRate;
};

// Size: 0xc
struct FLiveLinkTimeSynchronizationSettings {
    /* 0x0000 */ FFrameRate FrameRate;
    /* 0x0008 */ FFrameNumber FrameOffset;
};

// Size: 0x20
struct FLiveLinkTransform {
};

// Size: 0x120
struct FLiveLinkTransformBlueprintData : public FLiveLinkBaseBlueprintData {
    /* 0x0008 */ FLiveLinkTransformStaticData StaticData;
    /* 0x0020 */ FLiveLinkTransformFrameData FrameData;
};

// Size: 0x100
struct FLiveLinkTransformFrameData : public FLiveLinkBaseFrameData {
    /* 0x00a0 */ FTransform Transform;
};

// Size: 0x28
class ULiveLinkTransformRole : public ULiveLinkBasicRole {
};

// Size: 0x18
struct FLiveLinkTransformStaticData : public FLiveLinkBaseStaticData {
    /* 0x0010 */ bool bIsLocationSupported;
    /* 0x0011 */ bool bIsRotationSupported;
    /* 0x0012 */ bool bIsScaleSupported;
};

// Size: 0x178
class ULiveLinkVirtualSubject : public UObject {
    /* 0x0030 */ UClass* Role;
    /* 0x0038 */ TArray<FLiveLinkSubjectName> Subjects;
    /* 0x0048 */ TArray<ULiveLinkFrameTranslator*> FrameTranslators;
    /* 0x0058 */ bool bRebroadcastSubject;
};

// Size: 0x10
struct FLiveLinkWorldTime {
    /* 0x0000 */ double Time;
    /* 0x0008 */ double Offset;
};

// Size: 0x18
struct FSubjectFrameHandle : public FLiveLinkBaseBlueprintData {
};

// Size: 0x70
struct FSubjectMetadata {
    /* 0x0000 */ TMap<FName, FString> StringMetaData;
    /* 0x0050 */ FTimecode SceneTimecode;
    /* 0x0068 */ FFrameRate SceneFramerate;
};

enum class ELocalFileReplayResult {
    Success = 0,
    InvalidReplayInfo = 1,
    StreamChunkIndexMismatch = 2,
    DecompressBuffer = 3,
    CompressionNotSupported = 4,
    DecryptBuffer = 5,
    EncryptionNotSupported = 6,
    EncryptBuffer = 7,
    CompressBuffer = 8,
    InvalidName = 9,
    FileWriter = 10,
    Unknown = 11,
    ELocalFileReplayResult_MAX = 12,
};

// Size: 0x30
struct FLocalizableMessage {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ FString DefaultText;
    /* 0x0020 */ TArray<FLocalizableMessageParameterEntry> Substitutions;
};

// Size: 0x20
struct FLocalizableMessageParameterEntry {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ FInstancedStruct Value;
};

// Size: 0x8
struct FLocalizableMessageParameterFloat {
    /* 0x0000 */ double Value;
};

// Size: 0x8
struct FLocalizableMessageParameterInt {
    /* 0x0000 */ int64_t Value;
};

// Size: 0x30
struct FLocalizableMessageParameterMessage {
    /* 0x0000 */ FLocalizableMessage Value;
};

// Size: 0x10
struct FLocalizableMessageParameterString {
    /* 0x0000 */ FString Value;
};

// Size: 0x28
class ULocalizableMessageLibrary : public UBlueprintFunctionLibrary {

    static FText Conv_LocalizableMessageToText(UObject* WorldContextObject, const FLocalizableMessage& Message);
    static bool IsEmpty_LocalizableMessage(const FLocalizableMessage& Message);
    static void Reset_LocalizableMessage(FLocalizableMessage& Message);
};

// Size: 0x2a0
class UAsyncMeshBuilder : public USceneComponent {
    /* 0x0240 */ TArray<FAsyncMeshBuilderMeshConfig> MeshConfigs;
    /* 0x0250 */ TArray<UStaticMeshComponent*> MeshComponents;
    /* 0x0260 */ TArray<UStaticMesh*> BuildingMeshes;
    /* 0x0270 */ TArray<UStaticMesh*> BuiltMeshes;
};

// Size: 0x18
struct FAsyncMeshBuilderMeshConfig {
    /* 0x0000 */ int32_t NumberOfUVChannels;
    /* 0x0008 */ UMaterialInterface* Material;
    /* 0x0010 */ bool bVisible;
};

// Size: 0x620
class UCustomBoundsMeshComponent : public UStaticMeshComponent {
    /* 0x0610 */ float OriginZ;
    /* 0x0614 */ float BoxExtentZ;
};

enum class EBiome {
    None = 0,
    Foundation = 1,
    Forest = 2,
    Field = 3,
    Track = 4,
    Water = 5,
    BIOMEEND = 6,
    EBiome_MAX = 7,
};

enum class EClimate {
    None = 0,
    Savanna = 1,
    Desert = 2,
    Temperate = 3,
    Boreal = 4,
    Arctic = 5,
    CLIMATEEND = 6,
    EClimate_MAX = 7,
};

enum class EDiscreteRotation {
    North = 0,
    NorthEast = 1,
    East = 2,
    SouthEast = 3,
    South = 4,
    SouthWest = 5,
    West = 6,
    NorthWest = 7,
    EDiscreteRotation_MAX = 8,
};

enum class EGridInstaMeshShadow {
    Default = 0,
    Hidden = 1,
    None = 2,
    EGridInstaMeshShadow_MAX = 3,
};

enum class EGridInstaMeshVisibility {
    Visible = 0,
    Invisible = 1,
    Disabled = 2,
    EGridInstaMeshVisibility_MAX = 3,
};

enum class EPlatformCategory {
    Pc = 0,
    XBO = 1,
    XSX = 2,
    Ps4 = 3,
    Ps5 = 4,
    Switch = 5,
    Stadia = 6,
    Steamdeck = 7,
    Switch2 = 8,
    EPlatformCategory_MAX = 9,
};

// Size: 0x120
struct FGridInstaMesh {
    /* 0x0000 */ USceneComponent* Parent;
    /* 0x0008 */ FVector GridScale;
    /* 0x0020 */ FVector Offset;
    /* 0x0038 */ uint8_t Collision;
    /* 0x0039 */ EGridInstaMeshShadow Shadow;
    /* 0x003a */ bool bAntiZFighting;
    /* 0x003b */ bool bHierarchical;
    /* 0x003c */ EGridInstaMeshVisibility Visibility;
    /* 0x003d */ bool bLightingChannel1;
    /* 0x003e */ bool bLightingChannel2;
    /* 0x003f */ bool bLightingChannel3;
    /* 0x0040 */ double WpoDisableDistance;
    /* 0x0048 */ TMap<UStaticMesh*, FGridInstaMeshInstances> Meshes;
    /* 0x00a8 */ TMap<FIntVector, FGridInstaMeshLocation> Locations;
    /* 0x0108 */ TArray<UMaterialInstance*> OverrideMaterials;
    /* 0x0118 */ int32_t NumCustomDataFloats;
};

// Size: 0x28
struct FGridInstaMeshInstances {
    /* 0x0000 */ UInstancedStaticMeshComponent* Meshes;
};

// Size: 0x10
struct FGridInstaMeshLocation {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ int32_t Index;
};

// Size: 0x3a0
class UInstaMesh : public USceneComponent {
    /* 0x0240 */ FInstaMeshState State;
    /* 0x0388 */ FInstaMeshConfig config;
};

// Size: 0x10
struct FInstaMeshConfig {
    /* 0x0000 */ bool disableCollisions;
    /* 0x0004 */ FName CollisionProfileName;
    /* 0x000c */ int32_t chunkSize;
};

// Size: 0xb8
struct FInstaMeshIndexTracker {
    /* 0x0000 */ TMap<int32_t, int32_t> fakeToTrueIndex;
    /* 0x0050 */ TMap<int32_t, int32_t> trueToFakeIndex;
    /* 0x00a0 */ TArray<int32_t> validTrueIndexes;
    /* 0x00b0 */ int32_t highestFakeIndex;
};

// Size: 0x148
struct FInstaMeshState {
    /* 0x0000 */ int32_t nextId;
    /* 0x0008 */ TMap<FString, int32_t> Parents;
    /* 0x0058 */ TMap<int32_t, FInstaMeshIndexTracker> parentIndexTracks;
    /* 0x00a8 */ TMap<int32_t, UInstancedStaticMeshComponent*> parentByParentId;
    /* 0x00f8 */ TSet<int32_t> changedParents;
};

// Size: 0x8
struct FInstaMeshTag {
    /* 0x0000 */ int32_t ParentID;
    /* 0x0004 */ int32_t fakeIndex;
};

// Size: 0x2c0
class AMesher : public AActor {
    /* 0x02a8 */ int32_t Resolution;
    /* 0x02b0 */ FString Name;
};

// Size: 0x80
class UNoise : public UObject {
    /* 0x0028 */ TArray<UNoise*> Children;
    /* 0x0038 */ uint64_t Seed;
    /* 0x0040 */ bool bSharedSeed;
    /* 0x0048 */ UClass* Random;
    /* 0x0050 */ float ClampMin;
    /* 0x0054 */ float ClampMax;
    /* 0x0058 */ UTexture2D* TestTexture;
    /* 0x0060 */ bool bEnableTest;
    /* 0x0064 */ int32_t TestTextureSize;
    /* 0x0068 */ double TestZoom;
    /* 0x0070 */ double TestScale;
    /* 0x0078 */ double TestBias;

    float Get2D(float X, float Y) const;
    float Get3D(float X, float Y, float Z) const;
    bool SetFloat(FString NoiseName, const FName& PropertyName, float Value);
    bool SetInt(FString NoiseName, const FName& PropertyName, int32_t Value);
    bool SetNoise(FString NoiseName, const FName& PropertyName, UNoise* Value);
    void SetSeed(uint64_t NewSeed);
};

// Size: 0x98
class UNoiseAbsolute : public UNoise {
    /* 0x0080 */ float Threshold;
    /* 0x0084 */ bool bPositive;
    /* 0x0088 */ UClass* Noise;
    /* 0x0090 */ UNoise* Loaded;
};

// Size: 0xa0
class UNoiseAddition : public UNoise {
    /* 0x0080 */ UClass* NoiseA;
    /* 0x0088 */ UClass* NoiseB;
    /* 0x0090 */ UNoise* LoadedA;
    /* 0x0098 */ UNoise* LoadedB;
};

// Size: 0xb0
class UNoiseDistance : public UNoiseFractal {
    /* 0x0098 */ float MinPower;
    /* 0x009c */ float MaxPower;
};

// Size: 0xc0
class UNoiseDistortion : public UNoise {
    /* 0x0080 */ UClass* NoiseX;
    /* 0x0088 */ UClass* NoiseY;
    /* 0x0090 */ UClass* NoiseZ;
    /* 0x0098 */ UClass* NoiseO;
    /* 0x00a0 */ UNoise* LoadedX;
    /* 0x00a8 */ UNoise* LoadedY;
    /* 0x00b0 */ UNoise* LoadedZ;
    /* 0x00b8 */ UNoise* LoadedO;
};

// Size: 0x98
class UNoiseFractal : public UNoise {
    /* 0x0080 */ float GridScale;
    /* 0x0084 */ uint32_t OctaveCount;
    /* 0x0088 */ float OctaveScale;
    /* 0x008c */ float OctaveAttenuation;
    /* 0x0090 */ float Bias;
    /* 0x0094 */ float Scale;
};

// Size: 0xa8
class UNoiseGradient : public UNoiseFractal {
};

// Size: 0xb8
class UNoiseIsland : public UNoise {
    /* 0x0080 */ FVector2f Center;
    /* 0x0088 */ FVector2f Size;
    /* 0x0090 */ int32_t BlobCount;
    /* 0x0094 */ float AverageSize;
    /* 0x0098 */ float Variation;
    /* 0x009c */ float Offset;
    /* 0x00a0 */ float Slope;
    /* 0x00a8 */ TArray<FNoiseIslandBlob> Blobs;
};

// Size: 0x10
struct FNoiseIslandBlob {
    /* 0x0000 */ FVector2f Center;
    /* 0x0008 */ float Size;
    /* 0x000c */ float Plateau;
};

// Size: 0xa0
class UNoiseMaximum : public UNoise {
    /* 0x0080 */ UClass* NoiseA;
    /* 0x0088 */ UClass* NoiseB;
    /* 0x0090 */ UNoise* LoadedA;
    /* 0x0098 */ UNoise* LoadedB;
};

// Size: 0xa0
class UNoiseMinimum : public UNoise {
    /* 0x0080 */ UClass* NoiseA;
    /* 0x0088 */ UClass* NoiseB;
    /* 0x0090 */ UNoise* LoadedA;
    /* 0x0098 */ UNoise* LoadedB;
};

// Size: 0xa0
class UNoiseMultiplication : public UNoise {
    /* 0x0080 */ UClass* NoiseA;
    /* 0x0088 */ UClass* NoiseB;
    /* 0x0090 */ UNoise* LoadedA;
    /* 0x0098 */ UNoise* LoadedB;
};

// Size: 0xc0
class UNoisePlateau : public UNoise {
    /* 0x0080 */ float Distance;
    /* 0x0084 */ float DistanceOffset;
    /* 0x0088 */ float ShiftFactor;
    /* 0x008c */ float PowerFactor;
    /* 0x0090 */ UClass* NoiseInput;
    /* 0x0098 */ UClass* NoiseShift;
    /* 0x00a0 */ UClass* NoisePower;
    /* 0x00a8 */ UNoise* LoadedInput;
    /* 0x00b0 */ UNoise* LoadedShift;
    /* 0x00b8 */ UNoise* LoadedPower;
};

// Size: 0xa0
class UNoiseSubtraction : public UNoise {
    /* 0x0080 */ UClass* NoiseA;
    /* 0x0088 */ UClass* NoiseB;
    /* 0x0090 */ UNoise* LoadedA;
    /* 0x0098 */ UNoise* LoadedB;
};

// Size: 0x80
class UNoiseTexture : public UNoise {
};

// Size: 0xa0
class UNoiseTilt : public UNoise {
    /* 0x0080 */ float Offset;
    /* 0x0084 */ FVector3f Weights;
    /* 0x0090 */ UClass* Noise;
    /* 0x0098 */ UNoise* Loaded;
};

// Size: 0xc0
class UNoiseValue : public UNoiseFractal {
    /* 0x0098 */ float MinPower;
    /* 0x009c */ float MaxPower;
    /* 0x00a0 */ float ShiftAmount;
};

// Size: 0xb0
class UNoiseVoronoi : public UNoiseFractal {
    /* 0x0098 */ float Smoothness;
};

// Size: 0x58
struct FPolygon {
    /* 0x0000 */ TArray<FVector2D> Corners;
};

// Size: 0x18
struct FPolygonContour {
    /* 0x0000 */ bool bIsHole;
    /* 0x0008 */ TArray<FVector2D> Vertices;
};

// Size: 0x10
struct FPolygonData {
    /* 0x0000 */ TArray<FPolygonContour> Contours;
};

// Size: 0x20
struct FPolygonTriangulation {
    /* 0x0000 */ TArray<FVector> Vertices;
    /* 0x0010 */ TArray<int32_t> Triangles;
};

// Size: 0x30
class URandom : public UObject {
    /* 0x0028 */ uint64_t Seed;

    float GetAngleRadian();
    double GetDouble();
    double GetDoubleNonZero();
    float GetFloat();
    float GetFloatNonZero();
    FVector2D GetGaussianPair();
    float GetNormalDistributed();
    double GetScaledDouble(double From, double To);
    float GetScaledFloat(float From, float To);
    uint32_t GetUint32();
    uint64_t GetUint64();
    FVector GetVector(float Length);
    void SetSeed(uint64_t NewSeed);
};

// Size: 0x30
class URandomEngine : public URandom {
};

// Size: 0x38
class URandomSplitMix : public URandom {
};

// Size: 0x8
struct FRandomSplitMixWrapper {
    /* 0x0000 */ URandomSplitMix* Instance;
};

// Size: 0x38
class URandomXorshift : public URandom {
};

// Size: 0x8
struct FRandomXorshiftWrapper {
    /* 0x0000 */ URandomXorshift* Instance;
};

// Size: 0x58
class URandomXorshiro : public URandom {
    /* 0x0030 */ URandomSplitMix* Initializer;
};

// Size: 0x8
struct FRandomXorshiroWrapper {
    /* 0x0000 */ URandomXorshiro* Instance;
};

// Size: 0x28
class USpecialFlags : public UBlueprintFunctionLibrary {

    static void ApplyTextInputLimits(FString rawText, FString& cleanText, bool& atLengthLimit);
    static FString ComputeConsoleDefaultAA();
    static int32_t ComputeConsoleDefaultResolutionScale();
    static EPlatformCategory FindPlatformCategory();
    static FString GetDemoName();
    static FString GetDemoTooltipStringId();
    static float GetGlobalApplicationScale();
    static float GetGlobalVolumeRatio();
    static int32_t GetSaveSlotMaxCount();
    static FString GetSaveSubfolder();
    static int32_t GetTextInputLengthLimit();
    static bool IsAMD();
    static bool IsAchievementsAllCaps();
    static bool IsAchievementsLoginOnly();
    static bool IsAchivementAllowed();
    static bool IsBenchmarkAllowed();
    static bool IsCheatAllowed();
    static bool IsConfMode();
    static bool IsConsole();
    static bool IsDX11();
    static bool IsDebugAllowed();
    static bool IsDemoMode();
    static bool IsDevelopmentMode();
    static bool IsEarlyAccessAllowed();
    static bool IsEarlyLoginEnabled();
    static bool IsEgs();
    static bool IsGameModded();
    static bool IsGamepadDisabled();
    static bool IsGlobalControllerMode();
    static bool IsGog();
    static bool IsImagesWrapped();
    static bool IsLowPerfPlatform();
    static bool IsMac();
    static bool IsMobile();
    static bool IsModdingAllowed();
    static bool IsMouseAllowed();
    static bool IsNavyAllowed();
    static bool IsNvidia();
    static bool IsOnStartAchievements();
    static bool IsPc();
    static bool IsPressMode();
    static bool IsQuitAllowed();
    static bool IsRateLimitedAchievements();
    static bool IsRunningRestarts();
    static bool IsSaveChunkingEnabled();
    static bool IsSlotBasedIo();
    static bool IsStandalone();
    static bool IsStartDialogAllowed();
    static bool IsStatsBasedAchievements();
    static bool IsSteam();
    static bool IsSteamdeck();
    static bool IsStove();
    static bool IsTrailerMode();
    static bool IsWinGdk();
    static bool IsWrongBranchMode();
    static bool IsXbox();
    static bool MarkRunningRestarts(bool doRestarts);
    static void ReportRestart();
    static void SetDevelopmentModeOverride(bool forceOn);
    static void SetGlobalControllerMode(bool isControllerNow);
    static void SetTrailerMode(bool IsTrailerMode);
};

// Size: 0x14
struct FTerraformCellState {
    /* 0x0000 */ FIntVector position;
    /* 0x000c */ int32_t Height;
    /* 0x0010 */ EBiome biome;
};

// Size: 0x10
struct FTerraformChangeOrder {
    /* 0x0000 */ TArray<FTerraformCellState> Cells;
};

// Size: 0x478
class ATexturator : public AActor {
    /* 0x02a8 */ FTexturatorGroup TextureGroup;
    /* 0x0428 */ FString DepthTextureName;
    /* 0x0438 */ FString AlbedoRoughnessTextureName;
    /* 0x0448 */ FString NormalTextureName;
    /* 0x0458 */ int32_t IntegrationIterations;
    /* 0x0460 */ double Epsilon;
    /* 0x0468 */ double HeightMultiplicator;
    /* 0x0470 */ int32_t MeanIterations;
    /* 0x0474 */ int32_t RedistributionIterations;
};

// Size: 0x180
struct FTexturatorGroup {
    /* 0x0000 */ FTexturatorSet Set00;
    /* 0x0060 */ FTexturatorSet Set10;
    /* 0x00c0 */ FTexturatorSet Set01;
    /* 0x0120 */ FTexturatorSet Set11;
};

// Size: 0x1
struct FTexturatorProperties {
    /* 0x0000 */ uint8_t CompressionSettings;
};

// Size: 0x60
struct FTexturatorSet {
    /* 0x0000 */ FTexturatorProperties ReadableProperties;
    /* 0x0008 */ UTexture2D* Albedo;
    /* 0x0010 */ FTexturatorProperties AlbedoProperties;
    /* 0x0018 */ UTexture2D* Normal;
    /* 0x0020 */ FTexturatorProperties NormalProperties;
    /* 0x0028 */ UTexture2D* OcclusionRoughnessDepth;
    /* 0x0030 */ FTexturatorProperties OcclusionRoughnessDepthProperties;
    /* 0x0038 */ double Bias;
    /* 0x0040 */ double BaseScale;
    /* 0x0048 */ double IntegrationScale;
    /* 0x0050 */ double HighPassSigma;
    /* 0x0058 */ double HighPassDamping;
};

enum class EMeshTrackerVertexColorMode {
    None = 0,
    Confidence = 1,
    Block = 2,
    EMeshTrackerVertexColorMode_MAX = 3,
};

// Size: 0x220
class UMRMeshBodyHolder : public UObject {
    /* 0x0030 */ UBodySetup* BodySetup;
    /* 0x0038 */ FBodyInstance BodyInstance;
};

// Size: 0x5a0
class UMRMeshComponent : public UPrimitiveComponent {
    /* 0x0528 */ UMaterialInterface* Material;
    /* 0x0530 */ UMaterialInterface* WireframeMaterial;
    /* 0x0538 */ bool bCreateMeshProxySections;
    /* 0x0539 */ bool bUpdateNavMeshOnMeshUpdate;
    /* 0x053b */ bool bNeverCreateCollisionMesh;
    /* 0x0580 */ TArray<UMRMeshBodyHolder*> BodyHolders;

    void Clear();
    void ForceNavMeshUpdate();
    bool GetEnableMeshOcclusion() const;
    bool GetUseWireframe() const;
    FLinearColor GetWireframeColor() const;
    bool IsConnected() const;
    void RequestNavMeshUpdate();
    void SetEnableMeshOcclusion(bool bEnable);
    void SetUseWireframe(bool bUseWireframe);
    void SetWireframeColor(const FLinearColor& InColor);
    void SetWireframeMaterial(UMaterialInterface* InMaterial);
};

// Size: 0x1
struct FMRMeshConfiguration {
};

// Size: 0x28
class UMeshReconstructorBase : public UObject {

    void ConnectMRMesh(UMRMeshComponent* Mesh);
    void DisconnectMRMesh();
    bool IsReconstructionPaused() const;
    bool IsReconstructionStarted() const;
    void PauseReconstruction();
    void StartReconstruction();
    void StopReconstruction();
};

// Size: 0x2b0
class UMockDataMeshTrackerComponent : public USceneComponent {
    /* 0x0240 */ FMulticastInlineDelegate OnMeshTrackerUpdated;
    /* 0x0250 */ bool ScanWorld;
    /* 0x0251 */ bool RequestNormals;
    /* 0x0252 */ bool RequestVertexConfidence;
    /* 0x0253 */ EMeshTrackerVertexColorMode VertexColorMode;
    /* 0x0258 */ TArray<FColor> BlockVertexColors;
    /* 0x0268 */ FLinearColor VertexColorFromConfidenceZero;
    /* 0x0278 */ FLinearColor VertexColorFromConfidenceOne;
    /* 0x0288 */ float UpdateInterval;
    /* 0x0290 */ UMRMeshComponent* MRMesh;

    void ConnectMRMesh(UMRMeshComponent* InMRMeshPtr);
    void DisconnectMRMesh(UMRMeshComponent* InMRMeshPtr);
    void OnMockDataMeshTrackerUpdated__DelegateSignature(int32_t Index, const TArray<FVector>& Vertices, const TArray<int32_t>& Triangles, const TArray<FVector>& Normals, const TArray<float>& Confidence);
};

enum class EActivationState {
    Inactive = 0,
    Active = 1,
    OneShot = 2,
    EActivationState_MAX = 3,
};

enum class EMassCommandOperationType {
    None = 0,
    Create = 1,
    Add = 2,
    Remove = 3,
    ChangeComposition = 4,
    Set = 5,
    Destroy = 6,
    MAX = 7,
};

enum class EMassFragmentAccess {
    None = 0,
    ReadOnly = 1,
    ReadWrite = 2,
    MAX = 3,
};

enum class EMassFragmentPresence {
    All = 0,
    Any = 1,
    None = 2,
    Optional = 3,
    MAX = 4,
};

enum class EMassObservedOperation {
    Add = 0,
    Remove = 1,
    MAX = 2,
};

enum class EMassProcessingPhase {
    PrePhysics = 0,
    StartPhysics = 1,
    DuringPhysics = 2,
    EndPhysics = 3,
    PostPhysics = 4,
    FrameEnd = 5,
    MAX = 6,
};

enum class EMassQueryBasedPruning {
    Prune = 0,
    Never = 1,
    Default = 0,
    EMassQueryBasedPruning_MAX = 2,
};

enum class EProcessorExecutionFlags {
    None = 0,
    Standalone = 1,
    Server = 2,
    Client = 4,
    Editor = 8,
    EditorWorld = 16,
    AllNetModes = 7,
    AllWorldModes = 23,
    All = 31,
    EProcessorExecutionFlags_MAX = 32,
};

// Size: 0x1
struct FMassChunkFragment {
};

// Size: 0x100
class UMassCompositeProcessor : public UMassProcessor {
    /* 0x00c0 */ FMassRuntimePipeline ChildPipeline;
    /* 0x00d8 */ FName GroupName;
};

// Size: 0x1
struct FMassConstSharedFragment {
};

// Size: 0x8
struct FMassDebugLogFragment : public FMassFragment {
    /* 0x0000 */ TWeakObjectPtr<UObject> LogOwner;
};

// Size: 0x8
struct FMassEntityHandle {
    /* 0x0000 */ int32_t Index;
    /* 0x0004 */ int32_t SerialNumber;
};

// Size: 0x50
struct FMassEntityObserverClassesMap {
    /* 0x0000 */ TMap<UScriptStruct*, FMassProcessorClassCollection> Container;
};

// Size: 0x350
struct FMassEntityQuery : public FMassFragmentRequirements {
};

// Size: 0x130
class UMassEntitySettings : public UMassModuleSettings {
    /* 0x0028 */ int32_t ChunkMemorySize;
    /* 0x0030 */ FString DumpDependencyGraphFileName;
    /* 0x0040 */ FMassProcessingPhaseConfig ProcessingPhasesConfig[6];
    /* 0x0100 */ TArray<UMassProcessor*> ProcessorCDOs;
};

// Size: 0x48
class UMassEntitySubsystem : public UMassSubsystemBase {
};

// Size: 0x28
struct FMassEntityView {
};

// Size: 0x1
struct FMassFragment {
};

// Size: 0x278
struct FMassFragmentRequirements {
};

// Size: 0x1
struct FMassGenericDebugEvent {
};

// Size: 0x28
class UMassModuleSettings : public UObject {
};

// Size: 0x1f0
struct FMassObserverManager {
    /* 0x00a8 */ FMassObserversMap FragmentObservers[2];
    /* 0x0148 */ FMassObserversMap TagObservers[2];
};

// Size: 0xd8
class UMassObserverProcessor : public UMassProcessor {
    /* 0x00c0 */ bool bAutoRegisterWithObserverRegistry;
    /* 0x00c8 */ UScriptStruct* ObservedType;
};

// Size: 0x168
class UMassObserverRegistry : public UObject {
    /* 0x0028 */ FMassEntityObserverClassesMap FragmentObservers[2];
    /* 0x00c8 */ FMassEntityObserverClassesMap TagObservers[2];
};

// Size: 0x50
struct FMassObserversMap {
    /* 0x0000 */ TMap<UScriptStruct*, FMassRuntimePipeline> Container;
};

// Size: 0x20
struct FMassProcessingContext_DEPRECATED {
    /* 0x0000 */ float DeltaSeconds;
    /* 0x0008 */ FInstancedStruct AuxData;
    /* 0x0018 */ bool bFlushCommandBuffer;
};

// Size: 0x20
struct FMassProcessingPhaseConfig {
    /* 0x0000 */ FName PhaseName;
    /* 0x0008 */ UClass* PhaseGroupClass;
    /* 0x0010 */ TArray<UMassProcessor*> ProcessorCDOs;
};

// Size: 0xc0
class UMassProcessor : public UObject {
    /* 0x0028 */ FMassProcessorExecutionOrder ExecutionOrder;
    /* 0x0050 */ EMassProcessingPhase ProcessingPhase;
    /* 0x0051 */ uint8_t ExecutionFlags;
    /* 0x0052 */ bool bAutoRegisterWithProcessingPhases;
    /* 0x0052 */ bool bRequiresGameThreadExecution;
    /* 0x0053 */ EActivationState ActivationState;
    /* 0x0054 */ int16_t ExecutionPriority;
};

// Size: 0x10
struct FMassProcessorClassCollection {
    /* 0x0000 */ TArray<UClass*> ClassCollection;
};

// Size: 0x28
struct FMassProcessorExecutionOrder {
    /* 0x0000 */ FName ExecuteInGroup;
    /* 0x0008 */ TArray<FName> ExecuteBefore;
    /* 0x0018 */ TArray<FName> ExecuteAfter;
};

// Size: 0x18
struct FMassRuntimePipeline {
    /* 0x0000 */ TArray<UMassProcessor*> Processors;
};

// Size: 0x88
class UMassSettings : public UDeveloperSettings {
    /* 0x0038 */ TMap<FName, UMassModuleSettings*> ModuleSettings;
};

// Size: 0x1
struct FMassSharedFragment {
};

// Size: 0x38
class UMassSubsystemBase : public UWorldSubsystem {
};

// Size: 0x48
struct FMassSubsystemRequirements {
};

// Size: 0x1
struct FMassTag {
};

// Size: 0x48
class UMassTickableSubsystemBase : public UTickableWorldSubsystem {
};

// Size: 0x1
struct FProcessorAuxDataBase {
};

enum class EMobileShadowQuality {
    NoFiltering = 0,
    PCF_1x1 = 1,
    PCF_3x3 = 2,
    PCF_5x5 = 3,
    EMobileShadowQuality_MAX = 4,
};

// Size: 0x8
struct FMaterialQualityOverrides {
    /* 0x0000 */ bool bDiscardQualityDuringCook;
    /* 0x0001 */ bool bEnableOverride;
    /* 0x0002 */ bool bForceFullyRough;
    /* 0x0003 */ bool bForceNonMetal;
    /* 0x0004 */ bool bForceDisableLMDirectionality;
    /* 0x0005 */ bool bForceDisablePreintegratedGF;
    /* 0x0006 */ bool bDisableMaterialNormalCalculation;
    /* 0x0007 */ EMobileShadowQuality MobileShadowQuality;
};

// Size: 0x78
class UMaterialShaderQualitySettings : public UObject {
    /* 0x0028 */ TMap<FName, UShaderPlatformQualitySettings*> ForwardSettingMap;
};

// Size: 0x58
class UShaderPlatformQualitySettings : public UObject {
    /* 0x0028 */ FMaterialQualityOverrides QualityOverrides[4];
};

// Size: 0x88
class UBaseMediaSource : public UMediaSource {
    /* 0x0080 */ FName PlayerName;
};

enum class EMediaAudioCaptureDeviceFilter {
    None = 0,
    Card = 1,
    Microphone = 2,
    Software = 4,
    Unknown = 8,
    EMediaAudioCaptureDeviceFilter_MAX = 9,
};

enum class EMediaPlayerTrack {
    Audio = 0,
    Caption = 1,
    Metadata = 2,
    Script = 3,
    Subtitle = 4,
    Text = 5,
    Video = 6,
    EMediaPlayerTrack_MAX = 7,
};

enum class EMediaSoundChannels {
    Mono = 0,
    Stereo = 1,
    Surround = 2,
    EMediaSoundChannels_MAX = 3,
};

enum class EMediaSoundComponentFFTSize {
    Min_64 = 0,
    Small_256 = 1,
    Medium_512 = 2,
    Large_1024 = 3,
    EMediaSoundComponentFFTSize_MAX = 4,
};

enum class EMediaTextureVisibleMipsTiles {
    None = 0,
    Plane = 1,
    Sphere = 2,
    EMediaTextureVisibleMipsTiles_MAX = 3,
};

enum class EMediaTimeRangeBPType {
    Absolute = 0,
    Current = 1,
    EMediaTimeRangeBPType_MAX = 2,
};

enum class EMediaVideoCaptureDeviceFilter {
    None = 0,
    Card = 1,
    Software = 2,
    Unknown = 4,
    Webcam = 8,
    EMediaVideoCaptureDeviceFilter_MAX = 9,
};

enum class EMediaWebcamCaptureDeviceFilter {
    None = 0,
    DepthSensor = 1,
    Front = 2,
    Rear = 4,
    Unknown = 8,
    EMediaWebcamCaptureDeviceFilter_MAX = 9,
};

// Size: 0xb0
class UFileMediaSource : public UBaseMediaSource {
    /* 0x0088 */ FString FilePath;
    /* 0x0098 */ bool PrecacheFile;

    void SetFilePath(FString Path);
};

// Size: 0x28
class UMediaBlueprintFunctionLibrary : public UBlueprintFunctionLibrary {

    static void EnumerateAudioCaptureDevices(TArray<FMediaCaptureDevice>& OutDevices, int32_t Filter);
    static void EnumerateVideoCaptureDevices(TArray<FMediaCaptureDevice>& OutDevices, int32_t Filter);
    static void EnumerateWebcamCaptureDevices(TArray<FMediaCaptureDevice>& OutDevices, int32_t Filter);
};

// Size: 0x20
struct FMediaCaptureDevice {
    /* 0x0000 */ FText DisplayName;
    /* 0x0010 */ FString URL;
};

// Size: 0xc8
class UMediaComponent : public UActorComponent {
    /* 0x00b8 */ UMediaTexture* MediaTexture;
    /* 0x00c0 */ UMediaPlayer* MediaPlayer;

    UMediaPlayer* GetMediaPlayer() const;
    UMediaTexture* GetMediaTexture() const;
};

// Size: 0x40
struct FMediaMetadataItemBPT {
    /* 0x0000 */ FString LanguageCode;
    /* 0x0010 */ FString MimeType;
    /* 0x0020 */ FString StringData;
    /* 0x0030 */ TArray<uint8_t> BinaryData;
};

// Size: 0x10
struct FMediaMetadataItemsBPT {
    /* 0x0000 */ TArray<FMediaMetadataItemBPT> Items;
};

// Size: 0x188
class UMediaPlayer : public UObject {
    /* 0x0030 */ FMulticastInlineDelegate OnEndReached;
    /* 0x0040 */ FMulticastInlineDelegate OnMediaClosed;
    /* 0x0050 */ FMulticastInlineDelegate OnMediaOpened;
    /* 0x0060 */ FMulticastInlineDelegate OnMediaOpenFailed;
    /* 0x0070 */ FMulticastInlineDelegate OnPlaybackResumed;
    /* 0x0080 */ FMulticastInlineDelegate OnPlaybackSuspended;
    /* 0x0090 */ FMulticastInlineDelegate OnSeekCompleted;
    /* 0x00a0 */ FMulticastInlineDelegate OnTracksChanged;
    /* 0x00b0 */ FMulticastInlineDelegate OnMetadataChanged;
    /* 0x00c0 */ FMulticastInlineDelegate OnBufferingStart;
    /* 0x00d0 */ FMulticastInlineDelegate OnBufferingCompleted;
    /* 0x00e0 */ FTimespan CacheAhead;
    /* 0x00e8 */ FTimespan CacheBehind;
    /* 0x00f0 */ FTimespan CacheBehindGame;
    /* 0x00f8 */ bool NativeAudioOut;
    /* 0x00f9 */ bool PlayOnOpen;
    /* 0x00fc */ bool Shuffle;
    /* 0x00fc */ bool Loop;
    /* 0x0100 */ UMediaPlaylist* Playlist;
    /* 0x0108 */ int32_t PlaylistIndex;
    /* 0x0110 */ FTimespan TimeDelay;
    /* 0x0118 */ float HorizontalFieldOfView;
    /* 0x011c */ float VerticalFieldOfView;
    /* 0x0120 */ FRotator ViewRotation;
    /* 0x0160 */ FGuid PlayerGuid;

    bool CanPause() const;
    bool CanPlaySource(UMediaSource* MediaSource);
    bool CanPlayUrl(FString URL);
    void Close();
    int32_t GetAudioTrackChannels(int32_t TrackIndex, int32_t FormatIndex) const;
    int32_t GetAudioTrackSampleRate(int32_t TrackIndex, int32_t FormatIndex) const;
    FString GetAudioTrackType(int32_t TrackIndex, int32_t FormatIndex) const;
    FName GetDesiredPlayerName() const;
    FTimespan GetDisplayTime() const;
    UMediaTimeStampInfo* GetDisplayTimeStamp() const;
    FTimespan GetDuration() const;
    float GetHorizontalFieldOfView() const;
    TMap<FString, FMediaMetadataItemsBPT> GetMediaMetadataItems() const;
    FText GetMediaName() const;
    int32_t GetNumTrackFormats(EMediaPlayerTrack TrackType, int32_t TrackIndex) const;
    int32_t GetNumTracks(EMediaPlayerTrack TrackType) const;
    FFloatInterval GetPlaybackTimeRange(EMediaTimeRangeBPType InRangeToGet);
    FName GetPlayerName() const;
    UMediaPlaylist* GetPlaylist() const;
    int32_t GetPlaylistIndex() const;
    float GetRate() const;
    int32_t GetSelectedTrack(EMediaPlayerTrack TrackType) const;
    void GetSupportedRates(TArray<FFloatRange>& OutRates, bool Unthinned) const;
    FTimespan GetTime() const;
    FTimespan GetTimeDelay() const;
    UMediaTimeStampInfo* GetTimeStamp() const;
    FText GetTrackDisplayName(EMediaPlayerTrack TrackType, int32_t TrackIndex) const;
    int32_t GetTrackFormat(EMediaPlayerTrack TrackType, int32_t TrackIndex) const;
    FString GetTrackLanguage(EMediaPlayerTrack TrackType, int32_t TrackIndex) const;
    FString GetUrl() const;
    float GetVerticalFieldOfView() const;
    float GetVideoTrackAspectRatio(int32_t TrackIndex, int32_t FormatIndex) const;
    FIntPoint GetVideoTrackDimensions(int32_t TrackIndex, int32_t FormatIndex) const;
    float GetVideoTrackFrameRate(int32_t TrackIndex, int32_t FormatIndex) const;
    FFloatRange GetVideoTrackFrameRates(int32_t TrackIndex, int32_t FormatIndex) const;
    FString GetVideoTrackType(int32_t TrackIndex, int32_t FormatIndex) const;
    FRotator GetViewRotation() const;
    bool HasError() const;
    bool IsBuffering() const;
    bool IsClosed() const;
    bool IsConnecting() const;
    bool IsLooping() const;
    bool IsPaused() const;
    bool IsPlaying() const;
    bool IsPreparing() const;
    bool IsReady() const;
    bool Next();
    bool OpenFile(FString FilePath);
    bool OpenPlaylist(UMediaPlaylist* InPlaylist);
    bool OpenPlaylistIndex(UMediaPlaylist* InPlaylist, int32_t Index);
    bool OpenSource(UMediaSource* MediaSource);
    void OpenSourceLatent(const UObject* WorldContextObject, FLatentActionInfo LatentInfo, UMediaSource* MediaSource, const FMediaPlayerOptions& Options, bool& bSuccess);
    bool OpenSourceWithOptions(UMediaSource* MediaSource, const FMediaPlayerOptions& Options);
    bool OpenUrl(FString URL);
    bool Pause();
    bool Play();
    void PlayAndSeek();
    bool Previous();
    bool Reopen();
    bool Rewind();
    bool Scrub(const FTimespan& Time);
    bool Seek(const FTimespan& Time);
    bool SelectTrack(EMediaPlayerTrack TrackType, int32_t TrackIndex);
    void SetBlockOnTime(const FTimespan& Time);
    void SetDesiredPlayerName(FName PlayerName);
    bool SetLooping(bool Looping);
    void SetMediaOptions(const UMediaSource* Options);
    bool SetNativeVolume(float Volume);
    bool SetPlaybackTimeRange(FFloatInterval InTimeRange);
    bool SetRate(float Rate);
    void SetTimeDelay(FTimespan TimeDelay);
    bool SetTrackFormat(EMediaPlayerTrack TrackType, int32_t TrackIndex, int32_t FormatIndex);
    bool SetVideoTrackFrameRate(int32_t TrackIndex, int32_t FormatIndex, float FrameRate);
    bool SetViewField(float Horizontal, float Vertical, bool Absolute);
    bool SetViewRotation(const FRotator& Rotation, bool Absolute);
    bool SupportsPlaybackTimeRange() const;
    bool SupportsRate(float Rate, bool Unthinned) const;
    bool SupportsScrubbing() const;
    bool SupportsSeeking() const;
};

// Size: 0x28
class IMediaPlayerProxyInterface : public UInterface {
};

// Size: 0x38
class UMediaPlaylist : public UObject {
    /* 0x0028 */ TArray<UMediaSource*> Items;

    bool Add(UMediaSource* MediaSource);
    bool AddFile(FString FilePath);
    bool AddUrl(FString URL);
    UMediaSource* Get(int32_t Index);
    UMediaSource* GetNext(int32_t& InOutIndex);
    UMediaSource* GetPrevious(int32_t& InOutIndex);
    UMediaSource* GetRandom(int32_t& OutIndex);
    void Insert(UMediaSource* MediaSource, int32_t Index);
    int32_t Num();
    bool Remove(UMediaSource* MediaSource);
    bool RemoveAt(int32_t Index);
    bool Replace(int32_t Index, UMediaSource* Replacement);
};

// Size: 0x980
class UMediaSoundComponent : public USynthComponent {
    /* 0x08a0 */ EMediaSoundChannels Channels;
    /* 0x08a4 */ bool DynamicRateAdjustment;
    /* 0x08a8 */ float RateAdjustmentFactor;
    /* 0x08ac */ FFloatRange RateAdjustmentRange;
    /* 0x08c0 */ UMediaPlayer* MediaPlayer;

    bool BP_GetAttenuationSettingsToApply(FSoundAttenuationSettings& OutAttenuationSettings);
    float GetEnvelopeValue() const;
    UMediaPlayer* GetMediaPlayer() const;
    TArray<FMediaSoundComponentSpectralData> GetNormalizedSpectralData();
    TArray<FMediaSoundComponentSpectralData> GetSpectralData();
    void SetEnableEnvelopeFollowing(bool bInEnvelopeFollowing);
    void SetEnableSpectralAnalysis(bool bInSpectralAnalysisEnabled);
    void SetEnvelopeFollowingsettings(int32_t AttackTimeMsec, int32_t ReleaseTimeMsec);
    void SetMediaPlayer(UMediaPlayer* NewMediaPlayer);
    void SetSpectralAnalysisSettings(TArray<float> InFrequenciesToAnalyze, EMediaSoundComponentFFTSize InFFTSize);
};

// Size: 0x8
struct FMediaSoundComponentSpectralData {
    /* 0x0000 */ float FrequencyHz;
    /* 0x0004 */ float Magnitude;
};

// Size: 0x80
class UMediaSource : public UObject {

    FString GetUrl() const;
    void SetMediaOptionBool(const FName& Key, bool Value);
    void SetMediaOptionFloat(const FName& Key, float Value);
    void SetMediaOptionInt64(const FName& Key, int64_t Value);
    void SetMediaOptionString(const FName& Key, FString Value);
    bool Validate() const;
};

// Size: 0x8
struct FMediaSourceCacheSettings {
    /* 0x0000 */ bool bOverride;
    /* 0x0004 */ float TimeToLookAhead;
};

// Size: 0x28
class IMediaSourceRendererInterface : public UInterface {
};

// Size: 0x228
class UMediaTexture : public UTexture {
    /* 0x0140 */ uint8_t AddressX;
    /* 0x0141 */ uint8_t AddressY;
    /* 0x0142 */ bool AutoClear;
    /* 0x0144 */ FLinearColor ClearColor;
    /* 0x0154 */ bool EnableGenMips;
    /* 0x0155 */ bool NewStyleOutput;
    /* 0x0158 */ float CurrentAspectRatio;
    /* 0x015c */ uint8_t CurrentOrientation;
    /* 0x0160 */ UMediaPlayer* MediaPlayer;

    float GetAspectRatio() const;
    int32_t GetHeight() const;
    UMediaPlayer* GetMediaPlayer() const;
    int32_t GetTextureNumMips() const;
    int32_t GetWidth() const;
    void SetMediaPlayer(UMediaPlayer* NewMediaPlayer);
    void UpdateResource();
};

enum class MediaTextureOrientation {
    MTORI_Original = 0,
    MTORI_CW90 = 1,
    MTORI_CW180 = 2,
    MTORI_CW270 = 3,
    MTORI_MAX = 4,
};

// Size: 0x38
class UMediaTimeStampInfo : public UObject {
    /* 0x0028 */ FTimespan Time;
    /* 0x0030 */ int64_t SequenceIndex;
};

// Size: 0x88
class UPlatformMediaSource : public UMediaSource {
    /* 0x0080 */ UMediaSource* MediaSource;
};

// Size: 0x98
class UStreamMediaSource : public UBaseMediaSource {
    /* 0x0088 */ FString StreamUrl;
};

// Size: 0xa0
class UTimeSynchronizableMediaSource : public UBaseMediaSource {
    /* 0x0088 */ bool bUseTimeSynchronization;
    /* 0x008c */ int32_t FrameDelay;
    /* 0x0090 */ double TimeDelay;
    /* 0x0098 */ bool bAutoDetectInput;
};

// Size: 0x118
class UMovieSceneMediaPlayerPropertySection : public UMovieSceneSection {
    /* 0x0108 */ UMediaSource* MediaSource;
    /* 0x0110 */ bool bLoop;
};

// Size: 0x48
struct FMovieSceneMediaPlayerPropertySectionTemplate : public FMovieScenePropertySectionTemplate {
    /* 0x0038 */ UMediaSource* MediaSource;
    /* 0x0040 */ FFrameNumber SectionStartFrame;
    /* 0x0044 */ bool bLoop;
};

// Size: 0x148
class UMovieSceneMediaPlayerPropertyTrack : public UMovieScenePropertyTrack {
};

// Size: 0x270
class UMovieSceneMediaSection : public UMovieSceneSection {
    /* 0x0108 */ UMediaSource* MediaSource;
    /* 0x0110 */ int32_t MediaSourceProxyIndex;
    /* 0x0114 */ bool bLooping;
    /* 0x0118 */ FFrameNumber StartFrameOffset;
    /* 0x0120 */ UMediaTexture* MediaTexture;
    /* 0x0128 */ UMediaSoundComponent* MediaSoundComponent;
    /* 0x0130 */ bool bUseExternalMediaPlayer;
    /* 0x0138 */ UMediaPlayer* ExternalMediaPlayer;
    /* 0x0140 */ FMediaSourceCacheSettings CacheSettings;
    /* 0x0148 */ int32_t TextureIndex;
    /* 0x014c */ bool bHasMediaPlayerProxy;
    /* 0x0150 */ FMovieSceneBoolChannel ChannelCanPlayerBeOpen;
    /* 0x0258 */ FMovieSceneObjectBindingID MediaSourceProxyBindingID;
};

// Size: 0x168
struct FMovieSceneMediaSectionParams {
    /* 0x0000 */ UMediaSoundComponent* MediaSoundComponent;
    /* 0x0008 */ UMediaSource* MediaSource;
    /* 0x0010 */ FMovieSceneObjectBindingID MediaSourceProxy;
    /* 0x0028 */ int32_t MediaSourceProxyIndex;
    /* 0x0030 */ UMediaTexture* MediaTexture;
    /* 0x0038 */ UMediaPlayer* MediaPlayer;
    /* 0x0040 */ FFrameNumber SectionStartFrame;
    /* 0x0044 */ FFrameNumber SectionEndFrame;
    /* 0x0048 */ bool bLooping;
    /* 0x004c */ FFrameNumber StartFrameOffset;
    /* 0x0050 */ FMovieSceneFloatChannel ProxyTextureBlend;
    /* 0x0160 */ FMediaSourceCacheSettings CacheSettings;
};

// Size: 0x190
struct FMovieSceneMediaSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneMediaSectionParams Params;
    /* 0x0188 */ UMovieSceneMediaSection* MediaSection;
};

// Size: 0x130
class UMovieSceneMediaTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ bool bSynchronousScrubbing;
    /* 0x0120 */ TArray<UMovieSceneSection*> MediaSections;
};

enum class EMediaPlateEventState {
    Play = 0,
    Open = 1,
    Close = 2,
    Pause = 3,
    Reverse = 4,
    Forward = 5,
    Rewind = 6,
    Next = 7,
    Previous = 8,
    MAX = 9,
};

enum class EMediaPlateResourceType {
    Playlist = 0,
    External = 1,
    Asset = 2,
    EMediaPlateResourceType_MAX = 3,
};

// Size: 0x2c0
class AMediaPlate : public AActor {
    /* 0x02a8 */ UMediaPlateComponent* MediaPlateComponent;
    /* 0x02b0 */ UStaticMeshComponent* StaticMeshComponent;
    /* 0x02b8 */ bool bEnableHoldoutComposite;

    bool IsHoldoutCompositeEnabled() const;
    void SetHoldoutCompositeEnabled(bool bInEnabled);
};

// Size: 0x38
class UMediaPlateAssetUserData : public UAssetUserData {
};

// Size: 0x260
class UMediaPlateComponent : public UActorComponent {
    /* 0x00c0 */ bool bPlayOnOpen;
    /* 0x00c1 */ bool bAutoPlay;
    /* 0x00c2 */ bool bEnableAudio;
    /* 0x00c4 */ float StartTime;
    /* 0x00c8 */ UMediaSoundComponent* SoundComponent;
    /* 0x00d0 */ UStaticMeshComponent* StaticMeshComponent;
    /* 0x00d8 */ TArray<UStaticMeshComponent*> Letterboxes;
    /* 0x00e8 */ FMediaPlateResource MediaPlateResource;
    /* 0x0150 */ int32_t PlaylistIndex;
    /* 0x0154 */ FMediaSourceCacheSettings CacheSettings;
    /* 0x015c */ bool bIsMediaPlatePlaying;
    /* 0x0170 */ bool bPlayOnlyWhenVisible;
    /* 0x0171 */ bool bLoop;
    /* 0x0172 */ EMediaTextureVisibleMipsTiles VisibleMipsTilesCalculations;
    /* 0x0174 */ float MipMapBias;
    /* 0x0178 */ bool bIsAspectRatioAuto;
    /* 0x0179 */ bool bEnableMipMapUpscaling;
    /* 0x017c */ int32_t MipLevelToUpscale;
    /* 0x0180 */ bool bAdaptivePoleMipUpscaling;
    /* 0x0184 */ float LetterboxAspectRatio;
    /* 0x0190 */ FVector2D MeshRange;
    /* 0x01a0 */ TArray<UMediaTexture*> MediaTextures;
    /* 0x01b0 */ FMediaTextureResourceSettings MediaTextureSettings;
    /* 0x01b8 */ UMediaPlayer* MediaPlayer;
    /* 0x01c0 */ UMediaSource* ExternalMediaSource;
    /* 0x01c8 */ UMediaPlaylist* ActivePlaylist;

    void Close();
    bool GetIsAspectRatioAuto() const;
    float GetLetterboxAspectRatio();
    bool GetLoop();
    UMediaPlayer* GetMediaPlayer();
    UMediaTexture* GetMediaTexture(int32_t Index);
    FVector2D GetMeshRange() const;
    bool IsEventStateChangeAllowed(EMediaPlateEventState InRequestEventState) const;
    bool IsMediaPlatePlaying() const;
    bool Next();
    void OnMediaEnd();
    void OnMediaOpened(FString DeviceUrl);
    void OnMediaResumed();
    void OnMediaSuspended();
    void Open();
    void OpenLatent(const UObject* InWorldContextObject, FLatentActionInfo InLatentInfo, float InTimeout, bool bInWaitForTexture, bool& bOutSuccess);
    void Pause();
    void Play();
    bool Previous();
    bool Rewind();
    bool Seek(const FTimespan& Time);
    void SelectExternalMedia(FString InFilePath);
    void SelectMediaPlaylistAsset(const UMediaPlaylist* InMediaPlaylist);
    void SelectMediaSourceAsset(const UMediaSource* InMediaSource);
    void SetEnableAudio(bool bInEnableAudio);
    void SetIsAspectRatioAuto(bool bInIsAspectRatioAuto);
    void SetLetterboxAspectRatio(float AspectRatio);
    void SetLoop(bool bInLoop);
    void SetMeshRange(FVector2D InMeshRange);
    void SetPlayOnlyWhenVisible(bool bInPlayOnlyWhenVisible);
};

// Size: 0x68
struct FMediaPlateResource {
    /* 0x0000 */ EMediaPlateResourceType Type;
    /* 0x0008 */ FString ExternalMediaPath;
    /* 0x0018 */ TSoftObjectPtr<UMediaSource> MediaAsset;
    /* 0x0040 */ TSoftObjectPtr<UMediaPlaylist> SourcePlaylist;
};

// Size: 0x1
struct FMediaTextureResourceSettings {
    /* 0x0000 */ bool bEnableGenMips;
};

enum class EMediaPlayerOptionBooleanOverride {
    UseMediaPlayerSetting = 0,
    Enabled = 1,
    Disabled = 2,
    EMediaPlayerOptionBooleanOverride_MAX = 3,
};

enum class EMediaPlayerOptionSeekTimeType {
    Ignored = 0,
    RelativeToStartTime = 1,
    EMediaPlayerOptionSeekTimeType_MAX = 2,
};

enum class EMediaPlayerOptionTrackSelectMode {
    UseMediaPlayerDefaults = 0,
    UseTrackOptionIndices = 1,
    UseLanguageCodes = 2,
    EMediaPlayerOptionTrackSelectMode_MAX = 3,
};

// Size: 0x40
struct FMediaPlayerInitialTrackLanguageSelection {
    /* 0x0000 */ FString Video;
    /* 0x0010 */ FString Audio;
    /* 0x0020 */ FString Subtitle;
    /* 0x0030 */ FString Caption;
};

// Size: 0xc8
struct FMediaPlayerOptions {
    /* 0x0000 */ FMediaPlayerTrackOptions Tracks;
    /* 0x0020 */ FMediaPlayerInitialTrackLanguageSelection TracksByLanguage;
    /* 0x0060 */ EMediaPlayerOptionTrackSelectMode TrackSelection;
    /* 0x0068 */ FTimespan SeekTime;
    /* 0x0070 */ EMediaPlayerOptionSeekTimeType SeekTimeType;
    /* 0x0071 */ EMediaPlayerOptionBooleanOverride PlayOnOpen;
    /* 0x0072 */ EMediaPlayerOptionBooleanOverride Loop;
};

// Size: 0x1c
struct FMediaPlayerTrackOptions {
    /* 0x0000 */ int32_t Audio;
    /* 0x0004 */ int32_t Caption;
    /* 0x0008 */ int32_t MetaData;
    /* 0x000c */ int32_t Script;
    /* 0x0010 */ int32_t Subtitle;
    /* 0x0014 */ int32_t Text;
    /* 0x0018 */ int32_t Video;
};

enum class EComputeNTBsOptions {
    None = 0,
    Normals = 1,
    Tangents = 2,
    WeightedNTBs = 4,
    EComputeNTBsOptions_MAX = 5,
};

// Size: 0x4
struct FEdgeID : public FElementID {
};

// Size: 0x4
struct FElementID {
    /* 0x0000 */ int32_t IDValue;
};

// Size: 0x2f0
class UMeshDescriptionBase : public UObject {

    void ComputePolygonTriangulation(FPolygonID PolygonID);
    FEdgeID CreateEdge(FVertexID VertexID0, FVertexID VertexID1);
    void CreateEdgeWithID(FEdgeID EdgeID, FVertexID VertexID0, FVertexID VertexID1);
    FPolygonID CreatePolygon(FPolygonGroupID PolygonGroupID, TArray<FVertexInstanceID>& VertexInstanceIDs, TArray<FEdgeID>& NewEdgeIDs);
    FPolygonGroupID CreatePolygonGroup();
    void CreatePolygonGroupWithID(FPolygonGroupID PolygonGroupID);
    void CreatePolygonWithID(FPolygonID PolygonID, FPolygonGroupID PolygonGroupID, TArray<FVertexInstanceID>& VertexInstanceIDs, TArray<FEdgeID>& NewEdgeIDs);
    FTriangleID CreateTriangle(FPolygonGroupID PolygonGroupID, const TArray<FVertexInstanceID>& VertexInstanceIDs, TArray<FEdgeID>& NewEdgeIDs);
    void CreateTriangleWithID(FTriangleID TriangleID, FPolygonGroupID PolygonGroupID, const TArray<FVertexInstanceID>& VertexInstanceIDs, TArray<FEdgeID>& NewEdgeIDs);
    FVertexID CreateVertex();
    FVertexInstanceID CreateVertexInstance(FVertexID VertexID);
    void CreateVertexInstanceWithID(FVertexInstanceID VertexInstanceID, FVertexID VertexID);
    void CreateVertexWithID(FVertexID VertexID);
    void DeleteEdge(FEdgeID EdgeID, TArray<FVertexID>& OrphanedVertices);
    void DeletePolygon(FPolygonID PolygonID, TArray<FEdgeID>& OrphanedEdges, TArray<FVertexInstanceID>& OrphanedVertexInstances, TArray<FPolygonGroupID>& OrphanedPolygonGroups);
    void DeletePolygonGroup(FPolygonGroupID PolygonGroupID);
    void DeleteTriangle(FTriangleID TriangleID, TArray<FEdgeID>& OrphanedEdges, TArray<FVertexInstanceID>& OrphanedVertexInstances, TArray<FPolygonGroupID>& OrphanedPolygonGroupsPtr);
    void DeleteVertex(FVertexID VertexID);
    void DeleteVertexInstance(FVertexInstanceID VertexInstanceID, TArray<FVertexID>& OrphanedVertices);
    void Empty();
    void GetEdgeConnectedPolygons(FEdgeID EdgeID, TArray<FPolygonID>& OutConnectedPolygonIDs) const;
    void GetEdgeConnectedTriangles(FEdgeID EdgeID, TArray<FTriangleID>& OutConnectedTriangleIDs) const;
    int32_t GetEdgeCount() const;
    FVertexID GetEdgeVertex(FEdgeID EdgeID, int32_t VertexNumber) const;
    void GetEdgeVertices(const FEdgeID EdgeID, TArray<FVertexID>& OutVertexIDs) const;
    int32_t GetNumEdgeConnectedPolygons(FEdgeID EdgeID) const;
    int32_t GetNumEdgeConnectedTriangles(FEdgeID EdgeID) const;
    int32_t GetNumPolygonGroupPolygons(FPolygonGroupID PolygonGroupID) const;
    int32_t GetNumPolygonInternalEdges(FPolygonID PolygonID) const;
    int32_t GetNumPolygonTriangles(FPolygonID PolygonID) const;
    int32_t GetNumPolygonVertices(FPolygonID PolygonID) const;
    int32_t GetNumVertexConnectedEdges(FVertexID VertexID) const;
    int32_t GetNumVertexConnectedPolygons(FVertexID VertexID) const;
    int32_t GetNumVertexConnectedTriangles(FVertexID VertexID) const;
    int32_t GetNumVertexInstanceConnectedPolygons(FVertexInstanceID VertexInstanceID) const;
    int32_t GetNumVertexInstanceConnectedTriangles(FVertexInstanceID VertexInstanceID) const;
    int32_t GetNumVertexVertexInstances(FVertexID VertexID) const;
    void GetPolygonAdjacentPolygons(FPolygonID PolygonID, TArray<FPolygonID>& OutPolygonIDs) const;
    int32_t GetPolygonCount() const;
    int32_t GetPolygonGroupCount() const;
    void GetPolygonGroupPolygons(FPolygonGroupID PolygonGroupID, TArray<FPolygonID>& OutPolygonIDs) const;
    void GetPolygonInternalEdges(FPolygonID PolygonID, TArray<FEdgeID>& OutEdgeIDs) const;
    void GetPolygonPerimeterEdges(FPolygonID PolygonID, TArray<FEdgeID>& OutEdgeIDs) const;
    FPolygonGroupID GetPolygonPolygonGroup(FPolygonID PolygonID) const;
    void GetPolygonTriangles(FPolygonID PolygonID, TArray<FTriangleID>& OutTriangleIDs) const;
    void GetPolygonVertexInstances(FPolygonID PolygonID, TArray<FVertexInstanceID>& OutVertexInstanceIDs) const;
    void GetPolygonVertices(FPolygonID PolygonID, TArray<FVertexID>& OutVertexIDs) const;
    void GetTriangleAdjacentTriangles(FTriangleID TriangleID, TArray<FTriangleID>& OutTriangleIDs) const;
    int32_t GetTriangleCount() const;
    void GetTriangleEdges(FTriangleID TriangleID, TArray<FEdgeID>& OutEdgeIDs) const;
    FPolygonID GetTrianglePolygon(FTriangleID TriangleID) const;
    FPolygonGroupID GetTrianglePolygonGroup(FTriangleID TriangleID) const;
    FVertexInstanceID GetTriangleVertexInstance(FTriangleID TriangleID, int32_t Index) const;
    void GetTriangleVertexInstances(FTriangleID TriangleID, TArray<FVertexInstanceID>& OutVertexInstanceIDs) const;
    void GetTriangleVertices(FTriangleID TriangleID, TArray<FVertexID>& OutVertexIDs) const;
    void GetVertexAdjacentVertices(FVertexID VertexID, TArray<FVertexID>& OutAdjacentVertexIDs) const;
    void GetVertexConnectedEdges(FVertexID VertexID, TArray<FEdgeID>& OutEdgeIDs) const;
    void GetVertexConnectedPolygons(FVertexID VertexID, TArray<FPolygonID>& OutConnectedPolygonIDs) const;
    void GetVertexConnectedTriangles(FVertexID VertexID, TArray<FTriangleID>& OutConnectedTriangleIDs) const;
    int32_t GetVertexCount() const;
    void GetVertexInstanceConnectedPolygons(FVertexInstanceID VertexInstanceID, TArray<FPolygonID>& OutConnectedPolygonIDs) const;
    void GetVertexInstanceConnectedTriangles(FVertexInstanceID VertexInstanceID, TArray<FTriangleID>& OutConnectedTriangleIDs) const;
    int32_t GetVertexInstanceCount() const;
    FVertexInstanceID GetVertexInstanceForPolygonVertex(FPolygonID PolygonID, FVertexID VertexID) const;
    FVertexInstanceID GetVertexInstanceForTriangleVertex(FTriangleID TriangleID, FVertexID VertexID) const;
    FEdgeID GetVertexInstancePairEdge(FVertexInstanceID VertexInstanceID0, FVertexInstanceID VertexInstanceID1) const;
    FVertexID GetVertexInstanceVertex(FVertexInstanceID VertexInstanceID) const;
    FEdgeID GetVertexPairEdge(FVertexID VertexID0, FVertexID VertexID1) const;
    FVector GetVertexPosition(FVertexID VertexID) const;
    void GetVertexVertexInstances(FVertexID VertexID, TArray<FVertexInstanceID>& OutVertexInstanceIDs) const;
    bool IsEdgeInternal(FEdgeID EdgeID) const;
    bool IsEdgeInternalToPolygon(FEdgeID EdgeID, FPolygonID PolygonID) const;
    bool IsEdgeValid(FEdgeID EdgeID) const;
    bool IsEmpty() const;
    bool IsPolygonGroupValid(FPolygonGroupID PolygonGroupID) const;
    bool IsPolygonValid(FPolygonID PolygonID) const;
    bool IsTrianglePartOfNgon(FTriangleID TriangleID) const;
    bool IsTriangleValid(const FTriangleID TriangleID) const;
    bool IsVertexInstanceValid(FVertexInstanceID VertexInstanceID) const;
    bool IsVertexOrphaned(FVertexID VertexID) const;
    bool IsVertexValid(FVertexID VertexID) const;
    void ReserveNewEdges(int32_t NumberOfNewEdges);
    void ReserveNewPolygonGroups(int32_t NumberOfNewPolygonGroups);
    void ReserveNewPolygons(const int32_t NumberOfNewPolygons);
    void ReserveNewTriangles(int32_t NumberOfNewTriangles);
    void ReserveNewVertexInstances(int32_t NumberOfNewVertexInstances);
    void ReserveNewVertices(int32_t NumberOfNewVertices);
    void ReversePolygonFacing(FPolygonID PolygonID);
    void SetPolygonPolygonGroup(FPolygonID PolygonID, FPolygonGroupID PolygonGroupID);
    void SetPolygonVertexInstances(FPolygonID PolygonID, const TArray<FVertexInstanceID>& VertexInstanceIDs);
    void SetVertexPosition(FVertexID VertexID, const FVector& position);
};

// Size: 0x28
class UMeshDescriptionBaseBulkData : public UObject {
};

// Size: 0x4
struct FPolygonGroupID : public FElementID {
};

// Size: 0x4
struct FPolygonID : public FElementID {
};

// Size: 0x4
struct FTriangleID : public FElementID {
};

// Size: 0x4
struct FUVID : public FElementID {
};

// Size: 0x4
struct FVertexID : public FElementID {
};

// Size: 0x4
struct FVertexInstanceID : public FElementID {
};

enum class EBodyTextureType {
    Body_Basecolor = 0,
    Body_Normal = 1,
    Body_Cavity = 2,
    Body_Underwear_Basecolor = 3,
    Body_Underwear_Normal = 4,
    Body_Underwear_Mask = 5,
    Chest_Basecolor = 6,
    Chest_Normal = 7,
    Chest_Cavity = 8,
    Chest_Underwear_Basecolor = 9,
    Chest_Underwear_Normal = 10,
    Count = 11,
    EBodyTextureType_MAX = 12,
};

enum class EFaceTextureType {
    Basecolor = 0,
    Basecolor_Animated_CM1 = 1,
    Basecolor_Animated_CM2 = 2,
    Basecolor_Animated_CM3 = 3,
    Normal = 4,
    Normal_Animated_WM1 = 5,
    Normal_Animated_WM2 = 6,
    Normal_Animated_WM3 = 7,
    Cavity = 8,
    Count = 9,
    EFaceTextureType_MAX = 10,
};

enum class EMetaHumanBodyBodyPartIndex {
    Body = 0,
    Face = 1,
    Torso = 2,
    Legs = 3,
    Feet = 4,
    Count = 5,
    EMetaHumanBodyBodyPartIndex_MAX = 6,
};

enum class EMetaHumanBodyType {
    f_med_nrw = 0,
    f_med_ovw = 1,
    f_med_unw = 2,
    f_srt_nrw = 3,
    f_srt_ovw = 4,
    f_srt_unw = 5,
    f_tal_nrw = 6,
    f_tal_ovw = 7,
    f_tal_unw = 8,
    m_med_nrw = 9,
    m_med_ovw = 10,
    m_med_unw = 11,
    m_srt_nrw = 12,
    m_srt_ovw = 13,
    m_srt_unw = 14,
    m_tal_nrw = 15,
    m_tal_ovw = 16,
    m_tal_unw = 17,
    BlendableBody = 18,
    Count = 19,
    EMetaHumanBodyType_MAX = 20,
};

enum class EMetaHumanQualityLevel {
    Low = 0,
    Medium = 1,
    High = 2,
    Cinematic = 3,
    Count = 4,
    EMetaHumanQualityLevel_MAX = 5,
};

// Size: 0x188
class UMetaHumanComponentBase : public UActorComponent {
    /* 0x00b8 */ FString BodyComponentName;
    /* 0x00c8 */ EMetaHumanBodyType BodyType;
    /* 0x00c9 */ bool bEnableBodyCorrectives;
    /* 0x00d0 */ FString FaceComponentName;
    /* 0x00e0 */ int32_t RigLogicLODThreshold;
    /* 0x00e4 */ bool bEnableNeckCorrectives;
    /* 0x00e8 */ int32_t NeckCorrectivesLODThreshold;
    /* 0x00ec */ bool bEnableNeckProcControlRig;
    /* 0x00f0 */ int32_t NeckProcControlRigLODThreshold;
    /* 0x00f8 */ FMetaHumanCustomizableBodyPart Torso;
    /* 0x0128 */ FMetaHumanCustomizableBodyPart Legs;
    /* 0x0158 */ FMetaHumanCustomizableBodyPart Feet;
};

// Size: 0x1b0
class UMetaHumanComponentUE : public UMetaHumanComponentBase {
    /* 0x0188 */ TSoftClassPtr<UAnimInstance> PostProcessAnimBP;
};

// Size: 0x30
struct FMetaHumanCustomizableBodyPart {
    /* 0x0000 */ UClass* ControlRigClass;
    /* 0x0008 */ int32_t ControlRigLODThreshold;
    /* 0x0010 */ UPhysicsAsset* PhysicsAsset;
    /* 0x0018 */ int32_t RigidBodyLODThreshold;
    /* 0x0020 */ FString ComponentName;
};

// Size: 0x20
struct FDefaultMetaSoundAssetAutoUpdateSettings {
    /* 0x0000 */ FSoftObjectPath MetaSound;
};

enum class EMetaSoundBuilderResult {
    Succeeded = 0,
    Failed = 1,
    EMetaSoundBuilderResult_MAX = 2,
};

enum class EMetaSoundMessageLevel {
    Error = 0,
    Warning = 1,
    Info = 2,
    EMetaSoundMessageLevel_MAX = 3,
};

enum class EMetaSoundOutputAudioFormat {
    Mono = 0,
    Stereo = 1,
    Quad = 2,
    FiveDotOne = 3,
    SevenDotOne = 4,
    COUNT = 5,
    EMetaSoundOutputAudioFormat_MAX = 6,
};

// Size: 0x10
struct FMetaSoundAssetDirectory {
    /* 0x0000 */ FDirectoryPath Directory;
};

// Size: 0x30
class UMetaSoundAssetSubsystem : public UEngineSubsystem {

    void RegisterAssetClassesInDirectories(const TArray<FMetaSoundAssetDirectory>& Directories);
    void UnregisterAssetClassesInDirectories(const TArray<FMetaSoundAssetDirectory>& Directories);
};

// Size: 0x30
struct FMetaSoundAsyncAssetDependencies {
    /* 0x0008 */ UObject* MetaSound;
};

// Size: 0xa0
class UMetaSoundBuilderBase : public UObject {
    /* 0x0028 */ FMetaSoundFrontendDocumentBuilder Builder;

    FMetaSoundBuilderNodeOutputHandle AddGraphInputNode(FName Name, FName DataType, FMetasoundFrontendLiteral DefaultValue, EMetaSoundBuilderResult& OutResult, bool bIsConstructorInput);
    FMetaSoundBuilderNodeInputHandle AddGraphOutputNode(FName Name, FName DataType, FMetasoundFrontendLiteral DefaultValue, EMetaSoundBuilderResult& OutResult, bool bIsConstructorOutput);
    void AddGraphVariable(FName Name, FName DataType, FMetasoundFrontendLiteral DefaultValue, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle AddGraphVariableGetDelayedNode(FName Name, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle AddGraphVariableGetNode(FName Name, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle AddGraphVariableSetNode(FName Name, EMetaSoundBuilderResult& OutResult);
    void AddInterface(FName InterfaceName, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle AddNode(const TScriptInterface<IMetaSoundDocumentInterface>& NodeClass, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle AddNodeByClassName(const FMetasoundFrontendClassName& ClassName, EMetaSoundBuilderResult& OutResult, int32_t MajorVersion);
    TScriptInterface<IMetaSoundDocumentInterface> Build(UObject* Parent, const FMetaSoundBuilderOptions& Options) const;
    void BuildAndOverwriteMetaSound(TScriptInterface<IMetaSoundDocumentInterface> ExistingMetaSound, bool bForceUniqueClassName);
    TScriptInterface<IMetaSoundDocumentInterface> BuildNewMetaSound(FName NameBase) const;
    void ConnectNodeInputToGraphInput(FName GraphInputName, const FMetaSoundBuilderNodeInputHandle& NodeInputHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeOutputHandle> ConnectNodeInputsToMatchingGraphInterfaceInputs(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult);
    void ConnectNodeOutputToGraphOutput(FName GraphOutputName, const FMetaSoundBuilderNodeOutputHandle& NodeOutputHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeInputHandle> ConnectNodeOutputsToMatchingGraphInterfaceOutputs(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult);
    void ConnectNodes(const FMetaSoundBuilderNodeOutputHandle& NodeOutputHandle, const FMetaSoundBuilderNodeInputHandle& NodeInputHandle, EMetaSoundBuilderResult& OutResult);
    void ConnectNodesByInterfaceBindings(const FMetaSoundNodeHandle& FromNodeHandle, const FMetaSoundNodeHandle& ToNodeHandle, EMetaSoundBuilderResult& OutResult);
    bool ContainsNode(const FMetaSoundNodeHandle& Node) const;
    bool ContainsNodeInput(const FMetaSoundBuilderNodeInputHandle& Input) const;
    bool ContainsNodeOutput(const FMetaSoundBuilderNodeOutputHandle& Output) const;
    void ConvertFromPreset(EMetaSoundBuilderResult& OutResult);
    void ConvertToPreset(const TScriptInterface<IMetaSoundDocumentInterface>& ReferencedNodeClass, EMetaSoundBuilderResult& OutResult);
    void DisconnectNodeInput(const FMetaSoundBuilderNodeInputHandle& NodeInputHandle, EMetaSoundBuilderResult& OutResult);
    void DisconnectNodeOutput(const FMetaSoundBuilderNodeOutputHandle& NodeOutputHandle, EMetaSoundBuilderResult& OutResult);
    void DisconnectNodes(const FMetaSoundBuilderNodeOutputHandle& NodeOutputHandle, const FMetaSoundBuilderNodeInputHandle& NodeInputHandle, EMetaSoundBuilderResult& OutResult);
    void DisconnectNodesByInterfaceBindings(const FMetaSoundNodeHandle& FromNodeHandle, const FMetaSoundNodeHandle& ToNodeHandle, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle FindGraphInputNode(FName InputName, FName& OutDataType, FMetaSoundBuilderNodeOutputHandle& NodeOutputHandle, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle FindGraphOutputNode(FName OutputName, FName& OutDataType, FMetaSoundBuilderNodeInputHandle& NodeInputHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundNodeHandle> FindInterfaceInputNodes(FName InterfaceName, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundNodeHandle> FindInterfaceOutputNodes(FName InterfaceName, EMetaSoundBuilderResult& OutResult);
    FMetasoundFrontendVersion FindNodeClassVersion(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult);
    FMetaSoundBuilderNodeInputHandle FindNodeInputByName(const FMetaSoundNodeHandle& NodeHandle, FName InputName, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle FindNodeInputParent(const FMetaSoundBuilderNodeInputHandle& InputHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeInputHandle> FindNodeInputs(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeInputHandle> FindNodeInputsByDataType(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult, FName DataType);
    FMetaSoundBuilderNodeOutputHandle FindNodeOutputByName(const FMetaSoundNodeHandle& NodeHandle, FName OutputName, EMetaSoundBuilderResult& OutResult);
    FMetaSoundNodeHandle FindNodeOutputParent(const FMetaSoundBuilderNodeOutputHandle& OutputHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeOutputHandle> FindNodeOutputs(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult);
    TArray<FMetaSoundBuilderNodeOutputHandle> FindNodeOutputsByDataType(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult, FName DataType);
    FMetasoundFrontendLiteral GetGraphInputDefault(FName InputName, EMetaSoundBuilderResult& OutResult) const;
    TArray<FName> GetGraphInputNames(EMetaSoundBuilderResult& OutResult) const;
    TArray<FName> GetGraphOutputNames(EMetaSoundBuilderResult& OutResult) const;
    FMetasoundFrontendLiteral GetGraphVariableDefault(FName VariableName, EMetaSoundBuilderResult& OutResult) const;
    FMetasoundFrontendLiteral GetNodeInputClassDefault(const FMetaSoundBuilderNodeInputHandle& InputHandle, EMetaSoundBuilderResult& OutResult);
    void GetNodeInputData(const FMetaSoundBuilderNodeInputHandle& InputHandle, FName& Name, FName& DataType, EMetaSoundBuilderResult& OutResult);
    FMetasoundFrontendLiteral GetNodeInputDefault(const FMetaSoundBuilderNodeInputHandle& InputHandle, EMetaSoundBuilderResult& OutResult);
    bool GetNodeInputIsConstructorPin(const FMetaSoundBuilderNodeInputHandle& InputHandle) const;
    void GetNodeOutputData(const FMetaSoundBuilderNodeOutputHandle& OutputHandle, FName& Name, FName& DataType, EMetaSoundBuilderResult& OutResult);
    bool GetNodeOutputIsConstructorPin(const FMetaSoundBuilderNodeOutputHandle& OutputHandle) const;
    UObject* GetReferencedPresetAsset() const;
    FMetasoundFrontendClassName GetRootGraphClassName() const;
    bool InterfaceIsDeclared(FName InterfaceName) const;
    bool IsPreset() const;
    bool NodeInputIsConnected(const FMetaSoundBuilderNodeInputHandle& InputHandle) const;
    bool NodeOutputIsConnected(const FMetaSoundBuilderNodeOutputHandle& OutputHandle) const;
    bool NodesAreConnected(const FMetaSoundBuilderNodeOutputHandle& OutputHandle, const FMetaSoundBuilderNodeInputHandle& InputHandle) const;
    void RemoveGraphInput(FName Name, EMetaSoundBuilderResult& OutResult);
    void RemoveGraphOutput(FName Name, EMetaSoundBuilderResult& OutResult);
    void RemoveGraphVariable(FName Name, EMetaSoundBuilderResult& OutResult);
    void RemoveInterface(FName InterfaceName, EMetaSoundBuilderResult& OutResult);
    void RemoveNode(const FMetaSoundNodeHandle& NodeHandle, EMetaSoundBuilderResult& OutResult, bool bRemoveUnusedDependencies);
    void RemoveNodeInputDefault(const FMetaSoundBuilderNodeInputHandle& InputHandle, EMetaSoundBuilderResult& OutResult);
    void RemoveUnusedDependencies();
    void SetGraphInputAccessType(FName InputName, EMetasoundFrontendVertexAccessType AccessType, EMetaSoundBuilderResult& OutResult);
    void SetGraphInputDataType(FName InputName, FName DataType, EMetaSoundBuilderResult& OutResult);
    void SetGraphInputDefault(FName InputName, const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    void SetGraphInputName(FName InputName, FName NewName, EMetaSoundBuilderResult& OutResult);
    void SetGraphOutputAccessType(FName OutputName, EMetasoundFrontendVertexAccessType AccessType, EMetaSoundBuilderResult& OutResult);
    void SetGraphOutputDataType(FName OutputName, FName DataType, EMetaSoundBuilderResult& OutResult);
    void SetGraphOutputName(FName OutputName, FName NewName, EMetaSoundBuilderResult& OutResult);
    void SetNodeInputDefault(const FMetaSoundBuilderNodeInputHandle& NodeInputHandle, const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
};

// Size: 0x20
struct FMetaSoundBuilderNodeInputHandle : public FMetasoundFrontendVertexHandle {
};

// Size: 0x20
struct FMetaSoundBuilderNodeOutputHandle : public FMetasoundFrontendVertexHandle {
};

// Size: 0x20
struct FMetaSoundBuilderOptions {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ bool bForceUniqueClassName;
    /* 0x0009 */ bool bAddToRegistry;
    /* 0x0010 */ TScriptInterface<IMetaSoundDocumentInterface> ExistingMetaSound;
};

// Size: 0x80
class UMetaSoundBuilderSubsystem : public UEngineSubsystem {
    /* 0x0030 */ TMap<FName, UMetaSoundBuilderBase*> NamedBuilders;

    FMetasoundFrontendLiteral CreateBoolArrayMetaSoundLiteral(const TArray<bool>& Value, FName& DataType);
    FMetasoundFrontendLiteral CreateBoolMetaSoundLiteral(bool Value, FName& DataType);
    FMetasoundFrontendLiteral CreateFloatArrayMetaSoundLiteral(const TArray<float>& Value, FName& DataType);
    FMetasoundFrontendLiteral CreateFloatMetaSoundLiteral(float Value, FName& DataType);
    FMetasoundFrontendLiteral CreateIntArrayMetaSoundLiteral(const TArray<int32_t>& Value, FName& DataType);
    FMetasoundFrontendLiteral CreateIntMetaSoundLiteral(int32_t Value, FName& DataType);
    FMetasoundFrontendLiteral CreateMetaSoundLiteralFromParam(const FAudioParameter& Param);
    FMetasoundFrontendLiteral CreateObjectArrayMetaSoundLiteral(const TArray<UObject*>& Value);
    FMetasoundFrontendLiteral CreateObjectMetaSoundLiteral(UObject* Value);
    UMetaSoundPatchBuilder* CreatePatchBuilder(FName BuilderName, EMetaSoundBuilderResult& OutResult);
    UMetaSoundPatchBuilder* CreatePatchPresetBuilder(FName BuilderName, const TScriptInterface<IMetaSoundDocumentInterface>& ReferencedPatchClass, EMetaSoundBuilderResult& OutResult);
    UMetaSoundSourceBuilder* CreateSourceBuilder(FName BuilderName, FMetaSoundBuilderNodeOutputHandle& OnPlayNodeOutput, FMetaSoundBuilderNodeInputHandle& OnFinishedNodeInput, TArray<FMetaSoundBuilderNodeInputHandle>& AudioOutNodeInputs, EMetaSoundBuilderResult& OutResult, EMetaSoundOutputAudioFormat OutputFormat, bool bIsOneShot);
    UMetaSoundSourceBuilder* CreateSourcePresetBuilder(FName BuilderName, const TScriptInterface<IMetaSoundDocumentInterface>& ReferencedSourceClass, EMetaSoundBuilderResult& OutResult);
    FMetasoundFrontendLiteral CreateStringArrayMetaSoundLiteral(const TArray<FString>& Value, FName& DataType);
    FMetasoundFrontendLiteral CreateStringMetaSoundLiteral(FString Value, FName& DataType);
    UMetaSoundBuilderBase* FindBuilder(FName BuilderName);
    UMetaSoundBuilderBase* FindBuilderOfDocument(TScriptInterface<IMetaSoundDocumentInterface> InMetaSound) const;
    UMetaSoundPatchBuilder* FindPatchBuilder(FName BuilderName);
    UMetaSoundSourceBuilder* FindSourceBuilder(FName BuilderName);
    bool IsInterfaceRegistered(FName InInterfaceName) const;
    void RegisterBuilder(FName BuilderName, UMetaSoundBuilderBase* Builder);
    void RegisterPatchBuilder(FName BuilderName, UMetaSoundPatchBuilder* Builder);
    void RegisterSourceBuilder(FName BuilderName, UMetaSoundSourceBuilder* Builder);
    bool SetTargetPage(FName pageName);
    bool UnregisterBuilder(FName BuilderName);
    bool UnregisterPatchBuilder(FName BuilderName);
    bool UnregisterSourceBuilder(FName BuilderName);
};

// Size: 0x78
class UMetaSoundCacheSubsystem : public UAudioEngineSubsystem {

    void PrecacheMetaSound(UMetaSoundSource* InMetaSound, int32_t InNumInstances);
    void RemoveCachedOperatorsForMetaSound(UMetaSoundSource* InMetaSound);
    void TouchOrPrecacheMetaSound(UMetaSoundSource* InMetaSound, int32_t InNumInstances);
};

// Size: 0x10
struct FMetaSoundNodeHandle {
    /* 0x0000 */ FGuid NodeID;
};

// Size: 0x10
struct FMetaSoundOutput : public FSoundGeneratorOutput {
};

// Size: 0x40
class UMetaSoundOutputSubsystem : public UWorldSubsystem {

    bool UnwatchOutput(UAudioComponent* AudioComponent, FName OutputName, const FDelegate& OnOutputValueChanged, FName AnalyzerName, FName AnalyzerOutputName);
    bool WatchOutput(UAudioComponent* AudioComponent, FName OutputName, const FDelegate& OnOutputValueChanged, FName AnalyzerName, FName AnalyzerOutputName);
};

// Size: 0x18
struct FMetaSoundPageSettings {
    /* 0x0000 */ FGuid UniqueID;
    /* 0x0010 */ FName Name;
};

// Size: 0x2f8
class UMetaSoundPatch : public UObject {
    /* 0x0070 */ FMetasoundFrontendDocument RootMetaSoundDocument;
    /* 0x0200 */ TSet<FString> ReferencedAssetClassKeys;
    /* 0x0250 */ TSet<UObject*> ReferencedAssetClassObjects;
    /* 0x02a0 */ TSet<FSoftObjectPath> ReferenceAssetClassCache;
};

// Size: 0xa0
class UMetaSoundPatchBuilder : public UMetaSoundBuilderBase {
};

// Size: 0x28
class UMetaSoundQualityHelper : public UObject {

    static TArray<FName> GetQualityNames();
};

// Size: 0x20
struct FMetaSoundQualitySettings {
    /* 0x0000 */ FGuid UniqueID;
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FPerPlatformInt SampleRate;
    /* 0x001c */ FPerPlatformFloat BlockRate;
};

// Size: 0xc8
class UMetaSoundSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bAutoUpdateEnabled;
    /* 0x0040 */ TArray<FMetasoundFrontendClassName> AutoUpdateDenylist;
    /* 0x0050 */ TArray<FDefaultMetaSoundAssetAutoUpdateSettings> AutoUpdateAssetDenylist;
    /* 0x0060 */ bool bAutoUpdateLogWarningOnDroppedConnection;
    /* 0x0068 */ TArray<FDirectoryPath> DirectoriesToRegister;
    /* 0x0078 */ int32_t DenyListCacheChangeID;
    /* 0x007c */ FName TargetPageName;
    /* 0x0084 */ FMetaSoundPageSettings DefaultPageSettings;
    /* 0x00a0 */ TArray<FMetaSoundPageSettings> PageSettings;
    /* 0x00b0 */ TArray<FMetaSoundQualitySettings> QualitySettings;
};

// Size: 0x890
class UMetaSoundSource : public USoundWaveProcedural {
    /* 0x0498 */ FMetasoundFrontendDocument RootMetaSoundDocument;
    /* 0x0628 */ TSet<FString> ReferencedAssetClassKeys;
    /* 0x0678 */ TSet<UObject*> ReferencedAssetClassObjects;
    /* 0x06c8 */ TSet<FSoftObjectPath> ReferenceAssetClassCache;
    /* 0x0718 */ EMetaSoundOutputAudioFormat OutputFormat;
};

// Size: 0xc8
class UMetaSoundSourceBuilder : public UMetaSoundBuilderBase {

    void Audition(UObject* Parent, UAudioComponent* AudioComponent, FDelegate OnCreateGenerator, bool bLiveUpdatesEnabled);
    bool GetLiveUpdatesEnabled() const;
    void SetBlockRateOverride(float BlockRate);
    void SetFormat(EMetaSoundOutputAudioFormat OutputFormat, EMetaSoundBuilderResult& OutResult);
    void SetQuality(FName Quality);
    void SetSampleRateOverride(int32_t SampleRate);
};

// Size: 0x60
class UMetasoundEditorGraphBase : public UEdGraph {
};

// Size: 0x28
class UMetasoundFrontendLiteralBlueprintAccess : public UBlueprintFunctionLibrary {

    static FString Conv_MetaSoundLiteralToString(const FMetasoundFrontendLiteral& Literal);
    static FMetasoundFrontendLiteral CreateBoolArrayMetaSoundLiteral(const TArray<bool>& Value);
    static FMetasoundFrontendLiteral CreateBoolMetaSoundLiteral(bool Value);
    static FMetasoundFrontendLiteral CreateFloatArrayMetaSoundLiteral(const TArray<float>& Value);
    static FMetasoundFrontendLiteral CreateFloatMetaSoundLiteral(float Value);
    static FMetasoundFrontendLiteral CreateIntArrayMetaSoundLiteral(const TArray<int32_t>& Value);
    static FMetasoundFrontendLiteral CreateIntMetaSoundLiteral(int32_t Value);
    static FMetasoundFrontendLiteral CreateMetaSoundLiteralFromParam(const FAudioParameter& Param);
    static FMetasoundFrontendLiteral CreateObjectArrayMetaSoundLiteral(const TArray<UObject*>& Value);
    static FMetasoundFrontendLiteral CreateObjectMetaSoundLiteral(UObject* Value);
    static FMetasoundFrontendLiteral CreateStringArrayMetaSoundLiteral(const TArray<FString>& Value);
    static FMetasoundFrontendLiteral CreateStringMetaSoundLiteral(FString Value);
    static TArray<bool> GetBoolArrayValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static bool GetBoolValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static TArray<float> GetFloatArrayValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static float GetFloatValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static TArray<int32_t> GetIntArrayValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static int32_t GetIntValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static TArray<UObject*> GetObjectArrayValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static UObject* GetObjectValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static TArray<FString> GetStringArrayValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static FString GetStringValueFromLiteral(const FMetasoundFrontendLiteral& Literal, EMetaSoundBuilderResult& OutResult);
    static EMetasoundFrontendLiteralType GetType(const FMetasoundFrontendLiteral& Literal);
};

// Size: 0xb0
class UMetasoundGeneratorHandle : public UObject {

    bool ApplyParameterPack(UMetasoundParameterPack* Pack);
    static UMetasoundGeneratorHandle* CreateMetaSoundGeneratorHandle(UAudioComponent* OnComponent);
    void EnableRuntimeRenderTiming(bool Enable) const;
    double GetCPUCoreUtilization() const;
    void UpdateWatchers() const;
    bool WatchOutput(FName OutputName, const FDelegate& OnOutputValueChanged, FName AnalyzerName, FName AnalyzerOutputName);
};

// Size: 0x28
class UMetasoundOutputBlueprintAccess : public UBlueprintFunctionLibrary {

    static bool GetBool(const FMetaSoundOutput& Output, bool& success);
    static float GetFloat(const FMetaSoundOutput& Output, bool& success);
    static int32_t GetInt32(const FMetaSoundOutput& Output, bool& success);
    static FString GetString(const FMetaSoundOutput& Output, bool& success);
    static double GetTimeSeconds(const FMetaSoundOutput& Output, bool& success);
    static bool IsBool(const FMetaSoundOutput& Output);
    static bool IsFloat(const FMetaSoundOutput& Output);
    static bool IsInt32(const FMetaSoundOutput& Output);
    static bool IsString(const FMetaSoundOutput& Output);
    static bool IsTime(const FMetaSoundOutput& Output);
};

enum class EMetaSoundFrontendGraphCommentMoveMode {
    GroupMovement = 0,
    NoGroupMovement = 1,
    EMetaSoundFrontendGraphCommentMoveMode_MAX = 2,
};

enum class EMetasoundFrontendClassType {
    External = 0,
    Graph = 1,
    Input = 2,
    Output = 3,
    Literal = 4,
    Variable = 5,
    VariableDeferredAccessor = 6,
    VariableAccessor = 7,
    VariableMutator = 8,
    Template = 9,
    Invalid = 10,
    EMetasoundFrontendClassType_MAX = 11,
};

enum class EMetasoundFrontendLiteralType {
    None = 0,
    Boolean = 1,
    Integer = 2,
    Float = 3,
    String = 4,
    UObject = 5,
    NoneArray = 6,
    BooleanArray = 7,
    IntegerArray = 8,
    FloatArray = 9,
    StringArray = 10,
    UObjectArray = 11,
    Invalid = 12,
    EMetasoundFrontendLiteralType_MAX = 13,
};

enum class EMetasoundFrontendNodeStyleDisplayVisibility {
    Visible = 0,
    Hidden = 1,
    EMetasoundFrontendNodeStyleDisplayVisibility_MAX = 2,
};

enum class EMetasoundFrontendVertexAccessType {
    Reference = 0,
    Value = 1,
    Unset = 2,
    EMetasoundFrontendVertexAccessType_MAX = 3,
};

enum class ESetParamResult {
    Succeeded = 0,
    Failed = 1,
    ESetParamResult_MAX = 2,
};

// Size: 0x20
struct FMetaSoundAssetKey {
    /* 0x0000 */ FMetasoundFrontendClassName ClassName;
    /* 0x0018 */ FMetasoundFrontendVersionNumber Version;
};

// Size: 0x1
struct FMetaSoundAssetTagClassCollections {
};

// Size: 0x1
struct FMetaSoundAssetTagCollections {
};

// Size: 0x1d0
class UMetaSoundBuilderDocument : public UObject {
    /* 0x0030 */ FMetasoundFrontendDocument Document;
    /* 0x01c0 */ UClass* MetaSoundUClass;
    /* 0x01c8 */ UClass* BuilderUClass;
};

// Size: 0x80
struct FMetaSoundClassInterfaceInfo {
    /* 0x0000 */ TArray<FMetasoundFrontendInterfaceMetadata> DefinedInterfaces;
    /* 0x0010 */ FMetaSoundClassSearchInfo SearchInfo;
    /* 0x0050 */ TArray<FMetaSoundClassVertexInfo> Inputs;
    /* 0x0060 */ TArray<FMetaSoundClassVertexInfo> Outputs;
    /* 0x0070 */ TArray<FMetasoundFrontendVersion> InheritedInterfaces;
};

// Size: 0x40
struct FMetaSoundClassSearchInfo {
    /* 0x0000 */ FText ClassDisplayName;
    /* 0x0010 */ FText ClassDescription;
    /* 0x0020 */ TArray<FText> Hierarchy;
    /* 0x0030 */ TArray<FText> Keywords;
};

// Size: 0x10
struct FMetaSoundClassVertexCollectionInfo {
    /* 0x0000 */ TArray<FMetaSoundClassVertexInfo> ClassVertexInfo;
};

// Size: 0x14
struct FMetaSoundClassVertexInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName TypeName;
    /* 0x0010 */ EMetasoundFrontendVertexAccessType AccessType;
};

// Size: 0x20
struct FMetaSoundDocumentInfo {
    /* 0x0000 */ FMetasoundFrontendVersionNumber DocumentVersion;
    /* 0x0008 */ TArray<FMetaSoundAssetKey> ReferencedAssetKeys;
    /* 0x0018 */ bool bIsPreset;
};

// Size: 0x28
class IMetaSoundDocumentInterface : public UInterface {
};

// Size: 0x58
struct FMetaSoundFrontendDocumentBuilder {
    /* 0x0008 */ TScriptInterface<IMetaSoundDocumentInterface> DocumentInterface;
    /* 0x0018 */ FGuid BuildPageID;
};

// Size: 0x1
struct FMetaSoundFrontendGraphComment {
};

// Size: 0x28
class UMetaSoundFrontendMemberMetadata : public UObject {
};

// Size: 0x8
struct FMetaSoundFrontendNodeConfiguration {
};

// Size: 0x8
struct FMetasoundCommentNodeIntVector : public FIntVector2 {
};

// Size: 0x90
struct FMetasoundFrontendClass {
    /* 0x0008 */ FGuid ID;
    /* 0x0018 */ FMetasoundFrontendClassMetadata MetaData;
    /* 0x0050 */ FMetasoundFrontendClassInterface Interface;
};

// Size: 0x14
struct FMetasoundFrontendClassEnvironmentVariable {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName TypeName;
    /* 0x0010 */ bool bIsRequired;
};

// Size: 0x48
struct FMetasoundFrontendClassInput : public FMetasoundFrontendClassVertex {
    /* 0x0038 */ TArray<FMetasoundFrontendClassInputDefault> Defaults;
};

// Size: 0x68
struct FMetasoundFrontendClassInputDefault {
    /* 0x0000 */ FMetasoundFrontendLiteral Literal;
    /* 0x0058 */ FGuid PageID;
};

// Size: 0x40
struct FMetasoundFrontendClassInterface {
    /* 0x0000 */ TArray<FMetasoundFrontendClassInput> Inputs;
    /* 0x0010 */ TArray<FMetasoundFrontendClassOutput> Outputs;
    /* 0x0020 */ TArray<FMetasoundFrontendClassEnvironmentVariable> Environment;
    /* 0x0030 */ FGuid ChangeID;
};

// Size: 0x34
struct FMetasoundFrontendClassMetadata {
    /* 0x0000 */ FMetasoundFrontendClassName ClassName;
    /* 0x0018 */ FMetasoundFrontendVersionNumber Version;
    /* 0x0020 */ EMetasoundFrontendClassType Type;
    /* 0x0021 */ bool bIsDeprecated;
    /* 0x0024 */ FGuid ChangeID;
};

// Size: 0x18
struct FMetasoundFrontendClassName {
    /* 0x0000 */ FName Namespace;
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName Variant;
};

// Size: 0x34
struct FMetasoundFrontendClassOutput : public FMetasoundFrontendClassVertex {
};

// Size: 0x1
struct FMetasoundFrontendClassStyle {
};

// Size: 0x1
struct FMetasoundFrontendClassStyleDisplay {
};

// Size: 0x90
struct FMetasoundFrontendClassVariable : public FMetasoundFrontendClassVertex {
    /* 0x0038 */ FMetasoundFrontendLiteral DefaultLiteral;
};

// Size: 0x34
struct FMetasoundFrontendClassVertex : public FMetasoundFrontendVertex {
    /* 0x0020 */ FGuid NodeID;
    /* 0x0030 */ EMetasoundFrontendVertexAccessType AccessType;
};

// Size: 0x190
struct FMetasoundFrontendDocument {
    /* 0x0010 */ FMetasoundFrontendDocumentMetadata MetaData;
    /* 0x0020 */ TSet<FMetasoundFrontendVersion> Interfaces;
    /* 0x0070 */ FMetasoundFrontendGraphClass RootGraph;
    /* 0x0168 */ TArray<FMetasoundFrontendGraphClass> Subgraphs;
    /* 0x0178 */ TArray<FMetasoundFrontendClass> Dependencies;
    /* 0x0188 */ uint32_t IDCounter;
};

// Size: 0x10
struct FMetasoundFrontendDocumentMetadata {
    /* 0x0000 */ FMetasoundFrontendVersion Version;
};

// Size: 0x40
struct FMetasoundFrontendEdge {
    /* 0x0000 */ FGuid FromNodeID;
    /* 0x0010 */ FGuid FromVertexID;
    /* 0x0020 */ FGuid ToNodeID;
    /* 0x0030 */ FGuid ToVertexID;
};

// Size: 0x28
struct FMetasoundFrontendEdgeStyle {
    /* 0x0000 */ FGuid NodeID;
    /* 0x0010 */ FName OutputName;
    /* 0x0018 */ TArray<FMetasoundFrontendEdgeStyleLiteralColorPair> LiteralColorPairs;
};

// Size: 0x68
struct FMetasoundFrontendEdgeStyleLiteralColorPair {
    /* 0x0000 */ FMetasoundFrontendLiteral Value;
    /* 0x0058 */ FLinearColor Color;
};

// Size: 0x40
struct FMetasoundFrontendGraph {
    /* 0x0000 */ TArray<FMetasoundFrontendNode> Nodes;
    /* 0x0010 */ TArray<FMetasoundFrontendEdge> Edges;
    /* 0x0020 */ TArray<FMetasoundFrontendVariable> Variables;
    /* 0x0030 */ FGuid PageID;
};

// Size: 0xf8
struct FMetasoundFrontendGraphClass : public FMetasoundFrontendClass {
    /* 0x0090 */ TArray<FMetasoundFrontendGraph> PagedGraphs;
    /* 0x00a0 */ FMetasoundFrontendGraphClassPresetOptions PresetOptions;
};

// Size: 0x58
struct FMetasoundFrontendGraphClassPresetOptions {
    /* 0x0000 */ bool bIsPreset;
    /* 0x0008 */ TSet<FName> InputsInheritingDefault;
};

// Size: 0x1
struct FMetasoundFrontendGraphStyle {
};

// Size: 0x60
struct FMetasoundFrontendInterface : public FMetasoundFrontendClassInterface {
    /* 0x0040 */ FMetasoundFrontendInterfaceMetadata MetaData;
};

// Size: 0x38
struct FMetasoundFrontendInterfaceBinding {
    /* 0x0000 */ FMetasoundFrontendVersion OutputInterfaceVersion;
    /* 0x0010 */ FMetasoundFrontendVersion InputInterfaceVersion;
    /* 0x0020 */ int32_t BindingPriority;
    /* 0x0028 */ TArray<FMetasoundFrontendInterfaceVertexBinding> VertexBindings;
};

// Size: 0x20
struct FMetasoundFrontendInterfaceMetadata {
    /* 0x0000 */ FMetasoundFrontendVersion Version;
    /* 0x0010 */ TArray<FMetasoundFrontendInterfaceUClassOptions> UClassOptions;
};

// Size: 0x1
struct FMetasoundFrontendInterfaceStyle {
};

// Size: 0x14
struct FMetasoundFrontendInterfaceUClassOptions {
    /* 0x0000 */ FTopLevelAssetPath ClassPath;
    /* 0x0010 */ bool bIsModifiable;
    /* 0x0011 */ bool bIsDefault;
};

// Size: 0x10
struct FMetasoundFrontendInterfaceVertexBinding {
    /* 0x0000 */ FName OutputName;
    /* 0x0008 */ FName InputName;
};

// Size: 0x58
struct FMetasoundFrontendLiteral {
    /* 0x0000 */ EMetasoundFrontendLiteralType Type;
    /* 0x0004 */ int32_t AsNumDefault;
    /* 0x0008 */ TArray<bool> AsBoolean;
    /* 0x0018 */ TArray<int32_t> AsInteger;
    /* 0x0028 */ TArray<float> AsFloat;
    /* 0x0038 */ TArray<FString> asString;
    /* 0x0048 */ TArray<UObject*> AsUObject;
};

// Size: 0x88
struct FMetasoundFrontendNode {
    /* 0x0000 */ FGuid ID;
    /* 0x0010 */ FGuid ClassID;
    /* 0x0020 */ FName Name;
    /* 0x0028 */ FMetasoundFrontendNodeInterface Interface;
    /* 0x0058 */ TArray<FMetasoundFrontendVertexLiteral> InputLiterals;
    /* 0x0068 */ FInstancedStruct Configuration;
    /* 0x0078 */ FInstancedStruct ClassInterfaceOverride;
};

// Size: 0x30
struct FMetasoundFrontendNodeInterface {
    /* 0x0000 */ TArray<FMetasoundFrontendVertex> Inputs;
    /* 0x0010 */ TArray<FMetasoundFrontendVertex> Outputs;
    /* 0x0020 */ TArray<FMetasoundFrontendVertex> Environment;
};

// Size: 0x1
struct FMetasoundFrontendNodeStyle {
};

// Size: 0x1
struct FMetasoundFrontendNodeStyleDisplay {
};

// Size: 0xb8
struct FMetasoundFrontendVariable {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName TypeName;
    /* 0x0010 */ FMetasoundFrontendLiteral Literal;
    /* 0x0068 */ FGuid ID;
    /* 0x0078 */ FGuid VariableNodeID;
    /* 0x0088 */ FGuid MutatorNodeID;
    /* 0x0098 */ TArray<FGuid> AccessorNodeIDs;
    /* 0x00a8 */ TArray<FGuid> DeferredAccessorNodeIDs;
};

// Size: 0x10
struct FMetasoundFrontendVersion {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FMetasoundFrontendVersionNumber Number;
};

// Size: 0x8
struct FMetasoundFrontendVersionNumber {
    /* 0x0000 */ int32_t Major;
    /* 0x0004 */ int32_t Minor;
};

// Size: 0x20
struct FMetasoundFrontendVertex {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName TypeName;
    /* 0x0010 */ FGuid VertexID;
};

// Size: 0x20
struct FMetasoundFrontendVertexHandle {
    /* 0x0000 */ FGuid NodeID;
    /* 0x0010 */ FGuid VertexID;
};

// Size: 0x68
struct FMetasoundFrontendVertexLiteral {
    /* 0x0000 */ FGuid VertexID;
    /* 0x0010 */ FMetasoundFrontendLiteral Value;
};

// Size: 0x1
struct FMetasoundFrontendVertexMetadata {
};

// Size: 0x40
class UMetasoundParameterPack : public UObject {

    bool GetBool(FName ParameterName, ESetParamResult& Result) const;
    float GetFloat(FName ParameterName, ESetParamResult& Result) const;
    int32_t GetInt(FName ParameterName, ESetParamResult& Result) const;
    FString GetString(FName ParameterName, ESetParamResult& Result) const;
    bool GetTrigger(FName ParameterName, ESetParamResult& Result) const;
    bool HasBool(FName ParameterName) const;
    bool HasFloat(FName ParameterName) const;
    bool HasInt(FName ParameterName) const;
    bool HasString(FName ParameterName) const;
    bool HasTrigger(FName ParameterName) const;
    static UMetasoundParameterPack* MakeMetasoundParameterPack();
    ESetParamResult SetBool(FName ParameterName, bool InValue, bool OnlyIfExists);
    ESetParamResult SetFloat(FName ParameterName, float InValue, bool OnlyIfExists);
    ESetParamResult SetInt(FName ParameterName, int32_t InValue, bool OnlyIfExists);
    ESetParamResult SetString(FName ParameterName, FString InValue, bool OnlyIfExists);
    ESetParamResult SetTrigger(FName ParameterName, bool OnlyIfExists);
};

// Size: 0x20
struct FNodeTemplateGenerateInterfaceParams {
    /* 0x0000 */ TArray<FName> InputsToConnect;
    /* 0x0010 */ TArray<FName> OutputsToConnect;
};

enum class EMoviePlaybackType {
    MT_Normal = 0,
    MT_Looped = 1,
    MT_LoadingLoop = 2,
    MT_MAX = 3,
};

// Size: 0x40
class UMoviePlayerSettings : public UObject {
    /* 0x0028 */ bool bWaitForMoviesToComplete;
    /* 0x0029 */ bool bMoviesAreSkippable;
    /* 0x0030 */ TArray<FString> StartupMovies;
};

// Size: 0x18
struct FActorForWorldTransforms {
    /* 0x0000 */ TWeakObjectPtr<AActor> Actor;
    /* 0x0008 */ TWeakObjectPtr<USceneComponent> Component;
    /* 0x0010 */ FName SocketName;
};

// Size: 0x28
class UBuiltInDynamicBindingResolverLibrary : public UBlueprintFunctionLibrary {

    static FMovieSceneDynamicBindingResolveResult ResolveToPlayerPawn(UObject* WorldContextObject, int32_t PlayerControllerIndex);
};

enum class EEvaluationMethod {
    Static = 0,
    Swept = 1,
    EEvaluationMethod_MAX = 2,
};

enum class EMovieSceneBlendType {
    Invalid = 0,
    Absolute = 1,
    Additive = 2,
    Relative = 4,
    AdditiveFromBase = 8,
    Override = 16,
    EMovieSceneBlendType_MAX = 17,
};

enum class EMovieSceneBreadcrumbMode {
    Sparse = 0,
    Dense = 1,
    EMovieSceneBreadcrumbMode_MAX = 2,
};

enum class EMovieSceneBuiltInEasing {
    Linear = 0,
    SinIn = 1,
    SinOut = 2,
    SinInOut = 3,
    QuadIn = 4,
    QuadOut = 5,
    QuadInOut = 6,
    Cubic = 7,
    CubicIn = 8,
    CubicOut = 9,
    CubicInOut = 10,
    HermiteCubicInOut = 11,
    QuartIn = 12,
    QuartOut = 13,
    QuartInOut = 14,
    QuintIn = 15,
    QuintOut = 16,
    QuintInOut = 17,
    ExpoIn = 18,
    ExpoOut = 19,
    ExpoInOut = 20,
    CircIn = 21,
    CircOut = 22,
    CircInOut = 23,
    Custom = 24,
    EMovieSceneBuiltInEasing_MAX = 25,
};

enum class EMovieSceneCompletionMode {
    KeepState = 0,
    RestoreState = 1,
    ProjectDefault = 2,
    EMovieSceneCompletionMode_MAX = 3,
};

enum class EMovieSceneCompletionModeOverride {
    None = 0,
    ForceKeepState = 1,
    ForceRestoreState = 2,
    EMovieSceneCompletionModeOverride_MAX = 3,
};

enum class EMovieSceneConditionCheckFrequency {
    Once = 0,
    OnTick = 1,
    EMovieSceneConditionCheckFrequency_MAX = 2,
};

enum class EMovieSceneConditionScope {
    Global = 0,
    Binding = 1,
    OwnerObject = 2,
    EMovieSceneConditionScope_MAX = 3,
};

enum class EMovieSceneEvaluationType {
    FrameLocked = 0,
    WithSubFrames = 1,
    EMovieSceneEvaluationType_MAX = 2,
};

enum class EMovieSceneGroupConditionOperator {
    And = 0,
    Or = 1,
    Xor = 2,
    EMovieSceneGroupConditionOperator_MAX = 3,
};

enum class EMovieSceneKeyInterpolation {
    Auto = 0,
    User = 1,
    Break = 2,
    Linear = 3,
    Constant = 4,
    SmartAuto = 5,
    EMovieSceneKeyInterpolation_MAX = 6,
};

enum class EMovieSceneObjectBindingSpace {
    Local = 0,
    Root = 1,
    Unused = 2,
    EMovieSceneObjectBindingSpace_MAX = 3,
};

enum class EMovieScenePlayerStatus {
    Stopped = 0,
    Playing = 1,
    Scrubbing = 2,
    Jumping = 3,
    Stepping = 4,
    Paused = 5,
    MAX = 6,
};

enum class EMovieScenePositionType {
    Frame = 0,
    Time = 1,
    MarkedFrame = 2,
    Timecode = 3,
    EMovieScenePositionType_MAX = 4,
};

enum class EMovieSceneSequenceCompilerMask {
    Hierarchy = 1,
    EvaluationTemplate = 2,
    EvaluationTemplateField = 4,
    EntityComponentField = 8,
    None = 0,
    EMovieSceneSequenceCompilerMask_MAX = 16,
};

enum class EMovieSceneSequenceFlags {
    None = 0,
    Volatile = 1,
    BlockingEvaluation = 2,
    DynamicWeighting = 4,
    InheritedFlags = 1,
    EMovieSceneSequenceFlags_MAX = 8,
};

enum class EMovieSceneServerClientMask {
    None = 0,
    Server = 1,
    Client = 2,
    All = 3,
    EMovieSceneServerClientMask_MAX = 4,
};

enum class EMovieSceneSubSectionFlags {
    None = 0,
    OverrideKeepState = 1,
    OverrideRestoreState = 2,
    IgnoreHierarchicalBias = 4,
    BlendHierarchicalBias = 8,
    AnyRestoreStateOverride = 3,
    EMovieSceneSubSectionFlags_MAX = 16,
};

enum class EMovieSceneTimeUnit {
    DisplayRate = 0,
    TickResolution = 1,
    EMovieSceneTimeUnit_MAX = 2,
};

enum class EMovieSceneTimeWarpType {
    FixedPlayRate = 0,
    Custom = 1,
    FixedTime = 2,
    FrameRate = 3,
    Loop = 4,
    Clamp = 5,
    LoopFloat = 6,
    ClampFloat = 7,
    EMovieSceneTimeWarpType_MAX = 8,
};

enum class ENavigationToolItemFlags {
    None = 0,
    IgnorePendingKill = 1,
    PendingRemoval = 2,
    Expanded = 4,
    ENavigationToolItemFlags_MAX = 5,
};

enum class ESectionEvaluationFlags {
    None = 0,
    PreRoll = 1,
    PostRoll = 2,
    ForceKeepState = 4,
    ForceRestoreState = 8,
    ESectionEvaluationFlags_MAX = 9,
};

enum class ESpawnOwnership {
    InnerSequence = 0,
    RootSequence = 1,
    External = 2,
    ESpawnOwnership_MAX = 3,
};

enum class EUpdateClockSource {
    Tick = 0,
    Platform = 1,
    Audio = 2,
    RelativeTimecode = 3,
    Timecode = 4,
    PlayEveryFrame = 5,
    Custom = 6,
    EUpdateClockSource_MAX = 7,
};

enum class EUpdatePositionMethod {
    Play = 0,
    Jump = 1,
    Scrub = 2,
    EUpdatePositionMethod_MAX = 3,
};

// Size: 0x8
struct FEasingComponentData {
    /* 0x0000 */ UMovieSceneSection* Section;
};

// Size: 0x40
struct FGeneratedMovieSceneKeyStruct {
};

// Size: 0x168
class UMovieScene : public UMovieSceneDecorationContainerObject {
    /* 0x0070 */ TArray<FMovieSceneSpawnable> Spawnables;
    /* 0x0080 */ TArray<FMovieScenePossessable> Possessables;
    /* 0x0090 */ TArray<FMovieSceneBinding> ObjectBindings;
    /* 0x00a0 */ TMap<FName, FMovieSceneObjectBindingIDs> BindingGroups;
    /* 0x00f0 */ TArray<UMovieSceneTrack*> Tracks;
    /* 0x0100 */ UMovieSceneTrack* CameraCutTrack;
    /* 0x0108 */ UMovieSceneClock* CustomClock;
    /* 0x0110 */ FMovieSceneFrameRange SelectionRange;
    /* 0x0120 */ FMovieSceneFrameRange PlaybackRange;
    /* 0x0130 */ FFrameRate TickResolution;
    /* 0x0138 */ FFrameRate DisplayRate;
    /* 0x0140 */ EMovieSceneEvaluationType EvaluationType;
    /* 0x0141 */ EUpdateClockSource ClockSource;
    /* 0x0148 */ TArray<FMovieSceneMarkedFrame> MarkedFrames;
    /* 0x0158 */ TArray<UMovieSceneGroupCondition*> GeneratedConditions;
};

// Size: 0x50
struct FMovieSceneAnchorsScalingGroup {
    /* 0x0000 */ TSet<UMovieSceneSection*> Sections;
};

// Size: 0xf8
struct FMovieSceneAudioTriggerChannel : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> Times;
    /* 0x0060 */ TArray<bool> Values;
    /* 0x0070 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x30
struct FMovieSceneBinding {
    /* 0x0000 */ FGuid ObjectGuid;
    /* 0x0010 */ FString BindingName;
    /* 0x0020 */ TArray<UMovieSceneTrack*> Tracks;
};

// Size: 0x28
class IMovieSceneBindingEventReceiverInterface : public UInterface {

    void OnObjectBoundBySequencer(UMovieSceneSequencePlayer* Player, FMovieSceneObjectBindingID BindingID);
    void OnObjectUnboundBySequencer(UMovieSceneSequencePlayer* Player, FMovieSceneObjectBindingID BindingID);
};

// Size: 0x110
class UMovieSceneBindingLifetimeSection : public UMovieSceneSection {
};

// Size: 0x40
class UMovieSceneBindingLifetimeSystem : public UMovieSceneEntitySystem {
};

// Size: 0x128
class UMovieSceneBindingLifetimeTrack : public UMovieSceneTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x48
struct FMovieSceneBindingOverrideData {
    /* 0x0000 */ FMovieSceneObjectBindingID ObjectBindingID;
    /* 0x0018 */ TSoftObjectPtr<UObject> Object;
    /* 0x0040 */ bool bOverridesDefault;
};

// Size: 0x90
class UMovieSceneBindingOverrides : public UObject {
    /* 0x0028 */ TArray<FMovieSceneBindingOverrideData> BindingData;
};

// Size: 0x28
class IMovieSceneBindingOwnerInterface : public UInterface {
};

// Size: 0x18
struct FMovieSceneBindingProxy {
    /* 0x0000 */ FGuid BindingID;
    /* 0x0010 */ UMovieSceneSequence* Sequence;
};

// Size: 0x30
struct FMovieSceneBindingReference {
    /* 0x0000 */ FGuid ID;
    /* 0x0010 */ FUniversalObjectLocator Locator;
    /* 0x0020 */ ELocatorResolveFlags ResolveFlags;
    /* 0x0028 */ UMovieSceneCustomBinding* CustomBinding;
};

// Size: 0x10
struct FMovieSceneBindingReferences {
    /* 0x0000 */ TArray<FMovieSceneBindingReference> SortedReferences;
};

// Size: 0x20
struct FMovieSceneBindingResolveContext {
    /* 0x0000 */ UObject* WorldContext;
    /* 0x0008 */ FMovieSceneBindingProxy Binding;
};

// Size: 0x28
struct FMovieSceneBindingResolveParams {
    /* 0x0000 */ UMovieSceneSequence* Sequence;
    /* 0x0008 */ FGuid ObjectBindingID;
    /* 0x0018 */ FMovieSceneSequenceID SequenceID;
    /* 0x0020 */ UObject* Context;
};

// Size: 0x8
struct FMovieSceneBindingResolveResult {
    /* 0x0000 */ UObject* Object;
};

// Size: 0x68
class UMovieSceneBlenderSystem : public UMovieSceneEntitySystem {
};

// Size: 0x28
class IMovieSceneBlenderSystemSupport : public UInterface {
};

// Size: 0x108
struct FMovieSceneBoolChannel : public FMovieSceneChannel {
    /* 0x0050 */ uint8_t PreInfinityExtrap;
    /* 0x0051 */ uint8_t PostInfinityExtrap;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ bool DefaultValue;
    /* 0x0069 */ bool bHasDefaultValue;
    /* 0x0070 */ TArray<bool> Values;
    /* 0x0080 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x218
class UMovieSceneBoolSection : public UMovieSceneSection {
    /* 0x0108 */ bool DefaultValue;
    /* 0x0110 */ FMovieSceneBoolChannel BoolCurve;
};

// Size: 0x28
class IMovieSceneBoundObjectProxy : public UInterface {

    UObject* BP_GetBoundObjectForSequencer(UObject* ResolvedObject);
};

// Size: 0x40
class UMovieSceneBoundSceneComponentInstantiator : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x38
class UMovieSceneBuiltInEasingFunction : public UObject {
    /* 0x0030 */ EMovieSceneBuiltInEasing Type;
};

// Size: 0x110
struct FMovieSceneByteChannel : public FMovieSceneChannel {
    /* 0x0050 */ uint8_t PreInfinityExtrap;
    /* 0x0051 */ uint8_t PostInfinityExtrap;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ uint8_t DefaultValue;
    /* 0x0069 */ bool bHasDefaultValue;
    /* 0x0070 */ TArray<uint8_t> Values;
    /* 0x0080 */ UEnum* Enum;
    /* 0x0088 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x40
class UMovieSceneCachePreAnimatedStateSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x28
class IMovieSceneCachedTrack : public UInterface {
};

// Size: 0x50
struct FMovieSceneChannel {
};

// Size: 0x28
class IMovieSceneChannelDecoration : public UInterface {
};

// Size: 0x58
class UMovieSceneChannelOverrideContainer : public UMovieSceneSignedObject {
};

// Size: 0x28
class IMovieSceneChannelOverrideProvider : public UInterface {
};

// Size: 0x28
class IMovieSceneChannelOwner : public UInterface {
};

// Size: 0x58
class UMovieSceneClock : public UMovieSceneSignedObject {
};

// Size: 0x420
class UMovieSceneCompiledData : public UObject {
    /* 0x0028 */ FMovieSceneEvaluationTemplate EvaluationTemplate;
    /* 0x0188 */ FMovieSceneSequenceHierarchy Hierarchy;
    /* 0x02c8 */ FMovieSceneEntityComponentField EntityComponentField;
    /* 0x03b8 */ FMovieSceneEvaluationField TrackTemplateField;
    /* 0x03e8 */ TArray<FMovieSceneDeterminismFence> DeterminismFences;
    /* 0x03f8 */ FGuid CompiledSignature;
    /* 0x0408 */ FGuid CompilerVersion;
    /* 0x0418 */ EMovieSceneSequenceCompilerMask AccumulatedMask;
    /* 0x0419 */ EMovieSceneSequenceCompilerMask AllocatedMask;
    /* 0x041a */ EMovieSceneSequenceFlags AccumulatedFlags;
};

// Size: 0x230
class UMovieSceneCompiledDataManager : public UObject {
    /* 0x00d8 */ TMap<int32_t, FMovieSceneSequenceHierarchy> Hierarchies;
    /* 0x0128 */ TMap<int32_t, FMovieSceneEvaluationTemplate> TrackTemplates;
    /* 0x0178 */ TMap<int32_t, FMovieSceneEvaluationField> TrackTemplateFields;
    /* 0x01c8 */ TMap<int32_t, FMovieSceneEntityComponentField> EntityComponentFields;
};

// Size: 0x1
struct FMovieSceneCompiledSequenceFlagStruct {
    /* 0x0000 */ bool bParentSequenceRequiresLowerFence;
    /* 0x0000 */ bool bParentSequenceRequiresUpperFence;
};

// Size: 0x60
class UMovieSceneCondition : public UMovieSceneSignedObject {
    /* 0x0058 */ bool bInvert;

    bool BP_EvaluateCondition(const FMovieSceneConditionContext& ConditionContext) const;
    EMovieSceneConditionCheckFrequency BP_GetCheckFrequency() const;
    EMovieSceneConditionScope BP_GetScope() const;
};

// Size: 0x8
struct FMovieSceneConditionContainer {
    /* 0x0000 */ UMovieSceneCondition* Condition;
};

// Size: 0x30
struct FMovieSceneConditionContext {
    /* 0x0000 */ UObject* WorldContext;
    /* 0x0008 */ FMovieSceneBindingProxy Binding;
    /* 0x0020 */ TArray<UObject*> BoundObjects;
};

// Size: 0x28
class UMovieSceneCustomBinding : public UObject {

    static int32_t GetBaseCustomPriority();
    static int32_t GetBaseEnginePriority();
};

// Size: 0x28
class IMovieSceneCustomClockSource : public UInterface {

    FFrameTime OnRequestCurrentTime(const FQualifiedFrameTime& InCurrentTime, float InPlayRate);
    void OnStartPlaying(const FQualifiedFrameTime& InStartTime);
    void OnStopPlaying(const FQualifiedFrameTime& InStopTime);
    void OnTick(float DeltaSeconds, float InPlayRate);
};

// Size: 0x8
struct FMovieSceneCustomTimeWarpGetterStruct {
    /* 0x0000 */ UMovieSceneTimeWarpGetter* Object;
};

// Size: 0x28
class IMovieSceneDecoration : public UInterface {
};

// Size: 0x10
struct FMovieSceneDecorationContainer {
    /* 0x0000 */ TArray<UObject*> Decorations;
};

// Size: 0x68
class UMovieSceneDecorationContainerObject : public UMovieSceneSignedObject {
    /* 0x0058 */ FMovieSceneDecorationContainer Decorations;
};

// Size: 0x18
struct FMovieSceneDeterminismData {
    /* 0x0000 */ TArray<FMovieSceneDeterminismFence> Fences;
    /* 0x0010 */ bool bParentSequenceRequiresLowerFence;
    /* 0x0011 */ bool bParentSequenceRequiresUpperFence;
};

// Size: 0x8
struct FMovieSceneDeterminismFence {
    /* 0x0000 */ FFrameNumber FrameNumber;
    /* 0x0004 */ bool bInclusive;
};

// Size: 0x28
class IMovieSceneDeterminismSource : public UInterface {
};

// Size: 0x118
struct FMovieSceneDoubleChannel : public FMovieSceneChannel {
    /* 0x0050 */ uint8_t PreInfinityExtrap;
    /* 0x0051 */ uint8_t PostInfinityExtrap;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ TArray<FMovieSceneDoubleValue> Values;
    /* 0x0078 */ double DefaultValue;
    /* 0x0080 */ bool bHasDefaultValue;
    /* 0x0088 */ FMovieSceneKeyHandleMap KeyHandles;
    /* 0x0110 */ FFrameRate TickResolution;
};

// Size: 0x20
struct FMovieSceneDoubleValue {
    /* 0x0000 */ double Value;
    /* 0x0008 */ FMovieSceneTangentData Tangent;
    /* 0x001c */ uint8_t InterpMode;
    /* 0x001d */ uint8_t TangentMode;
    /* 0x001e */ uint8_t PaddingByte;
};

// Size: 0x28
struct FMovieSceneDynamicBinding {
    /* 0x0000 */ UFunction* Function;
    /* 0x0008 */ FFieldPath ResolveParamsProperty;
};

// Size: 0x28
struct FMovieSceneDynamicBindingContainer {
    /* 0x0000 */ FMovieSceneDynamicBinding DynamicBinding;
};

// Size: 0x30
struct FMovieSceneDynamicBindingPayloadVariable {
    /* 0x0000 */ FSoftObjectPath ObjectValue;
    /* 0x0020 */ FString Value;
};

// Size: 0x20
struct FMovieSceneDynamicBindingResolveParams {
    /* 0x0000 */ UMovieSceneSequence* Sequence;
    /* 0x0008 */ FGuid ObjectBindingID;
    /* 0x0018 */ UMovieSceneSequence* RootSequence;
};

// Size: 0x10
struct FMovieSceneDynamicBindingResolveResult {
    /* 0x0000 */ UObject* Object;
    /* 0x0008 */ bool bIsPossessedObject;
};

// Size: 0x38
class UMovieSceneEasingExternalCurve : public UObject {
    /* 0x0030 */ UCurveFloat* Curve;
};

// Size: 0x28
class IMovieSceneEasingFunction : public UInterface {

    float OnEvaluate(float Interp) const;
};

// Size: 0x38
struct FMovieSceneEasingSettings {
    /* 0x0000 */ int32_t AutoEaseInDuration;
    /* 0x0004 */ int32_t AutoEaseOutDuration;
    /* 0x0008 */ TScriptInterface<IMovieSceneEasingFunction> EaseIn;
    /* 0x0018 */ bool bManualEaseIn;
    /* 0x001c */ int32_t ManualEaseInDuration;
    /* 0x0020 */ TScriptInterface<IMovieSceneEasingFunction> EaseOut;
    /* 0x0030 */ bool bManualEaseOut;
    /* 0x0034 */ int32_t ManualEaseOutDuration;
};

// Size: 0x208
struct FMovieSceneEditorData {
    /* 0x0000 */ TMap<FString, FMovieSceneExpansionState> ExpansionStates;
    /* 0x0050 */ TArray<FString> PinnedNodes;
    /* 0x0060 */ double ViewStart;
    /* 0x0068 */ double ViewEnd;
    /* 0x0070 */ double WorkStart;
    /* 0x0078 */ double WorkEnd;
    /* 0x0080 */ TSet<FFrameNumber> MarkedFrames;
    /* 0x00d0 */ FFloatRange WorkingRange;
    /* 0x00e0 */ FFloatRange ViewRange;
    /* 0x00f0 */ FNavigationToolSaveState NavigationToolState;
    /* 0x01e8 */ TArray<FString> SoloNodes;
    /* 0x01f8 */ TArray<FString> MuteNodes;
};

// Size: 0x1
struct FMovieSceneEmptyStruct {
};

// Size: 0xf0
struct FMovieSceneEntityComponentField {
    /* 0x0000 */ FMovieSceneEvaluationFieldEntityTree PersistentEntityTree;
    /* 0x0060 */ FMovieSceneEvaluationFieldEntityTree OneShotEntityTree;
    /* 0x00c0 */ TArray<FMovieSceneEvaluationFieldEntity> Entities;
    /* 0x00d0 */ TArray<FMovieSceneEvaluationFieldEntityMetaData> EntityMetaData;
    /* 0x00e0 */ TArray<FMovieSceneEvaluationFieldSharedEntityMetaData> SharedMetaData;
};

// Size: 0x28
class IMovieSceneEntityDecorator : public UInterface {
};

// Size: 0x158
class UMovieSceneEntityGroupingSystem : public UMovieSceneEntitySystem {
};

// Size: 0x40
class UMovieSceneEntityInstantiatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x28
class IMovieSceneEntityProvider : public UInterface {
};

// Size: 0x40
class UMovieSceneEntitySystem : public UObject {
    /* 0x0028 */ UMovieSceneEntitySystemLinker* Linker;
};

// Size: 0x190
struct FMovieSceneEntitySystemGraph {
    /* 0x00b8 */ FMovieSceneEntitySystemGraphNodes Nodes;
};

// Size: 0x28
struct FMovieSceneEntitySystemGraphNode {
    /* 0x0020 */ UMovieSceneEntitySystem* System;
};

// Size: 0x38
struct FMovieSceneEntitySystemGraphNodes {
};

// Size: 0x768
class UMovieSceneEntitySystemLinker : public UObject {
    /* 0x02d0 */ FMovieSceneEntitySystemGraph SystemGraph;
};

// Size: 0x20
struct FMovieSceneEvalTemplate : public FMovieSceneEvalTemplateBase {
    /* 0x0010 */ EMovieSceneCompletionMode CompletionMode;
    /* 0x0014 */ TWeakObjectPtr<UMovieSceneSection> SourceSectionPtr;
};

// Size: 0x10
struct FMovieSceneEvalTemplateBase {
};

// Size: 0x88
struct FMovieSceneEvalTemplatePtr {
};

// Size: 0x1d0
class UMovieSceneEvalTimeSystem : public UMovieSceneEntitySystem {
};

// Size: 0x30
struct FMovieSceneEvaluationField {
    /* 0x0000 */ TArray<FMovieSceneFrameRange> Ranges;
    /* 0x0010 */ TArray<FMovieSceneEvaluationGroup> Groups;
    /* 0x0020 */ TArray<FMovieSceneEvaluationMetaData> MetaData;
};

// Size: 0x10
struct FMovieSceneEvaluationFieldEntity {
    /* 0x0000 */ FMovieSceneEvaluationFieldEntityKey Key;
    /* 0x000c */ int32_t SharedMetaDataIndex;
};

// Size: 0xc
struct FMovieSceneEvaluationFieldEntityKey {
    /* 0x0000 */ TWeakObjectPtr<UObject> EntityOwner;
    /* 0x0008 */ uint32_t EntityID;
};

// Size: 0x40
struct FMovieSceneEvaluationFieldEntityMetaData {
    /* 0x0000 */ TSoftObjectPtr<UMovieSceneCondition> Condition;
    /* 0x0028 */ FString OverrideBoundPropertyPath;
    /* 0x0038 */ FFrameNumber ForcedTime;
    /* 0x003c */ ESectionEvaluationFlags Flags;
    /* 0x003d */ bool bEvaluateInSequencePreRoll;
    /* 0x003d */ bool bEvaluateInSequencePostRoll;
};

// Size: 0x60
struct FMovieSceneEvaluationFieldEntityTree {
};

// Size: 0xc
struct FMovieSceneEvaluationFieldSegmentPtr : public FMovieSceneEvaluationFieldTrackPtr {
    /* 0x0008 */ FMovieSceneSegmentIdentifier SegmentID;
};

// Size: 0x10
struct FMovieSceneEvaluationFieldSharedEntityMetaData {
    /* 0x0000 */ FGuid ObjectBindingID;
};

// Size: 0x8
struct FMovieSceneEvaluationFieldTrackPtr {
    /* 0x0000 */ FMovieSceneSequenceID SequenceID;
    /* 0x0004 */ FMovieSceneTrackIdentifier TrackIdentifier;
};

// Size: 0x30
struct FMovieSceneEvaluationGroup {
    /* 0x0000 */ TArray<FMovieSceneEvaluationGroupLUTIndex> LUTIndices;
    /* 0x0010 */ TArray<FMovieSceneFieldEntry_EvaluationTrack> TrackLUT;
    /* 0x0020 */ TArray<FMovieSceneFieldEntry_ChildTemplate> SectionLUT;
};

// Size: 0x8
struct FMovieSceneEvaluationGroupLUTIndex {
    /* 0x0000 */ int32_t NumInitPtrs;
    /* 0x0004 */ int32_t NumEvalPtrs;
};

// Size: 0x28
class IMovieSceneEvaluationHook : public UInterface {
};

// Size: 0x20
struct FMovieSceneEvaluationHookComponent {
    /* 0x0000 */ TScriptInterface<IMovieSceneEvaluationHook> Interface;
};

// Size: 0x40
struct FMovieSceneEvaluationHookEvent {
    /* 0x0000 */ FMovieSceneEvaluationHookComponent Hook;
};

// Size: 0x10
struct FMovieSceneEvaluationHookEventContainer {
    /* 0x0000 */ TArray<FMovieSceneEvaluationHookEvent> Events;
};

// Size: 0x90
class UMovieSceneEvaluationHookSystem : public UMovieSceneEntitySystem {
    /* 0x0040 */ TMap<FMovieSceneEvaluationInstanceKey, FMovieSceneEvaluationHookEventContainer> PendingEventsByRootInstance;
};

// Size: 0x4
struct FMovieSceneEvaluationInstanceKey {
};

// Size: 0xc
struct FMovieSceneEvaluationKey {
    /* 0x0000 */ FMovieSceneSequenceID SequenceID;
    /* 0x0004 */ FMovieSceneTrackIdentifier TrackIdentifier;
    /* 0x0008 */ uint32_t SectionIndex;
};

// Size: 0x20
struct FMovieSceneEvaluationMetaData {
    /* 0x0000 */ TArray<FMovieSceneSequenceID> ActiveSequences;
    /* 0x0010 */ TArray<FMovieSceneOrderedEvaluationKey> ActiveEntities;
};

// Size: 0x14
struct FMovieSceneEvaluationOperand {
    /* 0x0000 */ FGuid ObjectBindingID;
    /* 0x0010 */ FMovieSceneSequenceID SequenceID;
};

// Size: 0x160
struct FMovieSceneEvaluationTemplate {
    /* 0x0000 */ TMap<FMovieSceneTrackIdentifier, FMovieSceneEvaluationTrack> Tracks;
    /* 0x00a0 */ FGuid SequenceSignature;
    /* 0x00b0 */ FMovieSceneEvaluationTemplateSerialNumber TemplateSerialNumber;
    /* 0x00b8 */ FMovieSceneTemplateGenerationLedger TemplateLedger;
};

// Size: 0x4
struct FMovieSceneEvaluationTemplateSerialNumber {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x78
struct FMovieSceneEvaluationTrack {
    /* 0x0000 */ FGuid ObjectBindingID;
    /* 0x0010 */ uint16_t EvaluationPriority;
    /* 0x0012 */ EEvaluationMethod EvaluationMethod;
    /* 0x0014 */ TWeakObjectPtr<UMovieSceneTrack> SourceTrack;
    /* 0x0020 */ TArray<FMovieSceneEvalTemplatePtr> ChildTemplates;
    /* 0x0030 */ FMovieSceneTrackImplementationPtr TrackTemplate;
    /* 0x0068 */ FName EvaluationGroup;
    /* 0x0070 */ bool bEvaluateInPreroll;
    /* 0x0070 */ bool bEvaluateInPostroll;
    /* 0x0070 */ bool bTearDownPriority;
};

// Size: 0x1
struct FMovieSceneExpansionState {
    /* 0x0000 */ bool bExpanded;
};

// Size: 0x78
class UMovieSceneExternalClock : public UMovieSceneClock {
    /* 0x0058 */ FSoftObjectPath CustomClockSourcePath;
};

// Size: 0x8
struct FMovieSceneFieldEntry_ChildTemplate {
    /* 0x0000 */ uint16_t ChildIndex;
    /* 0x0002 */ ESectionEvaluationFlags Flags;
    /* 0x0004 */ FFrameNumber ForcedTime;
};

// Size: 0xc
struct FMovieSceneFieldEntry_EvaluationTrack {
    /* 0x0000 */ FMovieSceneEvaluationFieldTrackPtr TrackPtr;
    /* 0x0008 */ uint16_t NumChildren;
};

// Size: 0x8
struct FMovieSceneFixedPlayRateStruct {
    /* 0x0000 */ double PlayRate;
};

// Size: 0x110
struct FMovieSceneFloatChannel : public FMovieSceneChannel {
    /* 0x0050 */ uint8_t PreInfinityExtrap;
    /* 0x0051 */ uint8_t PostInfinityExtrap;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ TArray<FMovieSceneFloatValue> Values;
    /* 0x0078 */ float DefaultValue;
    /* 0x007c */ bool bHasDefaultValue;
    /* 0x0080 */ FMovieSceneKeyHandleMap KeyHandles;
    /* 0x0108 */ FFrameRate TickResolution;
};

// Size: 0x1c
struct FMovieSceneFloatValue {
    /* 0x0000 */ float Value;
    /* 0x0004 */ FMovieSceneTangentData Tangent;
    /* 0x0018 */ uint8_t InterpMode;
    /* 0x0019 */ uint8_t TangentMode;
    /* 0x001a */ uint8_t PaddingByte;
};

// Size: 0x78
class UMovieSceneFolder : public UObject {
    /* 0x002c */ FName FolderName;
    /* 0x0038 */ TArray<UMovieSceneFolder*> ChildFolders;
    /* 0x0048 */ TArray<UMovieSceneTrack*> ChildTracks;
    /* 0x0058 */ TArray<FString> ChildObjectBindingStrings;
};

// Size: 0x10
struct FMovieSceneFrameRange {
};

// Size: 0x40
class UMovieSceneGenericBoundObjectInstantiator : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x78
class UMovieSceneGroupCondition : public UMovieSceneCondition {
    /* 0x0060 */ EMovieSceneGroupConditionOperator Operator;
    /* 0x0068 */ TArray<FMovieSceneConditionContainer> SubConditions;
};

// Size: 0x120
class UMovieSceneHookSection : public UMovieSceneSection {
    /* 0x0118 */ bool bRequiresRangedHook;
    /* 0x0118 */ bool bRequiresTriggerHooks;
};

// Size: 0x40
class UMovieSceneInitialValueSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x108
struct FMovieSceneIntegerChannel : public FMovieSceneChannel {
    /* 0x0050 */ uint8_t PreInfinityExtrap;
    /* 0x0051 */ uint8_t PostInfinityExtrap;
    /* 0x0052 */ bool bInterpolateLinearKeys;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ int32_t DefaultValue;
    /* 0x006c */ bool bHasDefaultValue;
    /* 0x0070 */ TArray<int32_t> Values;
    /* 0x0080 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x10
struct FMovieSceneInverseNestedSequenceTransform {
    /* 0x0000 */ FMovieSceneTimeWarpVariant TimeScale;
    /* 0x0008 */ FFrameTime Offset;
};

// Size: 0x20
struct FMovieSceneInverseSequenceTransform {
    /* 0x0000 */ FMovieSceneTimeTransform LinearTransform;
    /* 0x0010 */ TArray<FMovieSceneInverseNestedSequenceTransform> NestedTransforms;
};

// Size: 0x88
struct FMovieSceneKeyHandleMap : public FKeyHandleLookupTable {
};

// Size: 0x28
class IMovieSceneKeyProxy : public UInterface {
};

// Size: 0x8
struct FMovieSceneKeyStruct {
};

// Size: 0x28
struct FMovieSceneKeyTimeStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FFrameNumber Time;
};

// Size: 0x38
class UMovieSceneLanguagePreviewDecoration : public UObject {
    /* 0x0028 */ FString PreviewLanguage;
};

// Size: 0x28
class IMovieSceneLifetimeDecoration : public UInterface {
};

// Size: 0x20
struct FMovieSceneMarkedFrame {
    /* 0x0000 */ FFrameNumber FrameNumber;
    /* 0x0008 */ FString Label;
    /* 0x0018 */ bool bIsDeterminismFence;
    /* 0x0019 */ bool bIsInclusiveTime;
};

// Size: 0x58
class UMovieSceneMetaData : public UObject {
    /* 0x0030 */ FString author;
    /* 0x0040 */ FDateTime Created;
    /* 0x0048 */ FString Notes;

    FString GetAuthor() const;
    FDateTime GetCreated() const;
    FString GetNotes() const;
    void SetAuthor(FString InAuthor);
    void SetCreated(FDateTime InCreated);
    void SetNotes(FString InNotes);
};

// Size: 0x28
class IMovieSceneMetaDataInterface : public UInterface {
};

// Size: 0x110
class UMovieSceneNameableTrack : public UMovieSceneTrack {
};

// Size: 0x18
struct FMovieSceneNestedSequenceTransform {
    /* 0x0000 */ FMovieSceneTimeWarpVariant TimeScale;
    /* 0x0008 */ FFrameTime Offset;
};

// Size: 0x28
class UMovieSceneNodeGroup : public UObject {
};

// Size: 0x28
class UMovieSceneNodeGroupCollection : public UObject {
};

// Size: 0x8
struct FMovieSceneNumericVariant {
};

// Size: 0x60
class UMovieSceneNumericVariantGetter : public UMovieSceneSignedObject {
    /* 0x0058 */ UMovieSceneNumericVariantGetter* ReferenceToSelf;
};

// Size: 0x18
struct FMovieSceneObjectBindingID {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ int32_t SequenceID;
    /* 0x0014 */ int32_t ResolveParentIndex;
};

// Size: 0x10
struct FMovieSceneObjectBindingIDs {
    /* 0x0000 */ TArray<FMovieSceneObjectBindingID> Ids;
};

// Size: 0x130
struct FMovieSceneObjectPathChannel : public FMovieSceneChannel {
    /* 0x0050 */ UClass* PropertyClass;
    /* 0x0058 */ TArray<FFrameNumber> Times;
    /* 0x0068 */ TArray<FMovieSceneObjectPathChannelKeyValue> Values;
    /* 0x0078 */ FMovieSceneObjectPathChannelKeyValue DefaultValue;
    /* 0x00a8 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x30
struct FMovieSceneObjectPathChannelKeyValue {
    /* 0x0000 */ TSoftObjectPtr<UObject> SoftPtr;
    /* 0x0028 */ UObject* HardPtr;
};

// Size: 0x10
struct FMovieSceneOrderedEvaluationKey {
    /* 0x0000 */ FMovieSceneEvaluationKey Key;
    /* 0x000c */ uint16_t SetupIndex;
    /* 0x000e */ uint16_t TearDownIndex;
};

// Size: 0x1b8
class UMovieScenePlayRateCurve : public UMovieSceneTimeWarpGetter {
    /* 0x0070 */ FMovieSceneTimeWarpChannel PlayRate;
    /* 0x0198 */ FFrameNumber PlaybackStartFrame;
    /* 0x019c */ bool bManualPlaybackStart;
};

// Size: 0x28
class IMovieScenePlaybackClient : public UInterface {
};

// Size: 0x80
struct FMovieScenePossessable {
    /* 0x0000 */ TArray<FName> Tags;
    /* 0x0010 */ FMovieSceneDynamicBinding DynamicBinding;
    /* 0x0038 */ FGuid Guid;
    /* 0x0048 */ FString Name;
    /* 0x0058 */ FGuid ParentGuid;
    /* 0x0068 */ FMovieSceneObjectBindingID SpawnableObjectBindingID;
};

// Size: 0x28
class IMovieScenePreAnimatedStateSystemInterface : public UInterface {
};

// Size: 0x14
struct FMovieScenePropertyBinding {
    /* 0x0000 */ FName PropertyName;
    /* 0x0008 */ FName PropertyPath;
    /* 0x0010 */ bool bCanUseClassLookup;
};

// Size: 0x18
struct FMovieScenePropertySectionData {
    /* 0x0000 */ FName PropertyName;
    /* 0x0008 */ FString PropertyPath;
};

// Size: 0x38
struct FMovieScenePropertySectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieScenePropertySectionData PropertyData;
};

// Size: 0x28
class UMovieSceneReplaceableBindingBase : public UMovieSceneCustomBinding {
};

// Size: 0x50
class UMovieSceneRestorePreAnimatedStateSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x20
struct FMovieSceneRootEvaluationTemplateInstance {
    /* 0x0000 */ UMovieSceneEntitySystemLinker* EntitySystemLinker;
};

// Size: 0x40
class UMovieSceneRootInstantiatorSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x8
struct FMovieSceneScalingAnchor {
    /* 0x0000 */ FFrameNumber position;
    /* 0x0004 */ int32_t Duration;
};

// Size: 0x2d8
class UMovieSceneScalingAnchors : public UMovieScenePlayRateCurve {
    /* 0x01c8 */ TArray<TScriptInterface<IMovieSceneScalingDriver>> ScalingDrivers;
    /* 0x01d8 */ TMap<FGuid, FMovieSceneScalingAnchor> InitialAnchors;
    /* 0x0228 */ TMap<FGuid, FMovieSceneAnchorsScalingGroup> ScalingGroups;
};

// Size: 0x28
class IMovieSceneScalingDriver : public UInterface {
};

// Size: 0x108
class UMovieSceneSection : public UMovieSceneDecorationContainerObject {
    /* 0x0068 */ FMovieSceneSectionEvalOptions EvalOptions;
    /* 0x0070 */ FMovieSceneEasingSettings Easing;
    /* 0x00a8 */ FMovieSceneFrameRange SectionRange;
    /* 0x00b8 */ FMovieSceneConditionContainer ConditionContainer;
    /* 0x00c0 */ FFrameNumber PreRollFrames;
    /* 0x00c4 */ FFrameNumber PostRollFrames;
    /* 0x00c8 */ int32_t RowIndex;
    /* 0x00cc */ int32_t OverlapPriority;
    /* 0x00d0 */ bool bIsActive;
    /* 0x00d0 */ bool bIsLocked;
    /* 0x00d4 */ float StartTime;
    /* 0x00d8 */ float EndTime;
    /* 0x00dc */ float PrerollTime;
    /* 0x00e0 */ float PostrollTime;
    /* 0x00e4 */ bool bIsInfinite;
    /* 0x00e8 */ bool bSupportsInfiniteRange;
    /* 0x00e9 */ FOptionalMovieSceneBlendType BlendType;

    FOptionalMovieSceneBlendType GetBlendType() const;
    FColor GetColorTint() const;
    EMovieSceneCompletionMode GetCompletionMode() const;
    int32_t GetOverlapPriority() const;
    int32_t GetPostRollFrames() const;
    int32_t GetPreRollFrames() const;
    int32_t GetRowIndex() const;
    bool IsActive() const;
    bool IsLocked() const;
    void SetBlendType(EMovieSceneBlendType InBlendType);
    void SetColorTint(const FColor& InColorTint);
    void SetCompletionMode(EMovieSceneCompletionMode InCompletionMode);
    void SetIsActive(bool bInIsActive);
    void SetIsLocked(bool bInIsLocked);
    void SetOverlapPriority(int32_t NewPriority);
    void SetPostRollFrames(int32_t InPostRollFrames);
    void SetPreRollFrames(int32_t InPreRollFrames);
    void SetRowIndex(int32_t NewRowIndex);
};

// Size: 0x50
class UMovieSceneSectionAnchorsDecoration : public UObject {
    /* 0x0040 */ FGuid StartAnchor;
};

// Size: 0x78
class UMovieSceneSectionChannelOverrideRegistry : public UObject {
    /* 0x0028 */ TMap<FName, UMovieSceneChannelOverrideContainer*> Overrides;
};

// Size: 0x28
class IMovieSceneSectionDecoration : public UInterface {
};

// Size: 0x2
struct FMovieSceneSectionEvalOptions {
    /* 0x0000 */ bool bCanEditCompletionMode;
    /* 0x0001 */ EMovieSceneCompletionMode CompletionMode;
};

// Size: 0x10
struct FMovieSceneSectionGroup {
    /* 0x0000 */ TArray<TWeakObjectPtr<UMovieSceneSection>> Sections;
};

// Size: 0x30
struct FMovieSceneSectionParameters {
    /* 0x0000 */ FFrameNumber StartFrameOffset;
    /* 0x0004 */ bool bCanLoop;
    /* 0x0008 */ FFrameNumber EndFrameOffset;
    /* 0x000c */ FFrameNumber FirstLoopStartFrameOffset;
    /* 0x0010 */ FMovieSceneTimeWarpVariant TimeScale;
    /* 0x0018 */ int32_t HierarchicalBias;
    /* 0x001c */ EMovieSceneSubSectionFlags Flags;
    /* 0x0020 */ float StartOffset;
    /* 0x0024 */ float PrerollTime;
    /* 0x0028 */ float PostrollTime;
};

// Size: 0x18
struct FMovieSceneSectionTimingParametersFrames {
    /* 0x0000 */ FMovieSceneTimeWarpVariant PlayRate;
    /* 0x0008 */ FFrameNumber InnerStartOffset;
    /* 0x000c */ FFrameNumber InnerEndOffset;
    /* 0x0010 */ FFrameNumber FirstLoopStartOffset;
    /* 0x0014 */ bool bLoop;
    /* 0x0014 */ bool bClamp;
    /* 0x0014 */ bool bReverse;
};

// Size: 0x18
struct FMovieSceneSectionTimingParametersSeconds {
    /* 0x0000 */ FMovieSceneTimeWarpVariant PlayRate;
    /* 0x0008 */ float InnerStartOffset;
    /* 0x000c */ float InnerEndOffset;
    /* 0x0010 */ float FirstLoopStartOffset;
    /* 0x0014 */ bool bLoop;
    /* 0x0014 */ bool bClamp;
    /* 0x0014 */ bool bReverse;
};

// Size: 0x58
struct FMovieSceneSegment {
};

// Size: 0x4
struct FMovieSceneSegmentIdentifier {
    /* 0x0000 */ int32_t IdentifierIndex;
};

// Size: 0x68
class UMovieSceneSequence : public UMovieSceneSignedObject {
    /* 0x0058 */ UMovieSceneCompiledData* CompiledData;
    /* 0x0060 */ EMovieSceneCompletionMode DefaultCompletionMode;
    /* 0x0061 */ bool bParentContextsAreSignificant;
    /* 0x0062 */ bool bPlayableDirectly;
    /* 0x0063 */ EMovieSceneSequenceFlags SequenceFlags;

    FMovieSceneObjectBindingID FindBindingByTag(FName InBindingName) const;
    TArray<FMovieSceneObjectBindingID> FindBindingsByTag(FName InBindingName) const;
    FMovieSceneTimecodeSource GetEarliestTimecodeSource() const;
};

// Size: 0x140
struct FMovieSceneSequenceHierarchy {
    /* 0x0000 */ FMovieSceneSequenceHierarchyNode RootNode;
    /* 0x0018 */ FMovieSceneSubSequenceTree tree;
    /* 0x0078 */ FMovieSceneSequenceTransform RootTransform;
    /* 0x0098 */ TMap<FMovieSceneSequenceID, FMovieSceneSubSequenceData> SubSequences;
    /* 0x00e8 */ TMap<FMovieSceneSequenceID, FMovieSceneSequenceHierarchyNode> Hierarchy;
    /* 0x0138 */ EMovieSceneServerClientMask AccumulatedNetworkMask;
};

// Size: 0x18
struct FMovieSceneSequenceHierarchyNode {
    /* 0x0000 */ FMovieSceneSequenceID ParentID;
    /* 0x0008 */ TArray<FMovieSceneSequenceID> Children;
};

// Size: 0x4
struct FMovieSceneSequenceID {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x8
struct FMovieSceneSequenceInstanceData {
};

// Size: 0x18
struct FMovieSceneSequenceInstanceDataPtr {
};

// Size: 0x4
struct FMovieSceneSequenceLoopCount {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x1
struct FMovieSceneSequencePlayToParams {
    /* 0x0000 */ bool bExclusive;
};

// Size: 0x40
struct FMovieSceneSequencePlaybackParams {
    /* 0x0000 */ FFrameTime Frame;
    /* 0x0008 */ float Time;
    /* 0x0010 */ FString MarkedFrame;
    /* 0x0020 */ FTimecode Timecode;
    /* 0x0038 */ EMovieScenePositionType PositionType;
    /* 0x0039 */ EUpdatePositionMethod UpdateMethod;
    /* 0x003a */ bool bHasJumped;
};

// Size: 0x28
struct FMovieSceneSequencePlaybackSettings {
    /* 0x0000 */ bool bAutoPlay;
    /* 0x0004 */ FMovieSceneSequenceLoopCount LoopCount;
    /* 0x0008 */ FMovieSceneSequenceTickInterval TickInterval;
    /* 0x0014 */ float PlayRate;
    /* 0x0018 */ float StartTime;
    /* 0x001c */ bool bRandomStartTime;
    /* 0x001c */ bool bDisableMovementInput;
    /* 0x001c */ bool bDisableLookAtInput;
    /* 0x001c */ bool bHidePlayer;
    /* 0x001c */ bool bHideHud;
    /* 0x001c */ bool bDisableCameraCuts;
    /* 0x0020 */ EMovieSceneCompletionModeOverride FinishCompletionStateOverride;
    /* 0x0024 */ bool bPauseAtEnd;
    /* 0x0024 */ bool bInheritTickIntervalFromOwner;
    /* 0x0024 */ bool bDynamicWeighting;
};

// Size: 0x470
class UMovieSceneSequencePlayer : public UObject {
    /* 0x0220 */ TScriptInterface<IMovieSceneSequencePlayerObserver> Observer;
    /* 0x0230 */ FMulticastInlineDelegate OnPlay;
    /* 0x0240 */ FMulticastInlineDelegate OnPlayReverse;
    /* 0x0250 */ FMulticastInlineDelegate OnStop;
    /* 0x0260 */ FMulticastInlineDelegate OnPause;
    /* 0x0270 */ FMulticastInlineDelegate OnFinished;
    /* 0x0290 */ uint8_t Status;
    /* 0x0294 */ bool bReversePlayback;
    /* 0x0298 */ UMovieSceneSequence* Sequence;
    /* 0x02a0 */ FFrameNumber StartTime;
    /* 0x02a4 */ int32_t DurationFrames;
    /* 0x02a8 */ float DurationSubFrames;
    /* 0x02ac */ int32_t CurrentNumLoops;
    /* 0x02b0 */ int32_t SerialNumber;
    /* 0x02b4 */ FMovieSceneSequencePlaybackSettings PlaybackSettings;
    /* 0x02e0 */ FMovieSceneRootEvaluationTemplateInstance RootTemplateInstance;
    /* 0x038c */ FMovieSceneSequenceReplProperties NetSyncProps;
    /* 0x03a0 */ TScriptInterface<IMovieScenePlaybackClient> PlaybackClient;
    /* 0x03b0 */ UMovieSceneSequenceTickManager* TickManager;

    void ChangePlaybackDirection();
    TArray<UObject*> GetBoundObjects(FMovieSceneObjectBindingID ObjectBinding);
    EMovieSceneCompletionModeOverride GetCompletionModeOverride() const;
    FQualifiedFrameTime GetCurrentTime() const;
    bool GetDisableCameraCuts();
    FQualifiedFrameTime GetDuration() const;
    FQualifiedFrameTime GetEndTime() const;
    int32_t GetFrameDuration() const;
    FFrameRate GetFrameRate() const;
    bool GetHideHud() const;
    TArray<FMovieSceneObjectBindingID> GetObjectBindings(UObject* InObject);
    float GetPlayRate() const;
    UMovieSceneSequence* GetSequence() const;
    FString GetSequenceName(bool bAddClientInfo) const;
    FQualifiedFrameTime GetStartTime() const;
    void GoToEndAndStop();
    bool IsPaused() const;
    bool IsPlaying() const;
    bool IsReversed() const;
    void Pause();
    void Play();
    void PlayLooping(int32_t NumLoops);
    void PlayReverse();
    void PlayTo(FMovieSceneSequencePlaybackParams PlaybackParams, FMovieSceneSequencePlayToParams PlayToParams);
    void RPC_ExplicitServerUpdateEvent(EUpdatePositionMethod Method, FFrameTime RelevantTime, int32_t NewSerialNumber);
    void RPC_OnFinishPlaybackEvent(FFrameTime StoppedTime, int32_t NewSerialNumber);
    void RPC_OnStopEvent(FFrameTime StoppedTime, int32_t NewSerialNumber);
    void RemoveWeight();
    void RequestInvalidateBinding(FMovieSceneObjectBindingID ObjectBinding);
    void RestoreState();
    void Scrub();
    void SetCompletionModeOverride(EMovieSceneCompletionModeOverride CompletionModeOverride);
    void SetDisableCameraCuts(bool bInDisableCameraCuts);
    void SetFrameRange(int32_t StartFrame, int32_t Duration, float SubFrames);
    void SetFrameRate(FFrameRate FrameRate);
    void SetHideHud(bool HideHud);
    void SetPlayRate(float PlayRate);
    void SetPlaybackPosition(FMovieSceneSequencePlaybackParams PlaybackParams);
    void SetTimeRange(float StartTime, float Duration);
    void SetWeight(double InWeight);
    void Stop();
    void StopAtCurrentTime();
};

// Size: 0x28
class IMovieSceneSequencePlayerObserver : public UInterface {
};

// Size: 0x14
struct FMovieSceneSequenceReplProperties {
    /* 0x0000 */ FFrameTime LastKnownPosition;
    /* 0x0008 */ uint8_t LastKnownStatus;
    /* 0x000c */ int32_t LastKnownNumLoops;
    /* 0x0010 */ int32_t LastKnownSerialNumber;
};

// Size: 0xc
struct FMovieSceneSequenceTickInterval {
    /* 0x0000 */ float TickIntervalSeconds;
    /* 0x0004 */ float EvaluationBudgetMicroseconds;
    /* 0x0008 */ bool bTickWhenPaused;
    /* 0x0009 */ bool bAllowRounding;
};

// Size: 0x98
class UMovieSceneSequenceTickManager : public UObject {
};

// Size: 0x28
class IMovieSceneSequenceTickManagerClient : public UInterface {
};

// Size: 0x20
struct FMovieSceneSequenceTransform {
    /* 0x0000 */ FMovieSceneTimeTransform LinearTransform;
    /* 0x0010 */ TArray<FMovieSceneNestedSequenceTransform> NestedTransforms;
};

// Size: 0x40
class UMovieSceneShotMetaData : public UObject {
    /* 0x0030 */ TOptional<bool> bIsNoGood;
    /* 0x0032 */ TOptional<bool> bIsFlagged;
    /* 0x0034 */ TOptional<bool> bIsRecorded;
    /* 0x0036 */ TOptional<bool> bIsSubSequence;
    /* 0x0038 */ TOptional<int32_t> FavoriteRating;
};

// Size: 0x58
class UMovieSceneSignedObject : public UObject {
    /* 0x002c */ FGuid Signature;
};

// Size: 0x220
class UMovieSceneSpawnSection : public UMovieSceneBoolSection {
};

// Size: 0x130
class UMovieSceneSpawnTrack : public UMovieSceneTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
    /* 0x0120 */ FGuid ObjectGuid;
};

// Size: 0xf0
struct FMovieSceneSpawnable {
    /* 0x0000 */ FTransform SpawnTransform;
    /* 0x0060 */ TArray<FName> Tags;
    /* 0x0070 */ bool bContinuouslyRespawn;
    /* 0x0071 */ bool bNetAddressableName;
    /* 0x0078 */ FMovieSceneDynamicBinding DynamicBinding;
    /* 0x00a0 */ FGuid Guid;
    /* 0x00b0 */ FString Name;
    /* 0x00c0 */ UObject* ObjectTemplate;
    /* 0x00c8 */ TArray<FGuid> ChildPossessables;
    /* 0x00d8 */ ESpawnOwnership Ownership;
    /* 0x00dc */ FName LevelName;
};

// Size: 0x30
class UMovieSceneSpawnableBindingBase : public UMovieSceneCustomBinding {
    /* 0x0028 */ ESpawnOwnership SpawnOwnership;
    /* 0x0029 */ bool bContinuouslyRespawn;
};

// Size: 0x40
class UMovieSceneSpawnablesSystem : public UMovieSceneEntitySystem {
};

// Size: 0x7f0
class UMovieSceneSubSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneSectionParameters Parameters;
    /* 0x0140 */ float StartOffset;
    /* 0x0144 */ float TimeScale;
    /* 0x0148 */ float PrerollTime;
    /* 0x014c */ uint8_t NetworkMask;
    /* 0x0150 */ FMovieSceneSubSectionOriginOverrideMask OriginOverrideMask;
    /* 0x0158 */ FMovieSceneDoubleChannel Translation[3];
    /* 0x04a0 */ FMovieSceneDoubleChannel Rotation[3];
    /* 0x07e8 */ UMovieSceneSequence* SubSequence;

    UMovieSceneSequence* GetSequence() const;
    void SetSequence(UMovieSceneSequence* Sequence);
};

// Size: 0x1c
struct FMovieSceneSubSectionData {
    /* 0x0000 */ TWeakObjectPtr<UMovieSceneSubSection> Section;
    /* 0x0008 */ FGuid ObjectBindingID;
    /* 0x0018 */ ESectionEvaluationFlags Flags;
};

// Size: 0x4
struct FMovieSceneSubSectionOriginOverrideMask {
    /* 0x0000 */ uint32_t Mask;
};

// Size: 0xf0
struct FMovieSceneSubSequenceData {
    /* 0x0000 */ FSoftObjectPath Sequence;
    /* 0x0020 */ FMovieSceneSequenceTransform OuterToInnerTransform;
    /* 0x0040 */ FMovieSceneSequenceTransform RootToSequenceTransform;
    /* 0x0060 */ FFrameRate TickResolution;
    /* 0x0068 */ FMovieSceneSequenceID DeterministicSequenceID;
    /* 0x006c */ FMovieSceneFrameRange PlayRange;
    /* 0x007c */ FMovieSceneFrameRange ParentPlayRange;
    /* 0x008c */ FMovieSceneFrameRange PreRollRange;
    /* 0x009c */ FMovieSceneFrameRange PostRollRange;
    /* 0x00ac */ int16_t HierarchicalBias;
    /* 0x00ae */ EMovieSceneSubSectionFlags AccumulatedFlags;
    /* 0x00af */ bool bCanLoop;
    /* 0x00b0 */ FMovieSceneSequenceInstanceDataPtr InstanceData;
    /* 0x00c8 */ FName SectionPath;
    /* 0x00d0 */ TWeakObjectPtr<UMovieSceneCondition> WeakCondition;
    /* 0x00e0 */ FGuid SubSectionSignature;
};

// Size: 0x60
struct FMovieSceneSubSequenceTree {
};

// Size: 0x30
struct FMovieSceneSubSequenceTreeEntry {
};

// Size: 0x120
class UMovieSceneSubTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x14
struct FMovieSceneTangentData {
    /* 0x0000 */ float ArriveTangent;
    /* 0x0004 */ float LeaveTangent;
    /* 0x0008 */ float ArriveTangentWeight;
    /* 0x000c */ float LeaveTangentWeight;
    /* 0x0010 */ uint8_t TangentWeightMode;
};

// Size: 0xa8
struct FMovieSceneTemplateGenerationLedger {
    /* 0x0000 */ FMovieSceneTrackIdentifier LastTrackIdentifier;
    /* 0x0008 */ TMap<FGuid, FMovieSceneTrackIdentifier> TrackSignatureToTrackIdentifier;
    /* 0x0058 */ TMap<FGuid, FMovieSceneFrameRange> SubSectionRanges;
};

// Size: 0xc
struct FMovieSceneTimeTransform {
    /* 0x0000 */ float TimeScale;
    /* 0x0004 */ FFrameTime Offset;
};

// Size: 0x128
struct FMovieSceneTimeWarpChannel : public FMovieSceneDoubleChannel {
    /* 0x0118 */ UMovieScene* Owner;
};

// Size: 0x4
struct FMovieSceneTimeWarpClamp {
    /* 0x0000 */ FFrameNumber max;
};

// Size: 0x4
struct FMovieSceneTimeWarpClampFloat {
    /* 0x0000 */ float max;
};

// Size: 0x198
class UMovieSceneTimeWarpCurve : public UMovieSceneTimeWarpGetter {
    /* 0x0070 */ FMovieSceneTimeWarpChannel Channel;
};

// Size: 0x40
class UMovieSceneTimeWarpDecoration : public UObject {
    /* 0x0030 */ TArray<TScriptInterface<IMovieSceneTimeWarpSource>> Sources;
};

// Size: 0x4
struct FMovieSceneTimeWarpFixedFrame {
    /* 0x0000 */ FFrameNumber FrameNumber;
};

// Size: 0x6
struct FMovieSceneTimeWarpFrameRate {
    /* 0x0000 */ uint8_t FrameRateNumerator[3];
    /* 0x0003 */ uint8_t FrameRateDenominator[3];
};

// Size: 0x70
class UMovieSceneTimeWarpGetter : public UMovieSceneNumericVariantGetter {
    /* 0x0068 */ bool bMuted;
};

// Size: 0x4
struct FMovieSceneTimeWarpLoop {
    /* 0x0000 */ FFrameNumber Duration;
};

// Size: 0x4
struct FMovieSceneTimeWarpLoopFloat {
    /* 0x0000 */ float Duration;
};

// Size: 0x110
class UMovieSceneTimeWarpSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneTimeWarpVariant TimeWarp;
};

// Size: 0x28
class IMovieSceneTimeWarpSource : public UInterface {
};

// Size: 0x130
class UMovieSceneTimeWarpTrack : public UMovieSceneTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> Sections;
    /* 0x0128 */ bool bIsActiveTimeWarp;
};

// Size: 0x8
struct FMovieSceneTimeWarpVariant {
    /* 0x0000 */ FMovieSceneNumericVariant Variant;
};

// Size: 0x8
struct FMovieSceneTimeWarping {
    /* 0x0000 */ FFrameNumber Start;
    /* 0x0004 */ FFrameNumber End;
};

// Size: 0x18
struct FMovieSceneTimecodeSource {
    /* 0x0000 */ FTimecode Timecode;
};

// Size: 0x110
class UMovieSceneTrack : public UMovieSceneDecorationContainerObject {
    /* 0x0070 */ FMovieSceneTrackEvalOptions EvalOptions;
    /* 0x0078 */ FMovieSceneConditionContainer ConditionContainer;
    /* 0x0081 */ bool bIsEvalDisabled;
    /* 0x0088 */ TArray<int32_t> RowsDisabled;
    /* 0x009c */ FGuid EvaluationFieldGuid;
    /* 0x00b0 */ FMovieSceneTrackEvaluationField EvaluationField;
    /* 0x00c0 */ TMap<int32_t, FMovieSceneTrackRowMetadata> TrackRowMetadata;
};

// Size: 0x28
class IMovieSceneTrackDecoration : public UInterface {
};

// Size: 0x4
struct FMovieSceneTrackDisplayOptions {
    /* 0x0000 */ bool bShowVerticalFrames;
};

// Size: 0x4
struct FMovieSceneTrackEvalOptions {
    /* 0x0000 */ bool bCanEvaluateNearestSection;
    /* 0x0000 */ bool bEvalNearestSection;
    /* 0x0000 */ bool bEvaluateInPreroll;
    /* 0x0000 */ bool bEvaluateInPostroll;
    /* 0x0000 */ bool bEvaluateNearestSection;
};

// Size: 0x10
struct FMovieSceneTrackEvaluationField {
    /* 0x0000 */ TArray<FMovieSceneTrackEvaluationFieldEntry> Entries;
};

// Size: 0x20
struct FMovieSceneTrackEvaluationFieldEntry {
    /* 0x0000 */ UMovieSceneSection* Section;
    /* 0x0008 */ FFrameNumberRange Range;
    /* 0x0018 */ FFrameNumber ForcedTime;
    /* 0x001c */ ESectionEvaluationFlags Flags;
    /* 0x001e */ int16_t LegacySortOrder;
};

// Size: 0x4
struct FMovieSceneTrackIdentifier {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x10
struct FMovieSceneTrackImplementation : public FMovieSceneEvalTemplateBase {
};

// Size: 0x38
struct FMovieSceneTrackImplementationPtr {
};

// Size: 0x50
class UMovieSceneTrackInstance : public UObject {
    /* 0x0028 */ TWeakObjectPtr<UObject> WeakAnimatedObject;
    /* 0x0030 */ bool bIsRootTrackInstance;
    /* 0x0038 */ UMovieSceneEntitySystemLinker* PrivateLinker;
    /* 0x0040 */ TArray<FMovieSceneTrackInstanceInput> Inputs;
};

// Size: 0x10
struct FMovieSceneTrackInstanceComponent {
    /* 0x0000 */ UMovieSceneSection* Owner;
    /* 0x0008 */ UClass* TrackInstanceClass;
};

// Size: 0x10
struct FMovieSceneTrackInstanceEntry {
    /* 0x0000 */ UObject* BoundObject;
    /* 0x0008 */ UMovieSceneTrackInstance* TrackInstance;
};

// Size: 0x10
struct FMovieSceneTrackInstanceInput {
    /* 0x0000 */ UMovieSceneSection* Section;
};

// Size: 0xf0
class UMovieSceneTrackInstanceInstantiator : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x48
class UMovieSceneTrackInstanceSystem : public UMovieSceneEntitySystem {
    /* 0x0040 */ UMovieSceneTrackInstanceInstantiator* Instantiator;
};

// Size: 0x10
struct FMovieSceneTrackLabels {
    /* 0x0000 */ TArray<FString> Strings;
};

// Size: 0x8
struct FMovieSceneTrackRowMetadata {
    /* 0x0000 */ FMovieSceneConditionContainer ConditionContainer;
};

// Size: 0x28
class IMovieSceneTrackTemplateProducer : public UInterface {
};

// Size: 0x18
struct FMovieSceneTransformBreadcrumbs {
    /* 0x0000 */ TArray<FFrameTime> Breadcrumbs;
    /* 0x0010 */ EMovieSceneBreadcrumbMode Mode;
};

// Size: 0x28
class IMovieSceneValueDecomposer : public UInterface {
};

// Size: 0x28
struct FMovieSceneWarpCounter : public FMovieSceneTransformBreadcrumbs {
};

// Size: 0xf8
struct FNavigationToolSaveState {
    /* 0x0000 */ FNavigationToolSerializedTree SerializedTree;
    /* 0x0088 */ TMap<FString, FColor> ItemColorMap;
    /* 0x00d8 */ TArray<FNavigationToolViewSaveState> ToolViewSaveStates;
    /* 0x00e8 */ FString ContextPath;
};

// Size: 0x10
struct FNavigationToolSerializedItem {
    /* 0x0000 */ FString ID;
};

// Size: 0x88
struct FNavigationToolSerializedTree {
    /* 0x0000 */ FNavigationToolSerializedTreeNode RootNode;
    /* 0x0028 */ TArray<FNavigationToolSerializedItem> SceneItems;
    /* 0x0038 */ TMap<FNavigationToolSerializedItem, FNavigationToolSerializedTreeNode> ItemTreeMap;
};

// Size: 0x28
struct FNavigationToolSerializedTreeNode {
    /* 0x0000 */ int32_t LocalIndex;
    /* 0x0004 */ int32_t GlobalIndex;
    /* 0x0008 */ int32_t ParentIndex;
    /* 0x0010 */ TArray<int32_t> ChildrenIndices;
};

// Size: 0x8
struct FNavigationToolViewColumnSaveState {
    /* 0x0000 */ bool bVisible;
    /* 0x0004 */ float Size;
};

// Size: 0xf0
struct FNavigationToolViewSaveState {
    /* 0x0000 */ TMap<FString, ENavigationToolItemFlags> ViewItemFlags;
    /* 0x0050 */ TMap<FName, FNavigationToolViewColumnSaveState> ColumnsState;
    /* 0x00a0 */ TSet<FName> ActiveItemFilters;
};

// Size: 0x28
class INodeAndChannelMappings : public UInterface {
};

// Size: 0x2
struct FOptionalMovieSceneBlendType {
    /* 0x0000 */ EMovieSceneBlendType BlendType;
    /* 0x0001 */ bool bIsValid;
};

// Size: 0xc
struct FSectionEvaluationData {
    /* 0x0000 */ int32_t ImplIndex;
    /* 0x0004 */ FFrameNumber ForcedTime;
    /* 0x0008 */ ESectionEvaluationFlags Flags;
};

// Size: 0x300
class ATestMovieSceneArrayPropertiesActor : public AActor {
    /* 0x02a8 */ FVector TestVector;
    /* 0x02c0 */ TArray<float> MultipleFloats;
    /* 0x02d0 */ FTestMovieSceneStruct SingleStruct;
    /* 0x02f0 */ TArray<FTestMovieSceneStruct> MultipleStructs;
};

// Size: 0x138
class UTestMovieSceneEvalHookSection : public UMovieSceneHookSection {
};

// Size: 0x120
class UTestMovieSceneEvalHookTrack : public UMovieSceneTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> SectionArray;
};

// Size: 0x20
struct FTestMovieSceneEvalTemplate : public FMovieSceneEvalTemplate {
};

// Size: 0x108
class UTestMovieSceneSection : public UMovieSceneSection {
};

// Size: 0x70
class UTestMovieSceneSequence : public UMovieSceneSequence {
    /* 0x0068 */ UMovieScene* MovieScene;
};

// Size: 0x20
struct FTestMovieSceneStruct {
    /* 0x0000 */ float First;
    /* 0x0004 */ float Second;
    /* 0x0008 */ FVector Vector;
};

// Size: 0x7f0
class UTestMovieSceneSubSection : public UMovieSceneSubSection {
};

// Size: 0x130
class UTestMovieSceneSubTrack : public UMovieSceneSubTrack {
    /* 0x0120 */ TArray<UMovieSceneSection*> SectionArray;
};

// Size: 0x130
class UTestMovieSceneTrack : public UMovieSceneTrack {
    /* 0x0118 */ bool bHighPassFilter;
    /* 0x0120 */ TArray<UMovieSceneSection*> SectionArray;
};

// Size: 0x10
struct FTrackInstanceInputComponent {
    /* 0x0000 */ UMovieSceneSection* Section;
    /* 0x0008 */ int32_t OutputIndex;
};

// Size: 0x8
struct FCaptureResolution {
    /* 0x0000 */ int32_t ResX;
    /* 0x0004 */ int32_t ResY;
};

// Size: 0x10
struct FCapturedPixels {
};

// Size: 0x50
struct FCapturedPixelsID {
    /* 0x0000 */ TMap<FName, FName> Identifiers;
};

// Size: 0x10
struct FCompositionGraphCapturePasses {
    /* 0x0000 */ TArray<FString> Value;
};

// Size: 0xc8
class UCompositionGraphCaptureProtocol : public UMovieSceneImageCaptureProtocolBase {
    /* 0x0058 */ FCompositionGraphCapturePasses IncludeRenderPasses;
    /* 0x0068 */ bool bCaptureFramesInHDR;
    /* 0x006c */ int32_t HDRCompressionQuality;
    /* 0x0070 */ uint8_t CaptureGamut;
    /* 0x0078 */ FSoftObjectPath PostProcessingMaterial;
    /* 0x0098 */ bool bDisableScreenPercentage;
    /* 0x00a0 */ UMaterialInterface* PostProcessingMaterialPtr;
};

// Size: 0xe0
class UCompressedImageSequenceProtocol : public UImageSequenceProtocol {
    /* 0x00d8 */ int32_t CompressionQuality;
};

enum class EHDRCaptureGamut {
    HCGM_Rec709 = 0,
    HCGM_P3DCI = 1,
    HCGM_Rec2020 = 2,
    HCGM_ACES = 3,
    HCGM_ACEScg = 4,
    HCGM_Linear = 5,
    HCGM_MAX = 6,
};

enum class EMovieSceneCaptureProtocolState {
    Idle = 0,
    Initialized = 1,
    Capturing = 2,
    Finalizing = 3,
    EMovieSceneCaptureProtocolState_MAX = 4,
};

// Size: 0x68
class UFrameGrabberProtocol : public UMovieSceneImageCaptureProtocolBase {
};

// Size: 0x10
struct FFrameMetrics {
    /* 0x0000 */ float TotalElapsedTime;
    /* 0x0004 */ float FrameDelta;
    /* 0x0008 */ int32_t FrameNumber;
    /* 0x000c */ int32_t NumDroppedFrames;
};

// Size: 0xd8
class UImageSequenceProtocol : public UFrameGrabberProtocol {
};

// Size: 0xd8
class UImageSequenceProtocol_BMP : public UImageSequenceProtocol {
};

// Size: 0xe8
class UImageSequenceProtocol_EXR : public UImageSequenceProtocol {
    /* 0x00d8 */ bool bCompressed;
    /* 0x00d9 */ uint8_t CaptureGamut;
};

// Size: 0xe0
class UImageSequenceProtocol_JPG : public UCompressedImageSequenceProtocol {
};

// Size: 0xe0
class UImageSequenceProtocol_PNG : public UCompressedImageSequenceProtocol {
};

// Size: 0x258
class ULevelCapture : public UMovieSceneCapture {
    /* 0x0238 */ bool bAutoStartCapture;
    /* 0x0244 */ FGuid PrerequisiteActorId;
};

// Size: 0x90
class UMasterAudioSubmixCaptureProtocol : public UMovieSceneAudioCaptureProtocolBase {
    /* 0x0058 */ FString Filename;
};

// Size: 0x58
class UMovieSceneAudioCaptureProtocolBase : public UMovieSceneCaptureProtocolBase {
};

// Size: 0x238
class UMovieSceneCapture : public UObject {
    /* 0x0038 */ FSoftClassPath ImageCaptureProtocolType;
    /* 0x0058 */ FSoftClassPath AudioCaptureProtocolType;
    /* 0x0078 */ UMovieSceneImageCaptureProtocolBase* ImageCaptureProtocol;
    /* 0x0080 */ UMovieSceneAudioCaptureProtocolBase* AudioCaptureProtocol;
    /* 0x0088 */ FMovieSceneCaptureSettings Settings;
    /* 0x00f8 */ bool bUseSeparateProcess;
    /* 0x00f9 */ bool bCloseEditorWhenCaptureStarts;
    /* 0x0100 */ FString AdditionalCommandLineArguments;
    /* 0x0110 */ FString InheritedCommandLineArguments;

    UMovieSceneCaptureProtocolBase* GetAudioCaptureProtocol();
    UMovieSceneCaptureProtocolBase* GetImageCaptureProtocol();
    void SetAudioCaptureProtocolType(UClass* ProtocolType);
    void SetImageCaptureProtocolType(UClass* ProtocolType);
};

// Size: 0x28
class UMovieSceneCaptureEnvironment : public UObject {

    static UMovieSceneAudioCaptureProtocolBase* FindAudioCaptureProtocol();
    static UMovieSceneImageCaptureProtocolBase* FindImageCaptureProtocol();
    static float GetCaptureElapsedTime();
    static int32_t GetCaptureFrameNumber();
    static bool IsCaptureInProgress();
};

// Size: 0x28
class IMovieSceneCaptureInterface : public UInterface {
};

// Size: 0x58
class UMovieSceneCaptureProtocolBase : public UObject {
    /* 0x0050 */ EMovieSceneCaptureProtocolState State;

    EMovieSceneCaptureProtocolState GetState() const;
    bool IsCapturing() const;
};

// Size: 0x70
struct FMovieSceneCaptureSettings {
    /* 0x0000 */ FDirectoryPath OutputDirectory;
    /* 0x0010 */ UClass* GameModeOverride;
    /* 0x0018 */ FString OutputFormat;
    /* 0x0028 */ bool bOverwriteExisting;
    /* 0x0029 */ bool bUseRelativeFrameNumbers;
    /* 0x002c */ int32_t HandleFrames;
    /* 0x0030 */ FString MovieExtension;
    /* 0x0040 */ uint8_t ZeroPadFrameNumbers;
    /* 0x0044 */ FFrameRate FrameRate;
    /* 0x004c */ bool bUseCustomFrameRate;
    /* 0x0050 */ FFrameRate CustomFrameRate;
    /* 0x0058 */ FCaptureResolution Resolution;
    /* 0x0060 */ bool bEnableTextureStreaming;
    /* 0x0061 */ bool bCinematicEngineScalability;
    /* 0x0062 */ bool bCinematicMode;
    /* 0x0063 */ bool bAllowMovement;
    /* 0x0064 */ bool bAllowTurning;
    /* 0x0065 */ bool bShowPlayer;
    /* 0x0066 */ bool bShowHUD;
    /* 0x0067 */ bool bUsePathTracer;
    /* 0x0068 */ int32_t PathTracerSamplePerPixel;
};

// Size: 0x58
class UMovieSceneImageCaptureProtocolBase : public UMovieSceneCaptureProtocolBase {
};

// Size: 0x58
class UNullAudioCaptureProtocol : public UMovieSceneAudioCaptureProtocolBase {
};

// Size: 0xd8
class UUserDefinedCaptureProtocol : public UMovieSceneImageCaptureProtocolBase {
    /* 0x0058 */ UWorld* World;

    FString GenerateFilename(const FFrameMetrics& InFrameMetrics) const;
    FFrameMetrics GetCurrentFrameMetrics() const;
    void OnBeginFinalize();
    bool OnCanFinalize() const;
    void OnCaptureFrame();
    void OnFinalize();
    void OnPauseCapture();
    void OnPixelsReceived(const FCapturedPixels& pixels, const FCapturedPixelsID& ID, FFrameMetrics FrameMetrics);
    void OnPreTick();
    bool OnSetup();
    void OnStartCapture();
    void OnTick();
    void OnWarmUp();
    void ResolveBuffer(UTexture* Buffer, const FCapturedPixelsID& BufferID);
    void StartCapturingFinalPixels(const FCapturedPixelsID& StreamID);
    void StopCapturingFinalPixels();
};

// Size: 0xe0
class UUserDefinedImageCaptureProtocol : public UUserDefinedCaptureProtocol {
    /* 0x00d8 */ EDesiredImageFormat Format;
    /* 0x00d9 */ bool bEnableCompression;
    /* 0x00dc */ int32_t CompressionQuality;

    FString GenerateFilenameForBuffer(UTexture* Buffer, const FCapturedPixelsID& StreamID);
    FString GenerateFilenameForCurrentFrame();
    void WriteImageToDisk(const FCapturedPixels& PixelData, const FCapturedPixelsID& StreamID, const FFrameMetrics& FrameMetrics, bool bCopyImageData);
};

// Size: 0x80
class UVideoCaptureProtocol : public UFrameGrabberProtocol {
    /* 0x0068 */ bool bUseCompression;
    /* 0x006c */ float CompressionQuality;
};

// Size: 0x8
struct FBaseParameterNameAndValue {
    /* 0x0000 */ FName ParameterName;
};

// Size: 0x40
class UBoolChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x110
struct FBoolParameterNameAndCurve : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneBoolChannel ParameterCurve;
};

// Size: 0x40
class UByteChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x450
struct FColorMaterialParameterInfoAndCurves {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ FMovieSceneFloatChannel RedCurve;
    /* 0x0120 */ FMovieSceneFloatChannel GreenCurve;
    /* 0x0230 */ FMovieSceneFloatChannel BlueCurve;
    /* 0x0340 */ FMovieSceneFloatChannel AlphaCurve;
};

// Size: 0x448
struct FColorParameterNameAndCurves : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneFloatChannel RedCurve;
    /* 0x0118 */ FMovieSceneFloatChannel GreenCurve;
    /* 0x0228 */ FMovieSceneFloatChannel BlueCurve;
    /* 0x0338 */ FMovieSceneFloatChannel AlphaCurve;
};

// Size: 0x10
struct FComponentMaterialInfo {
    /* 0x0000 */ FName MaterialSlotName;
    /* 0x0008 */ int32_t MaterialSlotIndex;
    /* 0x000c */ EComponentMaterialType MaterialType;
};

// Size: 0x18
struct FConstraintComponentData {
    /* 0x0000 */ FGuid ConstraintID;
};

// Size: 0x40
class UDoubleChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x40
class UDoublePerlinNoiseChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

enum class EComponentMaterialType {
    Empty = 0,
    IndexedMaterial = 1,
    OverlayMaterial = 2,
    DecalMaterial = 3,
    VolumetricCloudMaterial = 4,
    EComponentMaterialType_MAX = 5,
};

enum class EFireEventsAtPosition {
    AtStartOfEvaluation = 0,
    AtEndOfEvaluation = 1,
    AfterSpawn = 2,
    EFireEventsAtPosition_MAX = 3,
};

enum class ELevelVisibility {
    Visible = 0,
    Hidden = 1,
    ELevelVisibility_MAX = 2,
};

enum class EMovieSceneScalabilityConditionGroup {
    ViewDistance = 0,
    AntiAliasing = 1,
    Shadow = 2,
    GlobalIllumination = 3,
    Reflection = 4,
    PostProcess = 5,
    Texture = 6,
    Effects = 7,
    Foliage = 8,
    Shading = 9,
    Landscape = 10,
    EMovieSceneScalabilityConditionGroup_MAX = 11,
};

enum class EMovieSceneScalabilityConditionLevel {
    Low = 0,
    Medium = 1,
    High = 2,
    Epic = 3,
    Cinematic = 4,
    EMovieSceneScalabilityConditionLevel_MAX = 5,
};

enum class EMovieSceneScalabilityConditionOperator {
    LessThan = 0,
    LessThanOrEqualTo = 1,
    EqualTo = 2,
    GreaterThanOrEqualTo = 3,
    GreaterThan = 4,
    EMovieSceneScalabilityConditionOperator_MAX = 5,
};

enum class EParticleKey {
    Activate = 0,
    Deactivate = 1,
    Trigger = 2,
    EParticleKey_MAX = 3,
};

// Size: 0x48
struct FEventPayload {
    /* 0x0000 */ FName EventName;
    /* 0x0008 */ FMovieSceneEventParameters Parameters;
};

// Size: 0x40
class UFloatChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x40
class UFloatPerlinNoiseChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x40
class UIntegerChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x8
struct FLevelVisibilityComponentData {
    /* 0x0000 */ UMovieSceneLevelVisibilitySection* Section;
};

// Size: 0x150
class UMovieScene3DAttachSection : public UMovieScene3DConstraintSection {
    /* 0x0138 */ FName AttachSocketName;
    /* 0x0140 */ FName AttachComponentName;
    /* 0x0148 */ EAttachmentRule AttachmentLocationRule;
    /* 0x0149 */ EAttachmentRule AttachmentRotationRule;
    /* 0x014a */ EAttachmentRule AttachmentScaleRule;
    /* 0x014b */ EDetachmentRule DetachmentLocationRule;
    /* 0x014c */ EDetachmentRule DetachmentRotationRule;
    /* 0x014d */ EDetachmentRule DetachmentScaleRule;
};

// Size: 0x120
class UMovieScene3DAttachTrack : public UMovieScene3DConstraintTrack {
};

// Size: 0x130
class UMovieScene3DConstraintSection : public UMovieSceneSection {
    /* 0x0108 */ FGuid ConstraintID;
    /* 0x0118 */ FMovieSceneObjectBindingID ConstraintBindingID;

    FMovieSceneObjectBindingID GetConstraintBindingID() const;
    void SetConstraintBindingID(const FMovieSceneObjectBindingID& InConstraintBindingID);
};

// Size: 0x120
class UMovieScene3DConstraintTrack : public UMovieSceneTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> ConstraintSections;
};

// Size: 0x40
struct FMovieScene3DLocationKeyStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FFrameNumber Time;
};

// Size: 0x248
class UMovieScene3DPathSection : public UMovieScene3DConstraintSection {
    /* 0x0130 */ FMovieSceneFloatChannel TimingCurve;
    /* 0x0240 */ MovieScene3DPathSection_Axis FrontAxisEnum;
    /* 0x0241 */ MovieScene3DPathSection_Axis UpAxisEnum;
    /* 0x0244 */ bool bFollow;
    /* 0x0244 */ bool bReverse;
    /* 0x0244 */ bool bForceUpright;
};

// Size: 0x150
struct FMovieScene3DPathSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneObjectBindingID PathBindingID;
    /* 0x0038 */ FMovieSceneFloatChannel TimingCurve;
    /* 0x0148 */ MovieScene3DPathSection_Axis FrontAxisEnum;
    /* 0x0149 */ MovieScene3DPathSection_Axis UpAxisEnum;
    /* 0x014c */ bool bFollow;
    /* 0x014c */ bool bReverse;
    /* 0x014c */ bool bForceUpright;
};

enum class MovieScene3DPathSection_Axis {
    X = 0,
    Y = 1,
    Z = 2,
    NEG_X = 3,
    NEG_Y = 4,
    NEG_Z = 5,
    MovieScene3DPathSection_MAX = 6,
};

// Size: 0x128
class UMovieScene3DPathTrack : public UMovieScene3DConstraintTrack {
};

// Size: 0x40
struct FMovieScene3DRotationKeyStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FRotator Rotation;
    /* 0x0020 */ FFrameNumber Time;
};

// Size: 0x30
struct FMovieScene3DScaleKeyStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FVector3f Scale;
    /* 0x0014 */ FFrameNumber Time;
};

// Size: 0x60
struct FMovieScene3DTransformKeyStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FRotator Rotation;
    /* 0x0038 */ FVector3f Scale;
    /* 0x0044 */ FFrameNumber Time;
};

// Size: 0x58
class UMovieScene3DTransformPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0xc50
class UMovieScene3DTransformSection : public UMovieSceneSection {
    /* 0x0148 */ FMovieSceneTransformMask TransformMask;
    /* 0x0150 */ FMovieSceneDoubleChannel Translation[3];
    /* 0x0498 */ FMovieSceneDoubleChannel Rotation[3];
    /* 0x07e0 */ FMovieSceneDoubleChannel Scale[3];
    /* 0x0b28 */ FMovieSceneFloatChannel ManualWeight;
    /* 0x0c38 */ UMovieSceneSectionChannelOverrideRegistry* OverrideRegistry;
    /* 0x0c40 */ UMovieScene3DTransformSectionConstraints* Constraints;
    /* 0x0c48 */ bool bUseQuaternionInterpolation;
};

// Size: 0x38
class UMovieScene3DTransformSectionConstraints : public UObject {
    /* 0x0028 */ TArray<FConstraintAndActiveChannel> ConstraintsChannels;
};

// Size: 0x150
class UMovieScene3DTransformTrack : public UMovieScenePropertyTrack {
    /* 0x0148 */ UClass* BlenderSystemClass;
};

// Size: 0x120
struct FMovieSceneActorReferenceData : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> KeyTimes;
    /* 0x0060 */ FMovieSceneActorReferenceKey DefaultValue;
    /* 0x0088 */ TArray<FMovieSceneActorReferenceKey> KeyValues;
    /* 0x0098 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x28
struct FMovieSceneActorReferenceKey {
    /* 0x0000 */ FMovieSceneObjectBindingID Object;
    /* 0x0018 */ FName ComponentName;
    /* 0x0020 */ FName SocketName;
};

// Size: 0x2b8
class UMovieSceneActorReferenceSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneActorReferenceData ActorReferenceData;
    /* 0x0228 */ FIntegralCurve ActorGuidIndexCurve;
    /* 0x02a8 */ TArray<FString> ActorGuidStrings;
};

// Size: 0x158
struct FMovieSceneActorReferenceSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieScenePropertySectionData PropertyData;
    /* 0x0038 */ FMovieSceneActorReferenceData ActorReferenceData;
};

// Size: 0x148
class UMovieSceneActorReferenceTrack : public UMovieScenePropertyTrack {
};

// Size: 0x80
class UMovieSceneAsyncAction_SequencePrediction : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate Result;
    /* 0x0040 */ FMulticastInlineDelegate Failure;
    /* 0x0060 */ UMovieSceneSequencePlayer* SequencePlayer;
    /* 0x0068 */ USceneComponent* SceneComponent;

    static UMovieSceneAsyncAction_SequencePrediction* PredictLocalTransformAtFrame(UMovieSceneSequencePlayer* Player, USceneComponent* TargetComponent, FFrameTime FrameTime);
    static UMovieSceneAsyncAction_SequencePrediction* PredictLocalTransformAtTime(UMovieSceneSequencePlayer* Player, USceneComponent* TargetComponent, float TimeInSeconds);
    static UMovieSceneAsyncAction_SequencePrediction* PredictWorldTransformAtFrame(UMovieSceneSequencePlayer* Player, USceneComponent* TargetComponent, FFrameTime FrameTime);
    static UMovieSceneAsyncAction_SequencePrediction* PredictWorldTransformAtTime(UMovieSceneSequencePlayer* Player, USceneComponent* TargetComponent, float TimeInSeconds);
};

// Size: 0x8
struct FMovieSceneAudioComponentData {
    /* 0x0000 */ UMovieSceneAudioSection* Section;
};

// Size: 0x60
struct FMovieSceneAudioInputData {
    /* 0x0000 */ FName FloatInputs[9];
    /* 0x0048 */ FName StringInput;
    /* 0x0050 */ FName BoolInput;
    /* 0x0058 */ FName IntInput;
};

// Size: 0x648
class UMovieSceneAudioSection : public UMovieSceneSection {
    /* 0x0118 */ USoundBase* Sound;
    /* 0x0120 */ FFrameNumber StartFrameOffset;
    /* 0x0124 */ float StartOffset;
    /* 0x0128 */ float AudioStartTime;
    /* 0x012c */ float AudioDilationFactor;
    /* 0x0130 */ float AudioVolume;
    /* 0x0138 */ FMovieSceneFloatChannel SoundVolume;
    /* 0x0248 */ FMovieSceneFloatChannel PitchMultiplier;
    /* 0x0358 */ TMap<FName, FMovieSceneFloatChannel> Inputs_Float;
    /* 0x03a8 */ TMap<FName, FMovieSceneStringChannel> Inputs_String;
    /* 0x03f8 */ TMap<FName, FMovieSceneBoolChannel> Inputs_Bool;
    /* 0x0448 */ TMap<FName, FMovieSceneIntegerChannel> Inputs_Int;
    /* 0x0498 */ TMap<FName, FMovieSceneAudioTriggerChannel> Inputs_Trigger;
    /* 0x04e8 */ FMovieSceneActorReferenceData AttachActorData;
    /* 0x0608 */ bool bLooping;
    /* 0x0609 */ bool bSuppressSubtitles;
    /* 0x060a */ bool bOverrideAttenuation;
    /* 0x0610 */ USoundAttenuation* AttenuationSettings;
    /* 0x0618 */ FDelegate OnQueueSubtitles;
    /* 0x0628 */ FMulticastInlineDelegate OnAudioFinished;
    /* 0x0638 */ FMulticastInlineDelegate OnAudioPlaybackPercent;

    USoundAttenuation* GetAttenuationSettings() const;
    bool GetLooping() const;
    bool GetOverrideAttenuation() const;
    USoundBase* GetPlaybackSound() const;
    USoundBase* GetSound() const;
    FFrameNumber GetStartOffset() const;
    bool GetSuppressSubtitles() const;
    void SetAttenuationSettings(USoundAttenuation* InAttenuationSettings);
    void SetLooping(bool bInLooping);
    void SetOverrideAttenuation(bool bInOverrideAttenuation);
    void SetSound(USoundBase* InSound);
    void SetStartOffset(FFrameNumber InStartOffset);
    void SetSuppressSubtitles(bool bInSuppressSubtitles);
};

// Size: 0xf0
class UMovieSceneAudioSystem : public UMovieSceneEntitySystem {
};

// Size: 0x120
class UMovieSceneAudioTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> AudioSections;
};

// Size: 0x20
struct FMovieSceneBaseCacheParams {
    /* 0x0008 */ FFrameNumber FirstLoopStartFrameOffset;
    /* 0x000c */ FFrameNumber StartFrameOffset;
    /* 0x0010 */ FFrameNumber EndFrameOffset;
    /* 0x0014 */ float PlayRate;
    /* 0x0018 */ bool bReverse;
};

// Size: 0x110
class UMovieSceneBaseCacheSection : public UMovieSceneSection {
};

// Size: 0x8
struct FMovieSceneBaseCacheSectionTemplateParameters {
    /* 0x0000 */ FFrameNumber SectionStartTime;
    /* 0x0004 */ FFrameNumber SectionEndTime;
};

// Size: 0x40
class UMovieSceneBaseValueEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x140
struct FMovieSceneBoolPropertySectionTemplate : public FMovieScenePropertySectionTemplate {
    /* 0x0038 */ FMovieSceneBoolChannel BoolCurve;
};

// Size: 0x58
class UMovieSceneBoolPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x148
class UMovieSceneBoolTrack : public UMovieScenePropertyTrack {
};

// Size: 0x58
class UMovieSceneBytePropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x220
class UMovieSceneByteSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneByteChannel ByteCurve;
};

// Size: 0x148
class UMovieSceneByteTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ UEnum* Enum;
};

// Size: 0x50
struct FMovieSceneCVarOverrides {
    /* 0x0000 */ TMap<FString, FString> ValuesByCVar;
};

// Size: 0x170
class UMovieSceneCVarSection : public UMovieSceneSection {
    /* 0x0110 */ TArray<FMovieSceneConsoleVariableCollection> ConsoleVariableCollections;
    /* 0x0120 */ FMovieSceneCVarOverrides ConsoleVariables;

    FString GetString() const;
    void SetFromString(FString InString);
};

// Size: 0x120
class UMovieSceneCVarTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0xa0
class UMovieSceneCVarTrackInstance : public UMovieSceneTrackInstance {
};

// Size: 0x1b0
class UMovieSceneCameraCutSection : public UMovieSceneSection {
    /* 0x0110 */ bool bLockPreviousCamera;
    /* 0x0114 */ FGuid CameraGuid;
    /* 0x0124 */ FMovieSceneObjectBindingID CameraBindingID;
    /* 0x0140 */ FTransform InitialCameraCutTransform;
    /* 0x01a0 */ bool bHasInitialCameraCutTransform;

    FMovieSceneObjectBindingID GetCameraBindingID() const;
    void SetCameraBindingID(const FMovieSceneObjectBindingID& InCameraBindingID);
};

// Size: 0x130
class UMovieSceneCameraCutTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ bool bCanBlend;
    /* 0x0118 */ TArray<UMovieSceneSection*> Sections;
    /* 0x0128 */ bool bAutoArrangeSections;
};

// Size: 0x78
class UMovieSceneCameraCutTrackInstance : public UMovieSceneTrackInstance {
};

// Size: 0x40
struct FMovieSceneCameraShakeComponentData {
    /* 0x0000 */ FMovieSceneCameraShakeSectionData SectionData;
    /* 0x0028 */ FFrameNumber SectionStartTime;
    /* 0x002c */ FFrameNumber SectionEndTime;
    /* 0x0030 */ FGuid SectionSignature;
};

// Size: 0x40
class UMovieSceneCameraShakeEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x20
struct FMovieSceneCameraShakeInstanceData {
    /* 0x0000 */ UCameraShakeBase* ShakeInstance;
    /* 0x0008 */ FGuid SectionSignature;
    /* 0x0018 */ bool bManagedByPreviewer;
};

// Size: 0xc0
class UMovieSceneCameraShakeInstantiatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x160
class UMovieSceneCameraShakeSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneCameraShakeSectionData ShakeData;
    /* 0x0138 */ UClass* ShakeClass;
    /* 0x0140 */ float PlayScale;
    /* 0x0144 */ ECameraShakePlaySpace PlaySpace;
    /* 0x0148 */ FRotator UserDefinedPlaySpace;
};

// Size: 0x28
struct FMovieSceneCameraShakeSectionData {
    /* 0x0000 */ UClass* ShakeClass;
    /* 0x0008 */ float PlayScale;
    /* 0x000c */ ECameraShakePlaySpace PlaySpace;
    /* 0x0010 */ FRotator UserDefinedPlaySpace;
};

// Size: 0x138
class UMovieSceneCameraShakeSourceShakeSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneCameraShakeSectionData ShakeData;
};

// Size: 0x120
class UMovieSceneCameraShakeSourceShakeTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> CameraShakeSections;
};

// Size: 0x28
struct FMovieSceneCameraShakeSourceTrigger {
    /* 0x0000 */ UClass* ShakeClass;
    /* 0x0008 */ float PlayScale;
    /* 0x000c */ ECameraShakePlaySpace PlaySpace;
    /* 0x0010 */ FRotator UserDefinedPlaySpace;
};

// Size: 0xf8
struct FMovieSceneCameraShakeSourceTriggerChannel : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> KeyTimes;
    /* 0x0060 */ TArray<FMovieSceneCameraShakeSourceTrigger> KeyValues;
    /* 0x0070 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x208
class UMovieSceneCameraShakeSourceTriggerSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneCameraShakeSourceTriggerChannel Channel;
};

// Size: 0x120
class UMovieSceneCameraShakeSourceTriggerTrack : public UMovieSceneTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x120
class UMovieSceneCameraShakeTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> CameraShakeSections;
};

// Size: 0x810
class UMovieSceneCinematicShotSection : public UMovieSceneSubSection {
    /* 0x07f0 */ FString ShotDisplayName;
    /* 0x0800 */ FText DisplayName;

    FString GetShotDisplayName() const;
    void SetShotDisplayName(FString InShotDisplayName);
};

// Size: 0x120
class UMovieSceneCinematicShotTrack : public UMovieSceneSubTrack {
};

// Size: 0x38
struct FMovieSceneColorKeyStruct : public FMovieSceneKeyStruct {
    /* 0x0008 */ FLinearColor Color;
    /* 0x0018 */ FFrameNumber Time;
};

// Size: 0x58
class UMovieSceneColorPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x550
class UMovieSceneColorSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneFloatChannel RedCurve;
    /* 0x0220 */ FMovieSceneFloatChannel GreenCurve;
    /* 0x0330 */ FMovieSceneFloatChannel BlueCurve;
    /* 0x0440 */ FMovieSceneFloatChannel AlphaCurve;
};

// Size: 0x148
class UMovieSceneColorTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ bool bIsSlateColor;
};

// Size: 0x1b0
class UMovieSceneCommonAnimationTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> AnimationSections;
    /* 0x0120 */ FMovieSceneSkeletalAnimRootMotionTrackParams RootMotionParams;
    /* 0x01a0 */ bool bBlendFirstChildOfRoot;
};

// Size: 0x40
class UMovieSceneComponentAttachmentInvalidatorSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x1d0
class UMovieSceneComponentAttachmentSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x130
class UMovieSceneComponentMaterialParameterSection : public UMovieSceneSection {
    /* 0x0110 */ TArray<FScalarMaterialParameterInfoAndCurve> ScalarParameterInfosAndCurves;
    /* 0x0120 */ TArray<FColorMaterialParameterInfoAndCurves> ColorParameterInfosAndCurves;

    void AddColorParameterKey(const FMaterialParameterInfo& InParameterInfo, FFrameNumber InTime, FLinearColor InValue, FString InLayerName, FString InAssetName, const FParameterChannelNames& InChannelNames);
    void AddScalarParameterKey(const FMaterialParameterInfo& InParameterInfo, FFrameNumber InTime, float InValue, FString InLayerName, FString InAssetName);
    bool RemoveColorParameter(const FMaterialParameterInfo& InParameterInfo);
    bool RemoveScalarParameter(const FMaterialParameterInfo& InParameterInfo);
};

// Size: 0x208
class UMovieSceneComponentMaterialSystem : public UMovieSceneEntitySystem {
};

// Size: 0x148
class UMovieSceneComponentMaterialTrack : public UMovieSceneMaterialTrack {
    /* 0x0138 */ FComponentMaterialInfo MaterialInfo;
};

// Size: 0x250
class UMovieSceneComponentMobilitySystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x58
class UMovieSceneComponentTransformSystem : public UMovieScenePropertySystem {
};

// Size: 0x18
struct FMovieSceneConsoleVariableCollection {
    /* 0x0000 */ TScriptInterface<IMovieSceneConsoleVariableTrackInterface> Interface;
    /* 0x0010 */ bool bOnlyIncludeChecked;
};

// Size: 0x28
class IMovieSceneConsoleVariableTrackInterface : public UInterface {
};

// Size: 0x28
class IMovieSceneConstrainedSection : public UInterface {
};

// Size: 0x50
class UMovieSceneConstraintSystem : public UMovieSceneEntitySystem {
};

// Size: 0x170
class UMovieSceneCustomPrimitiveDataSection : public UMovieSceneParameterSection {
};

// Size: 0x1d8
class UMovieSceneCustomPrimitiveDataSystem : public UMovieSceneEntitySystem {
    /* 0x01d0 */ UMovieScenePiecewiseDoubleBlenderSystem* DoubleBlenderSystem;
};

// Size: 0x138
class UMovieSceneCustomPrimitiveDataTrack : public UMovieSceneNameableTrack {
    /* 0x0120 */ TArray<UMovieSceneSection*> Sections;
    /* 0x0130 */ UMovieSceneSection* SectionToKey;
};

// Size: 0x8
struct FMovieSceneDataLayerComponentData {
    /* 0x0000 */ UMovieSceneDataLayerSection* Section;
};

// Size: 0x128
class UMovieSceneDataLayerSection : public UMovieSceneSection {
    /* 0x0110 */ TArray<UDataLayerAsset*> DataLayerAssets;
    /* 0x0120 */ EDataLayerRuntimeState DesiredState;
    /* 0x0121 */ EDataLayerRuntimeState PrerollState;
    /* 0x0122 */ bool bFlushOnActivated;
    /* 0x0123 */ bool bFlushOnUnload;

    TArray<UDataLayerAsset*> GetDataLayerAssets() const;
    EDataLayerRuntimeState GetDesiredState() const;
    bool GetFlushOnActivated() const;
    bool GetFlushOnUnload() const;
    EDataLayerRuntimeState GetPrerollState() const;
    bool HasPreRoll() const;
    void SetDataLayerAssets(const TArray<UDataLayerAsset*>& InDataLayerAssets);
    void SetDesiredState(EDataLayerRuntimeState InDesiredState);
    void SetFlushOnActivated(bool bFlushOnActivated);
    void SetFlushOnUnload(bool bFlushOnUnload);
    void SetPrerollState(EDataLayerRuntimeState InPrerollState);
};

// Size: 0xf0
class UMovieSceneDataLayerSystem : public UMovieSceneEntitySystem {
};

// Size: 0x120
class UMovieSceneDataLayerTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x30
class UMovieSceneDecomposerTestObject : public UObject {
    /* 0x0028 */ float FloatProperty;
};

// Size: 0x58
class UMovieSceneDeferredComponentMovementSystem : public UMovieSceneEntitySystem {
};

// Size: 0x90
class UMovieSceneDirectorBlueprintCondition : public UMovieSceneCondition {
    /* 0x0060 */ FMovieSceneDirectorBlueprintConditionData DirectorBlueprintConditionData;
    /* 0x0088 */ EMovieSceneConditionScope scope;
    /* 0x0089 */ EMovieSceneConditionCheckFrequency CheckFrequency;
};

// Size: 0x28
struct FMovieSceneDirectorBlueprintConditionData {
    /* 0x0000 */ UFunction* Function;
    /* 0x0008 */ FFieldPath ConditionContextProperty;
};

// Size: 0x30
struct FMovieSceneDirectorBlueprintConditionPayloadVariable {
    /* 0x0000 */ FSoftObjectPath ObjectValue;
    /* 0x0020 */ FString Value;
};

// Size: 0x68
struct FMovieSceneDoublePerlinNoiseChannel : public FMovieSceneChannel {
    /* 0x0050 */ FPerlinNoiseParams PerlinNoiseParams;
};

// Size: 0xc0
class UMovieSceneDoublePerlinNoiseChannelContainer : public UMovieSceneChannelOverrideContainer {
    /* 0x0058 */ FMovieSceneDoublePerlinNoiseChannel PerlinNoiseChannel;
};

// Size: 0x58
class UMovieSceneDoublePropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x228
class UMovieSceneDoubleSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneDoubleChannel DoubleCurve;
};

// Size: 0x140
class UMovieSceneDoubleTrack : public UMovieScenePropertyTrack {
};

// Size: 0x28
struct FMovieSceneDoubleVectorKeyStructBase : public FMovieSceneKeyStruct {
    /* 0x0008 */ FFrameNumber Time;
};

// Size: 0x58
class UMovieSceneDoubleVectorPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x578
class UMovieSceneDoubleVectorSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneDoubleChannel Curves[4];
    /* 0x0570 */ int32_t ChannelsUsed;
};

// Size: 0x148
class UMovieSceneDoubleVectorTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ int32_t NumChannelsUsed;
};

// Size: 0x58
class UMovieSceneEnumPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x220
class UMovieSceneEnumSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneByteChannel EnumCurve;
};

// Size: 0x148
class UMovieSceneEnumTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ UEnum* Enum;
};

// Size: 0x58
class UMovieSceneEulerTransformPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x140
class UMovieSceneEulerTransformTrack : public UMovieScenePropertyTrack {
};

// Size: 0x28
struct FMovieSceneEvent {
    /* 0x0000 */ FMovieSceneEventPtrs Ptrs;
};

// Size: 0xf8
struct FMovieSceneEventChannel : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> KeyTimes;
    /* 0x0060 */ TArray<FMovieSceneEvent> KeyValues;
    /* 0x0070 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x40
struct FMovieSceneEventParameters {
};

// Size: 0x30
struct FMovieSceneEventPayloadVariable {
    /* 0x0000 */ FSoftObjectPath ObjectValue;
    /* 0x0020 */ FString Value;
};

// Size: 0x28
struct FMovieSceneEventPtrs {
    /* 0x0000 */ UFunction* Function;
    /* 0x0008 */ FFieldPath BoundObjectProperty;
};

// Size: 0x138
class UMovieSceneEventRepeaterSection : public UMovieSceneEventSectionBase {
    /* 0x0110 */ FMovieSceneEvent Event;
};

// Size: 0x278
class UMovieSceneEventSection : public UMovieSceneSection {
    /* 0x0108 */ FNameCurve Events;
    /* 0x0180 */ FMovieSceneEventSectionData EventData;
};

// Size: 0x108
class UMovieSceneEventSectionBase : public UMovieSceneSection {
};

// Size: 0xf8
struct FMovieSceneEventSectionData : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> Times;
    /* 0x0060 */ TArray<FEventPayload> KeyValues;
    /* 0x0070 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x120
struct FMovieSceneEventSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneEventSectionData EventData;
    /* 0x0118 */ bool bFireEventsWhenForwards;
    /* 0x0118 */ bool bFireEventsWhenBackwards;
};

// Size: 0x90
class UMovieSceneEventSystem : public UMovieSceneEntitySystem {
};

// Size: 0x138
class UMovieSceneEventTrack : public UMovieSceneNameableTrack {
    /* 0x0120 */ bool bFireEventsWhenForwards;
    /* 0x0120 */ bool bFireEventsWhenBackwards;
    /* 0x0124 */ EFireEventsAtPosition EventPosition;
    /* 0x0128 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x48
struct FMovieSceneEventTriggerData {
    /* 0x0000 */ FMovieSceneEventPtrs Ptrs;
    /* 0x0028 */ FGuid ObjectBindingID;
};

// Size: 0x208
class UMovieSceneEventTriggerSection : public UMovieSceneEventSectionBase {
    /* 0x0110 */ FMovieSceneEventChannel EventChannel;
};

// Size: 0x238
class UMovieSceneFadeSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneFloatChannel FloatCurve;
    /* 0x0220 */ FLinearColor FadeColor;
    /* 0x0230 */ bool bFadeAudio;
};

// Size: 0x50
class UMovieSceneFadeSystem : public UMovieSceneEntitySystem {
};

// Size: 0x140
class UMovieSceneFadeTrack : public UMovieSceneFloatTrack {
};

// Size: 0x28
class UMovieSceneFadeTrackTestLibrary : public UBlueprintFunctionLibrary {

    static float GetManualFadeAmount(APlayerCameraManager* PlayerCameraManager);
};

// Size: 0x68
struct FMovieSceneFloatPerlinNoiseChannel : public FMovieSceneChannel {
    /* 0x0050 */ FPerlinNoiseParams PerlinNoiseParams;
};

// Size: 0xc0
class UMovieSceneFloatPerlinNoiseChannelContainer : public UMovieSceneChannelOverrideContainer {
    /* 0x0058 */ FMovieSceneFloatPerlinNoiseChannel PerlinNoiseChannel;
};

// Size: 0x58
class UMovieSceneFloatPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x230
class UMovieSceneFloatSection : public UMovieSceneSection {
    /* 0x0118 */ FMovieSceneFloatChannel FloatCurve;
    /* 0x0228 */ UMovieSceneSectionChannelOverrideRegistry* OverrideRegistry;
};

// Size: 0x140
class UMovieSceneFloatTrack : public UMovieScenePropertyTrack {
};

// Size: 0x28
struct FMovieSceneFloatVectorKeyStructBase : public FMovieSceneKeyStruct {
    /* 0x0008 */ FFrameNumber Time;
};

// Size: 0x58
class UMovieSceneFloatVectorPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x558
class UMovieSceneFloatVectorSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneFloatChannel Curves[4];
    /* 0x0550 */ int32_t ChannelsUsed;
};

// Size: 0x148
class UMovieSceneFloatVectorTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ int32_t NumChannelsUsed;
};

// Size: 0x48
class UMovieSceneHierarchicalBiasSystem : public UMovieSceneEntityInstantiatorSystem {
    /* 0x0040 */ UMovieSceneEntityGroupingSystem* GroupingSystem;
};

// Size: 0x40
class UMovieSceneHierarchicalEasingFinalizationSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0xd8
class UMovieSceneHierarchicalEasingInstantiatorSystem : public UMovieSceneEntityInstantiatorSystem {
    /* 0x00c8 */ UWeightAndEasingEvaluatorSystem* EvaluatorSystem;
};

// Size: 0x58
class UMovieSceneIntegerPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x218
class UMovieSceneIntegerSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneIntegerChannel IntegerCurve;
};

// Size: 0x140
class UMovieSceneIntegerTrack : public UMovieScenePropertyTrack {
};

// Size: 0x200
class UMovieSceneInterrogatedPropertyInstantiatorSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x128
class UMovieSceneLevelVisibilitySection : public UMovieSceneSection {
    /* 0x0110 */ ELevelVisibility Visibility;
    /* 0x0118 */ TArray<FName> LevelNames;

    TArray<FName> GetLevelNames() const;
    ELevelVisibility GetVisibility() const;
    void SetLevelNames(const TArray<FName>& InLevelNames);
    void SetVisibility(ELevelVisibility InVisibility);
};

// Size: 0x1c8
class UMovieSceneLevelVisibilitySystem : public UMovieSceneEntitySystem {
};

// Size: 0x120
class UMovieSceneLevelVisibilityTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x68
class UMovieSceneMaterialParameterCollectionSystem : public UMovieSceneEntitySystem {
};

// Size: 0x140
class UMovieSceneMaterialParameterCollectionTrack : public UMovieSceneMaterialTrack {
    /* 0x0138 */ UMaterialParameterCollection* MPC;
};

// Size: 0x40
class UMovieSceneMaterialParameterEvaluationSystem : public UMovieSceneEntitySystem {
};

// Size: 0x358
class UMovieSceneMaterialParameterInstantiatorSystem : public UMovieSceneEntityInstantiatorSystem {
    /* 0x0350 */ UMovieScenePiecewiseDoubleBlenderSystem* DoubleBlenderSystem;
};

// Size: 0x128
class UMovieSceneMaterialTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
    /* 0x0120 */ UMovieSceneSection* SectionToKey;
};

// Size: 0x10
struct FMovieSceneMixedAnimationTarget {
};

// Size: 0x98
class UMovieSceneMotionVectorSimulationSystem : public UMovieSceneEntitySystem {
};

// Size: 0x240
class UMovieSceneObjectPropertySection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneObjectPathChannel ObjectChannel;
};

// Size: 0x58
class UMovieSceneObjectPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x148
class UMovieSceneObjectPropertyTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ UClass* PropertyClass;
};

// Size: 0x170
class UMovieSceneParameterSection : public UMovieSceneSection {
    /* 0x0110 */ TArray<FBoolParameterNameAndCurve> BoolParameterNamesAndCurves;
    /* 0x0120 */ TArray<FScalarParameterNameAndCurve> ScalarParameterNamesAndCurves;
    /* 0x0130 */ TArray<FVector2DParameterNameAndCurves> Vector2DParameterNamesAndCurves;
    /* 0x0140 */ TArray<FVectorParameterNameAndCurves> VectorParameterNamesAndCurves;
    /* 0x0150 */ TArray<FColorParameterNameAndCurves> ColorParameterNamesAndCurves;
    /* 0x0160 */ TArray<FTransformParameterNameAndCurves> TransformParameterNamesAndCurves;

    void AddBoolParameterKey(FName InParameterName, FFrameNumber InTime, bool InValue);
    void AddColorParameterKey(FName InParameterName, FFrameNumber InTime, FLinearColor InValue);
    void AddScalarParameterKey(FName InParameterName, FFrameNumber InTime, float InValue);
    void AddTransformParameterKey(FName InParameterName, FFrameNumber InTime, const FTransform& InValue);
    void AddVector2DParameterKey(FName InParameterName, FFrameNumber InTime, FVector2D InValue);
    void AddVectorParameterKey(FName InParameterName, FFrameNumber InTime, FVector InValue);
    void GetParameterNames(TSet<FName>& ParameterNames) const;
    bool RemoveBoolParameter(FName InParameterName);
    bool RemoveColorParameter(FName InParameterName);
    bool RemoveScalarParameter(FName InParameterName);
    bool RemoveTransformParameter(FName InParameterName);
    bool RemoveVector2DParameter(FName InParameterName);
    bool RemoveVectorParameter(FName InParameterName);
};

// Size: 0x28
class IMovieSceneParameterSectionExtender : public UInterface {
};

// Size: 0x80
struct FMovieSceneParameterSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ TArray<FScalarParameterNameAndCurve> Scalars;
    /* 0x0030 */ TArray<FBoolParameterNameAndCurve> Bools;
    /* 0x0040 */ TArray<FVector2DParameterNameAndCurves> Vector2Ds;
    /* 0x0050 */ TArray<FVectorParameterNameAndCurves> Vectors;
    /* 0x0060 */ TArray<FColorParameterNameAndCurves> Colors;
    /* 0x0070 */ TArray<FTransformParameterNameAndCurves> Transforms;
};

// Size: 0x48
class UMovieScenePartialEvaluationTestObject : public UObject {
    /* 0x0028 */ float FloatProperty;
    /* 0x0030 */ FVector VectorProperty;
};

// Size: 0x110
struct FMovieSceneParticleChannel : public FMovieSceneByteChannel {
};

// Size: 0x80
struct FMovieSceneParticleParameterSectionTemplate : public FMovieSceneParameterSectionTemplate {
};

// Size: 0x128
class UMovieSceneParticleParameterTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x218
class UMovieSceneParticleSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneParticleChannel ParticleKeys;
};

// Size: 0x130
struct FMovieSceneParticleSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FMovieSceneParticleChannel ParticleKeys;
};

// Size: 0x128
class UMovieSceneParticleTrack : public UMovieSceneNameableTrack {
    /* 0x0118 */ TArray<UMovieSceneSection*> ParticleSections;
};

// Size: 0x90
class UMovieScenePiecewiseBoolBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0x90
class UMovieScenePiecewiseByteBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0x160
class UMovieScenePiecewiseDoubleBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0x90
class UMovieScenePiecewiseEnumBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0xb0
class UMovieScenePiecewiseIntegerBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0x70
class UMovieScenePlatformCondition : public UMovieSceneCondition {
    /* 0x0060 */ TArray<FName> ValidPlatforms;
};

// Size: 0x90
class UMovieScenePostEvalEventSystem : public UMovieSceneEventSystem {
};

// Size: 0x90
class UMovieScenePostSpawnEventSystem : public UMovieSceneEventSystem {
};

// Size: 0x30
struct FMovieScenePreAnimatedMaterialParameters {
    /* 0x0000 */ UMaterialInterface* PreviousMaterial;
    /* 0x0008 */ TSoftObjectPtr<UMaterialInterface> SoftPreviousMaterial;
};

// Size: 0x90
class UMovieScenePreSpawnEventSystem : public UMovieSceneEventSystem {
};

// Size: 0xf0
class UMovieScenePredictionSystem : public UMovieSceneEntitySystem {
    /* 0x00d0 */ TArray<UMovieSceneAsyncAction_SequencePrediction*> PendingPredictions;
    /* 0x00e0 */ TArray<UMovieSceneAsyncAction_SequencePrediction*> ProcessingPredictions;
};

// Size: 0x240
class UMovieScenePrimitiveMaterialSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneObjectPathChannel MaterialChannel;
};

// Size: 0x150
class UMovieScenePrimitiveMaterialTrack : public UMovieScenePropertyTrack {
    /* 0x0140 */ FComponentMaterialInfo MaterialInfo;
};

// Size: 0x1e0
class UMovieScenePropertyInstantiatorSystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x58
class UMovieScenePropertySystem : public UMovieSceneEntitySystem {
    /* 0x0048 */ UMovieScenePropertyInstantiatorSystem* InstantiatorSystem;
};

// Size: 0x140
class UMovieScenePropertyTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ UMovieSceneSection* SectionToKey;
    /* 0x0118 */ FMovieScenePropertyBinding PropertyBinding;
    /* 0x0130 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0xc8
class UMovieSceneQuaternionBlenderSystem : public UMovieSceneBlenderSystem {
};

// Size: 0x40
class UMovieSceneQuaternionInterpolationRotationSystem : public UMovieSceneEntitySystem {
};

// Size: 0x28
class UMovieSceneReplaceableActorBinding : public UMovieSceneReplaceableBindingBase {
};

// Size: 0x38
class UMovieSceneReplaceableActorBinding_BPBase : public UMovieSceneReplaceableBindingBase {
    /* 0x0028 */ int32_t CustomBindingPriority;
    /* 0x0030 */ UClass* PreviewSpawnableType;

    void BP_InitReplaceableBinding(UObject* SourceObject, UMovieScene* OwnerMovieScene);
    FMovieSceneBindingResolveResult BP_ResolveRuntimeBinding(const FMovieSceneBindingResolveContext& ResolveContext) const;
    bool BP_SupportsBindingCreationFromObject(const UObject* SourceObject) const;
};

// Size: 0x58
class UMovieSceneReplaceableDirectorBlueprintBinding : public UMovieSceneReplaceableBindingBase {
    /* 0x0028 */ FMovieSceneDynamicBinding DynamicBinding;
    /* 0x0050 */ UClass* PreviewSpawnableType;
};

// Size: 0x58
class UMovieSceneRotatorPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x458
class UMovieSceneRotatorSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneDoubleChannel Rotation[3];
};

// Size: 0x140
class UMovieSceneRotatorTrack : public UMovieScenePropertyTrack {
};

// Size: 0x68
class UMovieSceneScalabilityCondition : public UMovieSceneCondition {
    /* 0x0060 */ EMovieSceneScalabilityConditionGroup Group;
    /* 0x0061 */ EMovieSceneScalabilityConditionOperator Operator;
    /* 0x0062 */ EMovieSceneScalabilityConditionLevel Level;
};

// Size: 0x28
class IMovieSceneSectionsToKey : public UInterface {
};

// Size: 0x80
struct FMovieSceneSkeletalAnimRootMotionTrackParams {
};

// Size: 0x8
struct FMovieSceneSkeletalAnimationComponentData {
    /* 0x0000 */ UMovieSceneSkeletalAnimationSection* Section;
};

// Size: 0x158
struct FMovieSceneSkeletalAnimationParams {
    /* 0x0000 */ UAnimSequenceBase* Animation;
    /* 0x0008 */ FFrameNumber FirstLoopStartFrameOffset;
    /* 0x000c */ FFrameNumber StartFrameOffset;
    /* 0x0010 */ FFrameNumber EndFrameOffset;
    /* 0x0018 */ FMovieSceneTimeWarpVariant PlayRate;
    /* 0x0020 */ bool bReverse;
    /* 0x0024 */ FName SlotName;
    /* 0x0030 */ UMirrorDataTable* MirrorDataTable;
    /* 0x0038 */ FMovieSceneFloatChannel Weight;
    /* 0x0148 */ bool bSkipAnimNotifiers;
    /* 0x0149 */ bool bForceCustomMode;
    /* 0x014a */ ESwapRootBone SwapRootBone;
    /* 0x014b */ bool bLinearPlaybackWhenScaled;
    /* 0x014c */ float StartOffset;
    /* 0x0150 */ float EndOffset;
};

// Size: 0x390
class UMovieSceneSkeletalAnimationSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneSkeletalAnimationParams Params;
    /* 0x0268 */ UAnimSequence* AnimSequence;
    /* 0x0270 */ UAnimSequenceBase* Animation;
    /* 0x0278 */ float StartOffset;
    /* 0x027c */ float EndOffset;
    /* 0x0280 */ float PlayRate;
    /* 0x0284 */ bool bReverse;
    /* 0x0288 */ FName SlotName;
    /* 0x0290 */ FVector StartLocationOffset;
    /* 0x02a8 */ FRotator StartRotationOffset;
    /* 0x02c0 */ FName MatchedBoneName;
    /* 0x02c8 */ FVector MatchedLocationOffset;
    /* 0x02e0 */ FRotator MatchedRotationOffset;
    /* 0x02f8 */ bool bMatchWithPrevious;
    /* 0x02f8 */ bool bMatchTranslation;
    /* 0x02f8 */ bool bMatchIncludeZHeight;
    /* 0x02f8 */ bool bMatchRotationYaw;
    /* 0x02f8 */ bool bMatchRotationPitch;
    /* 0x02f8 */ bool bMatchRotationRoll;
    /* 0x02f8 */ bool bDebugForceTickPose;
    /* 0x0300 */ FInstancedStruct MixedAnimationTarget;
    /* 0x0310 */ int32_t MixedAnimationPriority;
};

// Size: 0xe0
class UMovieSceneSkeletalAnimationSystem : public UMovieSceneEntitySystem {
};

// Size: 0x1b0
class UMovieSceneSkeletalAnimationTrack : public UMovieSceneCommonAnimationTrack {
    /* 0x01a8 */ bool bUseLegacySectionIndexBlend;
    /* 0x01a9 */ ESwapRootBone SwapRootBone;

    ESwapRootBone GetSwapRootBone() const;
    void SetSwapRootBone(ESwapRootBone InValue);
};

// Size: 0x220
class UMovieSceneSlomoSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneFloatChannel FloatCurve;
};

// Size: 0x58
class UMovieSceneSlomoSystem : public UMovieSceneEntitySystem {
};

// Size: 0x140
class UMovieSceneSlomoTrack : public UMovieSceneFloatTrack {
};

// Size: 0x48
class UMovieSceneSpawnableActorBinding : public UMovieSceneSpawnableActorBindingBase {
    /* 0x0040 */ AActor* ActorTemplate;
};

// Size: 0x40
class UMovieSceneSpawnableActorBindingBase : public UMovieSceneSpawnableBindingBase {
    /* 0x0030 */ bool bNetAddressableName;
    /* 0x0034 */ FName LevelName;
};

// Size: 0x58
class UMovieSceneSpawnableDirectorBlueprintBinding : public UMovieSceneSpawnableBindingBase {
    /* 0x0030 */ FMovieSceneDynamicBinding DynamicBinding;
};

// Size: 0x110
struct FMovieSceneStringChannel : public FMovieSceneChannel {
    /* 0x0050 */ TArray<FFrameNumber> Times;
    /* 0x0060 */ TArray<FString> Values;
    /* 0x0070 */ FString DefaultValue;
    /* 0x0080 */ bool bHasDefaultValue;
    /* 0x0088 */ FMovieSceneKeyHandleMap KeyHandles;
};

// Size: 0x58
class UMovieSceneStringPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x220
class UMovieSceneStringSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneStringChannel StringCurve;
};

// Size: 0x140
class UMovieSceneStringTrack : public UMovieScenePropertyTrack {
};

// Size: 0x90
class UMovieSceneTestSequence : public UMovieSceneSequence {
    /* 0x0068 */ UMovieScene* MovieScene;
    /* 0x0070 */ TArray<UObject*> BoundObjects;
    /* 0x0080 */ TArray<FGuid> BindingGuids;
};

// Size: 0x30
class UMovieSceneTracksSettings : public UObject {
    /* 0x0028 */ bool bPreviewCameraCutsInSimulate;
};

// Size: 0x4
struct FMovieSceneTransformMask {
    /* 0x0000 */ uint32_t Mask;
};

// Size: 0x28
class IMovieSceneTransformOrigin : public UInterface {

    FTransform BP_GetTransformOrigin() const;
};

// Size: 0x40
class UMovieSceneTransformOriginInstantiatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x158
class UMovieSceneTransformOriginSystem : public UMovieSceneEntitySystem {
};

// Size: 0x140
class UMovieSceneTransformTrack : public UMovieScenePropertyTrack {
};

// Size: 0x38
struct FMovieSceneVector2DKeyStruct : public FMovieSceneDoubleVectorKeyStructBase {
    /* 0x0028 */ FVector2D Vector;
};

// Size: 0x30
struct FMovieSceneVector2fKeyStruct : public FMovieSceneFloatVectorKeyStructBase {
    /* 0x0028 */ FVector2f Vector;
};

// Size: 0x40
struct FMovieSceneVector3dKeyStruct : public FMovieSceneDoubleVectorKeyStructBase {
    /* 0x0028 */ FVector3d Vector;
};

// Size: 0x38
struct FMovieSceneVector3fKeyStruct : public FMovieSceneFloatVectorKeyStructBase {
    /* 0x0028 */ FVector3f Vector;
};

// Size: 0x50
struct FMovieSceneVector4dKeyStruct : public FMovieSceneDoubleVectorKeyStructBase {
    /* 0x0030 */ FVector4d Vector;
};

// Size: 0x40
struct FMovieSceneVector4fKeyStruct : public FMovieSceneFloatVectorKeyStructBase {
    /* 0x0030 */ FVector4f Vector;
};

// Size: 0x220
class UMovieSceneVisibilitySection : public UMovieSceneBoolSection {
};

// Size: 0x50
class UMovieSceneVisibilitySystem : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x140
class UMovieSceneVisibilityTrack : public UMovieScenePropertyTrack {
};

// Size: 0x40
class UObjectPathChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x18
struct FPerlinNoiseParams {
    /* 0x0000 */ float Frequency;
    /* 0x0008 */ double Amplitude;
    /* 0x0010 */ float Offset;
};

// Size: 0x120
struct FScalarMaterialParameterInfoAndCurve {
    /* 0x0000 */ FMaterialParameterInfo ParameterInfo;
    /* 0x0010 */ FMovieSceneFloatChannel ParameterCurve;
};

// Size: 0x118
struct FScalarParameterNameAndCurve : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneFloatChannel ParameterCurve;
};

// Size: 0x40
class UStringChannelEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x998
struct FTransformParameterNameAndCurves : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneFloatChannel Translation[3];
    /* 0x0338 */ FMovieSceneFloatChannel Rotation[3];
    /* 0x0668 */ FMovieSceneFloatChannel Scale[3];
};

// Size: 0x228
struct FVector2DParameterNameAndCurves : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneFloatChannel XCurve;
    /* 0x0118 */ FMovieSceneFloatChannel YCurve;
};

// Size: 0x338
struct FVectorParameterNameAndCurves : public FBaseParameterNameAndValue {
    /* 0x0008 */ FMovieSceneFloatChannel XCurve;
    /* 0x0118 */ FMovieSceneFloatChannel YCurve;
    /* 0x0228 */ FMovieSceneFloatChannel ZCurve;
};

// Size: 0x58
class UWeightAndEasingEvaluatorSystem : public UMovieSceneEntitySystem {
};

enum class ENNETensorDataType {
    None = 0,
    Char = 1,
    Boolean = 2,
    Half = 3,
    Float = 4,
    Double = 5,
    Int8 = 6,
    Int16 = 7,
    Int32 = 8,
    Int64 = 9,
    UInt8 = 10,
    UInt16 = 11,
    UInt32 = 12,
    UInt64 = 13,
    Complex64 = 14,
    Complex128 = 15,
    BFloat16 = 16,
    ENNETensorDataType_MAX = 17,
};

// Size: 0x110
class UNNEModelData : public UObject {
};

// Size: 0x28
class INNERuntime : public UInterface {
};

// Size: 0x28
class INNERuntimeCPU : public UInterface {
};

// Size: 0x28
class INNERuntimeGPU : public UInterface {
};

// Size: 0x28
class INNERuntimeNPU : public UInterface {
};

// Size: 0x28
class INNERuntimeRDG : public UInterface {
};

enum class EDenoiserRuntimeType {
    CPU = 0,
    GPU = 1,
    RDG = 2,
    EDenoiserRuntimeType_MAX = 3,
};

enum class EInputResourceName {
    Color = 0,
    Albedo = 1,
    Normal = 2,
    Output = 3,
    EInputResourceName_MAX = 4,
};

enum class EOutputResourceName {
    Output = 0,
    EOutputResourceName_MAX = 1,
};

enum class EResourceName {
    Color = 0,
    Albedo = 1,
    Normal = 2,
    Flow = 3,
    Output = 4,
    EResourceName_MAX = 5,
};

enum class ETemporalInputResourceName {
    Color = 0,
    Albedo = 1,
    Normal = 2,
    Flow = 3,
    Output = 4,
    ETemporalInputResourceName_MAX = 5,
};

enum class ETemporalOutputResourceName {
    Output = 0,
    ETemporalOutputResourceName_MAX = 1,
};

// Size: 0xb8
class UNNEDenoiserAsset : public UDataAsset {
    /* 0x0030 */ TSoftObjectPtr<UNNEModelData> ModelData;
    /* 0x0058 */ TSoftObjectPtr<UDataTable> InputMapping;
    /* 0x0080 */ TSoftObjectPtr<UDataTable> OutputMapping;
    /* 0x00a8 */ FTilingConfig TilingConfig;
};

// Size: 0x18
struct FNNEDenoiserBaseMappingData : public FTableRowBase {
    /* 0x0008 */ int32_t TensorIndex;
    /* 0x000c */ int32_t TensorChannel;
    /* 0x0010 */ int32_t ResourceChannel;
};

// Size: 0x20
struct FNNEDenoiserInputMappingData : public FNNEDenoiserBaseMappingData {
    /* 0x0018 */ EInputResourceName Resource;
};

// Size: 0x20
struct FNNEDenoiserOutputMappingData : public FNNEDenoiserBaseMappingData {
    /* 0x0018 */ EOutputResourceName Resource;
};

// Size: 0xa0
class UNNEDenoiserSettings : public UDeveloperSettingsBackedByCVars {
    /* 0x0038 */ TSoftObjectPtr<UNNEDenoiserAsset> DenoiserAsset;
    /* 0x0088 */ int32_t MaximumTileSizeOverride;
    /* 0x008c */ uint8_t RuntimeType;
    /* 0x0090 */ FString RuntimeName;
};

// Size: 0xb8
class UNNEDenoiserTemporalAsset : public UDataAsset {
    /* 0x0030 */ TSoftObjectPtr<UNNEModelData> ModelData;
    /* 0x0058 */ TSoftObjectPtr<UDataTable> InputMapping;
    /* 0x0080 */ TSoftObjectPtr<UDataTable> OutputMapping;
    /* 0x00a8 */ FTilingConfig TilingConfig;
};

// Size: 0x20
struct FNNEDenoiserTemporalInputMappingData : public FNNEDenoiserBaseMappingData {
    /* 0x0018 */ ETemporalInputResourceName Resource;
    /* 0x001c */ int32_t FrameIndex;
};

// Size: 0x20
struct FNNEDenoiserTemporalOutputMappingData : public FNNEDenoiserBaseMappingData {
    /* 0x0018 */ ETemporalOutputResourceName Resource;
};

// Size: 0x10
struct FTilingConfig {
    /* 0x0000 */ int32_t Alignment;
    /* 0x0004 */ int32_t Overlap;
    /* 0x0008 */ int32_t MaxSize;
    /* 0x000c */ int32_t MinSize;
};

enum class EExecutionMode {
    SEQUENTIAL = 0,
    PARALLEL = 1,
    EExecutionMode_MAX = 2,
};

// Size: 0x48
class UNNERuntimeORTCpu : public UObject {
};

// Size: 0x38
class UNNERuntimeORTDmlProxy : public UObject {
};

// Size: 0x40
class UNNERuntimeORTDml_GPU : public UNNERuntimeORTDmlProxy {
};

// Size: 0x48
class UNNERuntimeORTDml_GPU_NPU : public UNNERuntimeORTDmlProxy {
};

// Size: 0x48
class UNNERuntimeORTDml_GPU_RDG : public UNNERuntimeORTDmlProxy {
};

// Size: 0x50
class UNNERuntimeORTDml_GPU_RDG_NPU : public UNNERuntimeORTDmlProxy {
};

// Size: 0x40
class UNNERuntimeORTDml_NPU : public UNNERuntimeORTDmlProxy {
};

// Size: 0x40
class UNNERuntimeORTDml_RDG : public UNNERuntimeORTDmlProxy {
};

// Size: 0x48
class UNNERuntimeORTDml_RDG_NPU : public UNNERuntimeORTDmlProxy {
};

// Size: 0x58
class UNNERuntimeORTSettings : public UDeveloperSettings {
    /* 0x0038 */ FThreadingOptions EditorThreadingOptions;
    /* 0x0048 */ FThreadingOptions GameThreadingOptions;
};

// Size: 0x10
struct FThreadingOptions {
    /* 0x0000 */ bool bUseGlobalThreadPool;
    /* 0x0004 */ int32_t IntraOpNumThreads;
    /* 0x0008 */ int32_t InterOpNumThreads;
    /* 0x000c */ uint8_t ExecutionMode;
};

// Size: 0xf8
class UGlobalNamingTokens : public UNamingTokens {
};

// Size: 0x48
struct FNamingTokenData {
    /* 0x0000 */ FString TokenKey;
    /* 0x0010 */ FText DisplayName;
    /* 0x0020 */ FText Description;
    /* 0x0030 */ FName FunctionName;
};

// Size: 0x18
struct FNamingTokenFilterArgs {
    /* 0x0000 */ TArray<FString> AdditionalNamespacesToInclude;
    /* 0x0010 */ bool bIncludeGlobal;
    /* 0x0011 */ bool bForceCaseSensitive;
    /* 0x0012 */ bool bNativeOnly;
};

// Size: 0x30
struct FNamingTokenResultData {
    /* 0x0000 */ FText OriginalText;
    /* 0x0010 */ FText EvaluatedText;
    /* 0x0020 */ TArray<FNamingTokenValueData> TokenValues;
};

// Size: 0x38
struct FNamingTokenValueData {
    /* 0x0000 */ FString TokenKey;
    /* 0x0010 */ FString ProvidedNamespace;
    /* 0x0020 */ FText TokenValue;
    /* 0x0030 */ bool bWasEvaluated;
};

// Size: 0xf8
class UNamingTokens : public UObject {
    /* 0x00b8 */ TArray<FNamingTokenData> CustomTokens;
    /* 0x00c8 */ FNamingTokensEvaluationData CurrentEvaluationData;
    /* 0x00e8 */ FString Namespace;

    FDateTime GetCurrentDateTime() const;
    void OnPostEvaluate();
    void OnPreEvaluate(const FNamingTokensEvaluationData& InEvaluationData);
    FText ProcessTokenTemplateFunction();
};

// Size: 0x150
class UNamingTokensEngineSubsystem : public UEngineSubsystem {
    /* 0x0030 */ TMap<FString, UNamingTokens*> CachedNamingTokens;

    void ClearCachedNamingTokens();
    FNamingTokenResultData EvaluateTokenString(FString InTokenString, const FNamingTokenFilterArgs& InFilter, const TArray<UObject*>& InContexts);
    FNamingTokenResultData EvaluateTokenText(const FText& InTokenText, const FNamingTokenFilterArgs& InFilter, const TArray<UObject*>& InContexts);
    TArray<FString> GetAllNamespaces() const;
    TArray<FString> GetGlobalNamespaces() const;
    TArray<UNamingTokens*> GetMultipleNamingTokens(const TArray<FString>& InNamespaces) const;
    UNamingTokens* GetNamingTokens(FString InNameSpace) const;
    UNamingTokens* GetNamingTokensNative(FString InNameSpace) const;
    bool IsGlobalNamespaceRegistered(FString InNameSpace) const;
    void RegisterGlobalNamespace(FString InNameSpace);
    void UnregisterGlobalNamespace(FString InNameSpace);
};

// Size: 0x20
struct FNamingTokensEvaluationData {
    /* 0x0000 */ FDateTime CurrentDateTime;
    /* 0x0008 */ TArray<UObject*> Contexts;
};

// Size: 0x50
struct FDamageHitAccumulation {
    /* 0x0000 */ TMap<FVector, int32_t> Hits;
};

enum class ENauticalAction {
    None = 0,
    Idle = 1,
    Fish = 2,
    GoneFishing = 3,
    Trade = 4,
    DeliverLetter = 5,
    Scout = 6,
    Attack = 7,
    GotoAttack = 8,
    Repair = 9,
    Return = 10,
    Flee = 11,
    GotoSalvage = 12,
    Salvage = 13,
    Sink = 14,
    Docking = 15,
    ENauticalAction_MAX = 16,
};

enum class ENauticalDockTask {
    None = 0,
    BuildShip = 1,
    ENauticalDockTask_MAX = 2,
};

enum class ENauticalPoiType {
    None = 0,
    FishingSpot = 1,
    SalvageSpot = 2,
    ENauticalPoiType_MAX = 3,
};

enum class ENauticalShipSailCategory {
    None = 0,
    Direct = 1,
    Lateral = 2,
    ENauticalShipSailCategory_MAX = 3,
};

enum class ENauticalShipSails {
    None = 0,
    Jibs = 1,
    StaySails = 2,
    Driver = 3,
    ForeSails = 4,
    MainSails = 5,
    MizzenSails = 6,
    ForeSailsLateral = 7,
    MainSailsLateral = 8,
    MizzenSailsLateral = 9,
    ENauticalShipSails_MAX = 10,
};

enum class ESyncEventType {
    None = 0,
    ShipNew = 1,
    ShipSunk = 2,
    ShipDocked = 3,
    CargoSet = 4,
    DockNew = 5,
    DockRemove = 6,
    ESyncEventType_MAX = 7,
};

// Size: 0x370
class ANauticalCannonBall : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ FNauticalCannonBallConfig config;
    /* 0x02f0 */ FNauticalCannonBallState State;
    /* 0x0368 */ ANauticalOcean* ocean;

    void UponFire();
    void UponHit(AActor* Target, FVector WorldPosition, FVector HitNormal);
    void UponSplash();
};

// Size: 0x40
struct FNauticalCannonBallConfig {
    /* 0x0000 */ bool isBall;
    /* 0x0008 */ double splashHeight;
    /* 0x0010 */ double damagePower;
    /* 0x0018 */ double startVelocity;
    /* 0x0020 */ double upwardRatio;
    /* 0x0028 */ double Gravity;
    /* 0x0030 */ double collisionRadius;
    /* 0x0038 */ uint8_t CollisionChannel;
};

// Size: 0x78
struct FNauticalCannonBallState {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ FName faction;
    /* 0x0010 */ double simScale;
    /* 0x0018 */ double visualScale;
    /* 0x0020 */ bool IsVisible;
    /* 0x0028 */ FVector worldStart;
    /* 0x0040 */ FVector worldForward;
    /* 0x0058 */ double Height;
    /* 0x0060 */ double velocityForward;
    /* 0x0068 */ double velocityUp;
    /* 0x0070 */ double Time;
};

// Size: 0x18
struct FNauticalCannonState {
    /* 0x0000 */ USceneComponent* Component;
    /* 0x0008 */ double cooldown;
    /* 0x0010 */ double firingPeriod;
};

// Size: 0x50
struct FNauticalCargo {
    /* 0x0000 */ TMap<FName, FNauticalCargoItem> Items;
};

// Size: 0x10
struct FNauticalCargoItem {
    /* 0x0000 */ FName ItemName;
    /* 0x0008 */ double Quantity;
};

// Size: 0x50
struct FNauticalConflicts {
    /* 0x0000 */ TMap<FName, FNauticalWarStatus> warByFaction;
};

// Size: 0x328
class ANauticalDock : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UStaticMeshComponent* foundation;
    /* 0x02b8 */ USceneComponent* primeBerth;
    /* 0x02c0 */ ANauticalOcean* ocean;
    /* 0x02c8 */ ANauticalIsland* owningIsland;
    /* 0x02d0 */ FNauticalDockState State;
    /* 0x0310 */ FNauticalDockConfig config;
};

// Size: 0x18
struct FNauticalDockConfig {
    /* 0x0000 */ UClass* shipClass;
    /* 0x0008 */ double repairSpeed;
    /* 0x0010 */ double shipBuildTime;
};

// Size: 0x40
struct FNauticalDockState {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ FName prototype;
    /* 0x000c */ FName externalName;
    /* 0x0018 */ double simScale;
    /* 0x0020 */ double visualScale;
    /* 0x0028 */ double visualHeight;
    /* 0x0030 */ ENauticalDockTask taskType;
    /* 0x0038 */ double taskTimeRemaining;
};

// Size: 0x370
class ANauticalIsland : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UStaticMeshComponent* land;
    /* 0x02b8 */ AActor* terrain;
    /* 0x02c0 */ ANauticalOcean* ocean;
    /* 0x02c8 */ FNauticalIslandState State;
    /* 0x0350 */ FNauticalIslandConfig config;
};

// Size: 0x20
struct FNauticalIslandConfig {
    /* 0x0000 */ UClass* islandSubactorClass;
    /* 0x0008 */ double defenseRange;
    /* 0x0010 */ double simBounds;
    /* 0x0018 */ double simFindBounds;
};

// Size: 0x88
struct FNauticalIslandState {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ FName prototype;
    /* 0x0010 */ double Bounds;
    /* 0x0018 */ FName faction;
    /* 0x0020 */ double simScale;
    /* 0x0028 */ double visualScale;
    /* 0x0030 */ double visualHeight;
    /* 0x0038 */ TSet<ANauticalDock*> docks;
};

// Size: 0x368
class ANauticalMap : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ FNauticalMapConfig config;
    /* 0x02f0 */ FNauticalMapState State;
    /* 0x0360 */ ANauticalOcean* ocean;
};

// Size: 0x40
struct FNauticalMapConfig {
    /* 0x0000 */ float heightOffset;
    /* 0x0008 */ UClass* islandFeatureClass;
    /* 0x0010 */ FName legendTargetFaction;
    /* 0x0018 */ UClass* legendIslandFeatureClass;
    /* 0x0020 */ UClass* legendFeatureClass;
    /* 0x0028 */ FVector legendSimOffset;
};

// Size: 0x70
struct FNauticalMapState {
    /* 0x0000 */ TMap<AActor*, FVector> mapFeatures;
    /* 0x0050 */ double simScale;
    /* 0x0058 */ double visualScale;
    /* 0x0060 */ double visualHeight;
    /* 0x0068 */ bool IsVisible;
};

// Size: 0x68
struct FNauticalNavigatorDirections {
    /* 0x0000 */ FRotator Angle;
    /* 0x0018 */ TSet<ENauticalShipSails> usedSails;
};

// Size: 0xd8
struct FNauticalNavigatorGoal {
    /* 0x0000 */ bool requiresAngle;
    /* 0x0008 */ FVector currentPosition;
    /* 0x0020 */ FRotator currentAngle;
    /* 0x0038 */ FRotator goalAngle;
    /* 0x0050 */ FVector goalPosition;
    /* 0x0068 */ double goalRadius;
    /* 0x0070 */ TSet<ENauticalShipSails> availableSails;
    /* 0x00c0 */ FVector WindDirection;
};

// Size: 0x798
class ANauticalOcean : public AActor {
    /* 0x02a8 */ FOceanConfig config;
    /* 0x0468 */ FOceanState State;
    /* 0x0778 */ FSyncEventList pendingEvents;
    /* 0x0788 */ TArray<uint8_t> testSaveBuffer;

    void TestLoadFromBuffer();
    void TestSaveToBuffer();
    void TestToggleVisiblity();
};

// Size: 0x58
struct FNauticalPlan {
    /* 0x0000 */ ANauticalShip* otherShip;
    /* 0x0008 */ ANauticalDock* otherDock;
    /* 0x0010 */ ANauticalPoi* otherPoi;
    /* 0x0018 */ FVector otherLocation;
    /* 0x0030 */ ENauticalAction actionGoal;
    /* 0x0031 */ bool isAutoPlan;
    /* 0x0038 */ double workStartPeriod;
    /* 0x0040 */ FName workStartTask;
    /* 0x0048 */ double workEndPeriod;
    /* 0x0050 */ FName workEndTask;
};

// Size: 0x3a8
class ANauticalPlanDisplay : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UStaticMeshComponent* targetSymbol;
    /* 0x02b8 */ USplineMeshComponent* pathVisual;
    /* 0x02c0 */ FNauticalPlanDisplayConfig config;
    /* 0x02e0 */ FNauticalPlanDisplayState State;
};

// Size: 0x20
struct FNauticalPlanDisplayConfig {
    /* 0x0000 */ int32_t PathSegmentCount;
    /* 0x0004 */ float pathHeight;
    /* 0x0008 */ int32_t pathCustomDepth;
    /* 0x0010 */ double arcEndsHeight;
    /* 0x0018 */ FColor arcColor;
};

// Size: 0xc8
struct FNauticalPlanDisplayState {
    /* 0x0000 */ double simScale;
    /* 0x0008 */ double visualScale;
    /* 0x0010 */ FNauticalPlan shownPlan;
    /* 0x0068 */ bool hasValidPlan;
    /* 0x0070 */ FVector Start;
    /* 0x0088 */ FVector destination;
    /* 0x00a0 */ FName IconName;
    /* 0x00a8 */ bool isMobileTarget;
    /* 0x00b0 */ AActor* Target;
    /* 0x00b8 */ AActor* doer;
    /* 0x00c0 */ bool IsVisible;
};

// Size: 0x348
class ANauticalPoi : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UStaticMeshComponent* Symbol;
    /* 0x02b8 */ FNauticalPoiConfig config;
    /* 0x02c8 */ FNauticalPoiState State;
    /* 0x0340 */ ANauticalOcean* ocean;
};

// Size: 0xc
struct FNauticalPoiConfig {
    /* 0x0000 */ ENauticalPoiType poiType;
    /* 0x0004 */ FName prototype;
};

// Size: 0x78
struct FNauticalPoiState {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ FName prototype;
    /* 0x0010 */ double simScale;
    /* 0x0018 */ double visualScale;
    /* 0x0020 */ double visualHeight;
    /* 0x0028 */ FNauticalCargo cargo;
};

// Size: 0x50
struct FNauticalRigging {
    /* 0x0000 */ TMap<ENauticalShipSails, double> sailDeployments;
};

// Size: 0x618
class ANauticalShip : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UStaticMeshComponent* hull;
    /* 0x02b8 */ UWidgetComponent* statusWidget;
    /* 0x02c0 */ USceneComponent* cannonsGroup;
    /* 0x02c8 */ UChildActorComponent* zoomedActor;
    /* 0x02d0 */ FNauticalShipConfig config;
    /* 0x0440 */ ANauticalOcean* ocean;
    /* 0x0448 */ ANauticalIsland* owningIsland;
    /* 0x0450 */ FNauticalShipState State;

    bool CanDoAction(ENauticalAction ActionType);
    void FireCannons(ANauticalShip* Target);
    void SetAnimation(ENauticalAction ActionType);
    void SetFullOrMini(bool isFull, bool isMini);
    void SetShowSelection(bool doShow);
    void SetShownRigging(FNauticalRigging nd);
    void TestCannons();
    void TestDestruction();
    void TestDocking();
    void TestSinking();
};

// Size: 0x170
struct FNauticalShipConfig {
    /* 0x0000 */ FName prototype;
    /* 0x0008 */ UTexture2D* Icon;
    /* 0x0010 */ TSet<ENauticalAction> capableActions;
    /* 0x0060 */ double simBounds;
    /* 0x0068 */ double goalBeeLineRange;
    /* 0x0070 */ double turningLookAhead;
    /* 0x0078 */ double moveSpeedMax;
    /* 0x0080 */ double rotateSpeed;
    /* 0x0088 */ double combatRange;
    /* 0x0090 */ double combatPower;
    /* 0x0098 */ double leewayRatio;
    /* 0x00a0 */ double sailDeploySpeed;
    /* 0x00a8 */ double sailStowSpeed;
    /* 0x00b0 */ double hullLeanRatio;
    /* 0x00b8 */ FRotator hullRotBase;
    /* 0x00d0 */ FVector2D cannonCooldowns;
    /* 0x00e0 */ TSet<ENauticalShipSails> equipedSails;
    /* 0x0130 */ UClass* planClass;
    /* 0x0138 */ double visionDeltaBetweenReports;
    /* 0x0140 */ FLinearColor factionColor;
    /* 0x0150 */ double armorDamageThreshold;
    /* 0x0158 */ double armorDamageReduction;
    /* 0x0160 */ double armorPoints;
    /* 0x0168 */ double minutesToFullHeal;
};

// Size: 0x1c8
struct FNauticalShipState {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ FName prototype;
    /* 0x000c */ FName externalName;
    /* 0x0018 */ double simScale;
    /* 0x0020 */ double Bounds;
    /* 0x0028 */ double visualScale;
    /* 0x0030 */ double visualHeight;
    /* 0x0038 */ FNauticalPlan plan;
    /* 0x0090 */ FNauticalCargo cargo;
    /* 0x00e0 */ UNauticalStatusWidget* statusUi;
    /* 0x00e8 */ FNauticalRigging rigging;
    /* 0x0138 */ double hp;
    /* 0x0140 */ FName killedByFaction;
    /* 0x0148 */ TArray<FNauticalCannonState> cannons;
    /* 0x0158 */ bool IsVisible;
    /* 0x0160 */ FVector worldLoc;
    /* 0x0178 */ FVector simLoc;
    /* 0x0190 */ FRotator worldRot;
    /* 0x01a8 */ ANauticalPlanDisplay* planDisplay;
    /* 0x01b0 */ FVector lastReportedVisionPoint;
};

// Size: 0x78
struct FNauticalStatus {
    /* 0x0000 */ bool doHide;
    /* 0x0004 */ FName taskName;
    /* 0x0010 */ double hp;
    /* 0x0018 */ FLinearColor hpColor;
    /* 0x0028 */ FNauticalCargo cargo;
};

// Size: 0x340
class UNauticalStatusWidget : public UUserWidget {

    void SetShownHp(double newHp);
    void SetShownStatus(FNauticalStatus nd);
};

// Size: 0xb8
class UNauticalTool : public UActorComponent {
};

// Size: 0xe8
struct FNauticalWarStatus {
    /* 0x0000 */ UTexture2D* factionIcon;
    /* 0x0008 */ FName factionStringId;
    /* 0x0010 */ FName conflictStringId;
    /* 0x0018 */ FName shipStringId;
    /* 0x0020 */ int32_t shipCount;
    /* 0x0024 */ int32_t waveCount;
    /* 0x0028 */ bool IsValid;
    /* 0x0029 */ bool isActiveConflict;
    /* 0x002c */ FName faction;
    /* 0x0034 */ int32_t conflictAgeDays;
    /* 0x0038 */ int32_t waitPeriodDays;
    /* 0x0040 */ double opinion;
    /* 0x0048 */ TSet<int32_t> opponentTargets;
    /* 0x0098 */ TSet<int32_t> ownCombatants;
};

// Size: 0x90
struct FNauticalWindSimInput {
    /* 0x0000 */ double leewayRatio;
    /* 0x0008 */ FVector shipDirection;
    /* 0x0020 */ FVector WindDirection;
    /* 0x0038 */ double windPower;
    /* 0x0040 */ FNauticalRigging rigging;
};

// Size: 0x20
struct FNauticalWindSimResult {
    /* 0x0000 */ FVector shipDelta;
    /* 0x0018 */ double hullLean;
};

// Size: 0x18
struct FOceanBlockerReport {
    /* 0x0000 */ ANauticalShip* ship;
    /* 0x0008 */ ANauticalIsland* island;
    /* 0x0010 */ double Distance;
};

// Size: 0x1c0
struct FOceanConfig {
    /* 0x0000 */ UClass* shipClass;
    /* 0x0008 */ TMap<FName, FOceanShipPrototypeLookup> shipPrototypes;
    /* 0x0058 */ UClass* dockClass;
    /* 0x0060 */ UClass* islandClass;
    /* 0x0068 */ UClass* poiClass;
    /* 0x0070 */ TMap<FName, FOceanPoiPrototypeLookup> poiPrototypes;
    /* 0x00c0 */ UClass* salvageClass;
    /* 0x00c8 */ UClass* cannonBallClass;
    /* 0x00d0 */ UClass* mapClass;
    /* 0x00d8 */ double simScale;
    /* 0x00e0 */ double visualHeight;
    /* 0x00e8 */ double visualScale;
    /* 0x00f0 */ UTextureRenderTarget2D* windRt;
    /* 0x00f8 */ double windPowerScale;
    /* 0x0100 */ bool manageStandalone;
    /* 0x0101 */ bool gatherOnStart;
    /* 0x0108 */ TArray<FOceanDesignPlan> procGenPlans;
    /* 0x0118 */ bool doProcGen;
    /* 0x0119 */ bool startHidden;
    /* 0x0120 */ FOceanVision visionConfig;
    /* 0x0150 */ float cannonBallForwardOffset;
    /* 0x0158 */ TMap<FName, UTexture2D*> factionIcons;
    /* 0x01a8 */ double waveSpawnDistance;
    /* 0x01b0 */ double simLimitRadius;
    /* 0x01b8 */ bool animateScale;
};

// Size: 0xf0
struct FOceanDesignPlan {
    /* 0x0000 */ FName faction;
    /* 0x0008 */ UClass* islandClassOverride;
    /* 0x0010 */ FVector2D islandDistance;
    /* 0x0020 */ double desiredClearDistance;
    /* 0x0028 */ FVector2D islandCount;
    /* 0x0038 */ FVector2D islandScales;
    /* 0x0048 */ double islandMaxRatio;
    /* 0x0050 */ double islandHeight;
    /* 0x0058 */ UClass* dockClassOverride;
    /* 0x0060 */ double dockBaseDistance;
    /* 0x0068 */ FVector dockFixedAngle;
    /* 0x0080 */ double dockHeight;
    /* 0x0088 */ UClass* shipClassOverride;
    /* 0x0090 */ FVector2D shipsCount;
    /* 0x00a0 */ UClass* shipClassOverrideAlt;
    /* 0x00a8 */ FVector2D shipsCountAlt;
    /* 0x00b8 */ double shipBaseDistance;
    /* 0x00c0 */ double shipHeight;
    /* 0x00c8 */ FVector2D poiCount;
    /* 0x00d8 */ FVector2D poiDistance;
    /* 0x00e8 */ double poiHeight;
};

// Size: 0x58
struct FOceanFoundIslandState {
    /* 0x0000 */ int32_t islandId;
    /* 0x0004 */ FName faction;
    /* 0x0010 */ FVector simLoc;
    /* 0x0028 */ FVector worldLoc;
    /* 0x0040 */ double distanceSim;
    /* 0x0048 */ double distanceWorld;
    /* 0x0050 */ float priceRatio;
};

// Size: 0x50
struct FOceanFoundIslands {
    /* 0x0000 */ TMap<int32_t, FOceanFoundIslandState> islands;
};

// Size: 0x20
struct FOceanMessage {
    /* 0x0000 */ ANauticalIsland* issueingIsland;
    /* 0x0008 */ ANauticalShip* issueingShip;
    /* 0x0010 */ FName titleStringId;
    /* 0x0018 */ FName descStringId;
};

// Size: 0x10
struct FOceanMessageAccumulation {
    /* 0x0000 */ TArray<FOceanMessage> msgs;
};

// Size: 0x10
struct FOceanPoiPrototypeLookup {
    /* 0x0000 */ FName poiType;
    /* 0x0008 */ UClass* poiClass;
};

// Size: 0x10
struct FOceanShipPrototypeLookup {
    /* 0x0000 */ FName shipType;
    /* 0x0008 */ UClass* shipClass;
};

// Size: 0x310
struct FOceanState {
    /* 0x0000 */ TMap<int32_t, ANauticalShip*> ships;
    /* 0x0050 */ TMap<int32_t, ANauticalDock*> docks;
    /* 0x00a0 */ TMap<int32_t, ANauticalIsland*> islands;
    /* 0x00f0 */ TMap<int32_t, ANauticalPoi*> pois;
    /* 0x0140 */ TMap<int32_t, ANauticalCannonBall*> cannonBalls;
    /* 0x0190 */ ANauticalMap* Map;
    /* 0x0198 */ double playtime;
    /* 0x01a0 */ bool IsVisible;
    /* 0x01a8 */ FNauticalConflicts conflicts;
    /* 0x01f8 */ FOceanFoundIslands foundIslands;
    /* 0x0248 */ int32_t nextAvailableId;
    /* 0x0250 */ TArray<int32_t> returnedIds;
    /* 0x0260 */ TSet<int32_t> inUseIds;
    /* 0x02b0 */ FDamageHitAccumulation damageHits;
    /* 0x0300 */ FOceanMessageAccumulation msgAccumulation;
};

// Size: 0x30
struct FOceanVision {
    /* 0x0000 */ FName playerTeamName;
    /* 0x0008 */ UTextureRenderTarget2D* playerVisionRt;
    /* 0x0010 */ UTexture2D* visionStamp;
    /* 0x0018 */ float visionWorldLimitSize;
    /* 0x001c */ int32_t visionRtResolution;
    /* 0x0020 */ float islandBaseVisionRange;
    /* 0x0024 */ float islandFoundVisionRange;
    /* 0x0028 */ float shipBaseVisionRange;
};

// Size: 0x60
struct FSyncCargoState {
    /* 0x0000 */ bool IsValid;
    /* 0x0004 */ FName shipName;
    /* 0x0010 */ FNauticalCargo cargo;
};

// Size: 0x38
struct FSyncDockState {
    /* 0x0000 */ bool IsValid;
    /* 0x0004 */ FName dockName;
    /* 0x0010 */ FString islandOwner;
    /* 0x0020 */ FVector dockLoc;
};

// Size: 0xe8
struct FSyncEvent {
    /* 0x0000 */ ESyncEventType EventType;
    /* 0x0008 */ FSyncShipState ship;
    /* 0x0050 */ FSyncDockState dock;
    /* 0x0088 */ FSyncCargoState cargo;
};

// Size: 0x10
struct FSyncEventList {
    /* 0x0000 */ TArray<FSyncEvent> Events;
};

// Size: 0x48
struct FSyncShipState {
    /* 0x0000 */ bool IsValid;
    /* 0x0004 */ FName shipName;
    /* 0x0010 */ FString faction;
    /* 0x0020 */ FName shipType;
    /* 0x0028 */ FName owningDockId;
    /* 0x0030 */ FVector Loc;
};

// Size: 0x500
class AAbstractNavData : public ANavigationData {
};

// Size: 0x40
class UBaseGeneratedNavLinksProxy : public UObject {
    /* 0x0030 */ FNavLinkId LinkProxyId;
    /* 0x0038 */ UObject* Owner;
};

// Size: 0x28
class UCrowdManagerBase : public UObject {
};

enum class EHeightFieldRenderMode {
    Solid = 0,
    Walkable = 1,
    EHeightFieldRenderMode_MAX = 2,
};

enum class ELinkGenerationDebugFlags {
    WalkableSurface = 1,
    WalkableBorders = 2,
    SelectedEdge = 4,
    SelectedEdgeTrajectory = 8,
    SelectedEdgeLandingSamples = 16,
    SelectedEdgeCollisions = 32,
    SelectedEdgeCollisionsSamples = 64,
    Links = 128,
    FilteredLinks = 256,
    ELinkGenerationDebugFlags_MAX = 257,
};

enum class ENavCostDisplay {
    TotalCost = 0,
    HeuristicOnly = 1,
    RealCostOnly = 2,
    ENavCostDisplay_MAX = 3,
};

enum class ENavLinkBuilderFlags {
    CreateCenterPointLink = 1,
    CreateExtremityLink = 2,
    ENavLinkBuilderFlags_MAX = 3,
};

enum class ENavSystemOverridePolicy {
    Override = 0,
    Append = 1,
    Skip = 2,
    ENavSystemOverridePolicy_MAX = 3,
};

enum class ENavigationLedgeSlopeFilterMode {
    Recast = 0,
    None = 1,
    UseStepHeightFromAgentMaxSlope = 2,
    ENavigationLedgeSlopeFilterMode_MAX = 3,
};

enum class ERecastPartitioning {
    Monotone = 0,
    Watershed = 1,
    ChunkyMonotone = 2,
    ERecastPartitioning_MAX = 3,
};

enum class ERuntimeGenerationType {
    Static = 0,
    DynamicModifiersOnly = 1,
    Dynamic = 2,
    LegacyGeneration = 3,
    ERuntimeGenerationType_MAX = 4,
};

enum class ESubdivisionLOD {
    Low = 0,
    Medium = 1,
    High = 2,
    Ultra = 3,
    ESubdivisionLOD_MAX = 4,
};

// Size: 0x48
class UNavArea : public UNavAreaBase {
    /* 0x0030 */ float DefaultCost;
    /* 0x0034 */ float FixedAreaEnteringCost;
    /* 0x0038 */ FColor DrawColor;
    /* 0x003c */ FNavAgentSelector SupportedAgents;
    /* 0x0040 */ bool bSupportsAgent0;
    /* 0x0040 */ bool bSupportsAgent1;
    /* 0x0040 */ bool bSupportsAgent2;
    /* 0x0040 */ bool bSupportsAgent3;
    /* 0x0040 */ bool bSupportsAgent4;
    /* 0x0040 */ bool bSupportsAgent5;
    /* 0x0040 */ bool bSupportsAgent6;
    /* 0x0040 */ bool bSupportsAgent7;
    /* 0x0041 */ bool bSupportsAgent8;
    /* 0x0041 */ bool bSupportsAgent9;
    /* 0x0041 */ bool bSupportsAgent10;
    /* 0x0041 */ bool bSupportsAgent11;
    /* 0x0041 */ bool bSupportsAgent12;
    /* 0x0041 */ bool bSupportsAgent13;
    /* 0x0041 */ bool bSupportsAgent14;
    /* 0x0041 */ bool bSupportsAgent15;
};

// Size: 0x48
class UNavAreaMeta : public UNavArea {
};

// Size: 0xc8
class UNavAreaMeta_SwitchByAgent : public UNavAreaMeta {
    /* 0x0048 */ UClass* Agent0Area;
    /* 0x0050 */ UClass* Agent1Area;
    /* 0x0058 */ UClass* Agent2Area;
    /* 0x0060 */ UClass* Agent3Area;
    /* 0x0068 */ UClass* Agent4Area;
    /* 0x0070 */ UClass* Agent5Area;
    /* 0x0078 */ UClass* Agent6Area;
    /* 0x0080 */ UClass* Agent7Area;
    /* 0x0088 */ UClass* Agent8Area;
    /* 0x0090 */ UClass* Agent9Area;
    /* 0x0098 */ UClass* Agent10Area;
    /* 0x00a0 */ UClass* Agent11Area;
    /* 0x00a8 */ UClass* Agent12Area;
    /* 0x00b0 */ UClass* Agent13Area;
    /* 0x00b8 */ UClass* Agent14Area;
    /* 0x00c0 */ UClass* Agent15Area;
};

// Size: 0x48
class UNavArea_Default : public UNavArea {
};

// Size: 0x48
class UNavArea_LowHeight : public UNavArea {
};

// Size: 0x48
class UNavArea_Null : public UNavArea {
};

// Size: 0x48
class UNavArea_Obstacle : public UNavArea {
};

// Size: 0x108
class UNavCollision : public UNavCollisionBase {
    /* 0x00b8 */ TArray<FNavCollisionCylinder> CylinderCollision;
    /* 0x00c8 */ TArray<FNavCollisionBox> BoxCollision;
    /* 0x00d8 */ UClass* AreaClass;
    /* 0x00e0 */ bool bGatherConvexGeometry;
    /* 0x00e0 */ bool bCreateOnClient;
};

// Size: 0x30
struct FNavCollisionBox {
    /* 0x0000 */ FVector Offset;
    /* 0x0018 */ FVector Extent;
};

// Size: 0x20
struct FNavCollisionCylinder {
    /* 0x0000 */ FVector Offset;
    /* 0x0018 */ float Radius;
    /* 0x001c */ float Height;
};

// Size: 0x18
struct FNavGraphEdge {
};

// Size: 0x18
struct FNavGraphNode {
    /* 0x0000 */ UObject* Owner;
};

// Size: 0x540
class UNavLinkComponent : public UPrimitiveComponent {
    /* 0x0528 */ TArray<FNavigationLink> links;
};

// Size: 0x1f8
class UNavLinkCustomComponent : public UNavRelevantComponent {
    /* 0x0110 */ uint32_t NavLinkUserId;
    /* 0x0118 */ FNavLinkId CustomLinkId;
    /* 0x0120 */ FNavLinkAuxiliaryId AuxiliaryCustomLinkId;
    /* 0x0128 */ UClass* EnabledAreaClass;
    /* 0x0130 */ UClass* DisabledAreaClass;
    /* 0x0138 */ FNavAgentSelector SupportedAgents;
    /* 0x0140 */ FVector LinkRelativeStart;
    /* 0x0158 */ FVector LinkRelativeEnd;
    /* 0x0170 */ uint8_t LinkDirection;
    /* 0x0174 */ bool bLinkEnabled;
    /* 0x0174 */ bool bNotifyWhenEnabled;
    /* 0x0174 */ bool bNotifyWhenDisabled;
    /* 0x0174 */ bool bCreateBoxObstacle;
    /* 0x0178 */ FVector ObstacleOffset;
    /* 0x0190 */ FVector ObstacleExtent;
    /* 0x01a8 */ UClass* ObstacleAreaClass;
    /* 0x01b0 */ float BroadcastRadius;
    /* 0x01b4 */ float BroadcastInterval;
    /* 0x01b8 */ uint8_t BroadcastChannel;
};

// Size: 0x78
struct FNavLinkCustomInstanceData : public FActorComponentInstanceData {
    /* 0x0068 */ FNavLinkId CustomLinkId;
    /* 0x0070 */ FNavLinkAuxiliaryId AuxiliaryCustomLinkId;
};

// Size: 0x28
class INavLinkCustomInterface : public UInterface {
};

// Size: 0x58
struct FNavLinkGenerationJumpDownConfig {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ float JumpLength;
    /* 0x0008 */ float JumpDistanceFromEdge;
    /* 0x000c */ float JumpMaxDepth;
    /* 0x0010 */ float JumpHeight;
    /* 0x0014 */ float JumpEndsHeightTolerance;
    /* 0x0018 */ float SamplingSeparationFactor;
    /* 0x001c */ float FilterDistanceThreshold;
    /* 0x0020 */ uint16_t LinkBuilderFlags;
    /* 0x0028 */ UClass* DownDirectionAreaClass;
    /* 0x0030 */ UClass* UpDirectionAreaClass;
    /* 0x0038 */ UClass* LinkProxyClass;
    /* 0x0040 */ FNavLinkId LinkProxyId;
    /* 0x0048 */ UBaseGeneratedNavLinksProxy* LinkProxy;
    /* 0x0050 */ bool bLinkProxyRegistered;
};

// Size: 0x28
class INavLinkHostInterface : public UInterface {
};

// Size: 0x520
class UNavLinkRenderingComponent : public UPrimitiveComponent {
};

// Size: 0x50
class UNavLinkTrivial : public UNavLinkDefinition {
};

// Size: 0x2e8
class ANavMeshBoundsVolume : public AVolume {
    /* 0x02e0 */ FNavAgentSelector SupportedAgents;
};

// Size: 0x590
class UNavMeshRenderingComponent : public UDebugDrawComponent {
};

// Size: 0xc
struct FNavMeshResolutionParam {
    /* 0x0000 */ float CellSize;
    /* 0x0004 */ float CellHeight;
    /* 0x0008 */ float AgentMaxStepHeight;
};

// Size: 0x1b0
class UNavModifierComponent : public UNavRelevantComponent {
    /* 0x0108 */ UClass* AreaClass;
    /* 0x0110 */ UClass* AreaClassToReplace;
    /* 0x0118 */ FVector FailsafeExtent;
    /* 0x0130 */ ENavigationDataResolution NavMeshResolution;
    /* 0x0131 */ bool bIncludeAgentHeight;

    void SetAreaClass(UClass* NewAreaClass);
    void SetAreaClassToReplace(UClass* NewAreaClassToReplace);
};

// Size: 0x300
class ANavModifierVolume : public AVolume {
    /* 0x02e8 */ UClass* AreaClass;
    /* 0x02f0 */ UClass* AreaClassToReplace;
    /* 0x02f8 */ bool bMaskFillCollisionUnderneathForNavmesh;
    /* 0x02f9 */ ENavigationDataResolution NavMeshResolution;

    void SetAreaClass(UClass* NewAreaClass);
    void SetAreaClassToReplace(UClass* NewAreaClassToReplace);
};

// Size: 0x28
class INavNodeInterface : public UInterface {
};

// Size: 0x108
class UNavRelevantComponent : public UActorComponent {
    /* 0x00f8 */ bool bAttachToOwnersRoot;
    /* 0x0100 */ UObject* CachedNavParent;

    void SetNavigationRelevancy(bool bRelevant);
};

// Size: 0x2b8
class ANavSystemConfigOverride : public AActor {
    /* 0x02a8 */ UNavigationSystemConfig* NavigationSystemConfig;
    /* 0x02b0 */ ENavSystemOverridePolicy OverridePolicy;
    /* 0x02b1 */ bool bLoadOnClient;
};

// Size: 0x500
class ANavigationData : public AActor {
    /* 0x02b0 */ UPrimitiveComponent* RenderingComp;
    /* 0x02b8 */ FNavDataConfig NavDataConfig;
    /* 0x0340 */ bool bEnableDrawing;
    /* 0x0340 */ bool bForceRebuildOnLoad;
    /* 0x0340 */ bool bAutoDestroyWhenNoNavigation;
    /* 0x0340 */ bool bCanBeMainNavData;
    /* 0x0340 */ bool bCanSpawnOnRebuild;
    /* 0x0340 */ bool bRebuildAtRuntime;
    /* 0x0344 */ ERuntimeGenerationType RuntimeGeneration;
    /* 0x0348 */ float ObservedPathsTickInterval;
    /* 0x034c */ uint32_t DataVersion;
    /* 0x0460 */ TArray<FSupportedAreaData> SupportedAreas;
};

// Size: 0x18
struct FNavigationFilterArea {
    /* 0x0000 */ UClass* AreaClass;
    /* 0x0008 */ float TravelCostOverride;
    /* 0x000c */ float EnteringCostOverride;
    /* 0x0010 */ bool bIsExcluded;
    /* 0x0010 */ bool bOverrideTravelCost;
    /* 0x0010 */ bool bOverrideEnteringCost;
};

// Size: 0x4
struct FNavigationFilterFlags {
    /* 0x0000 */ bool bNavFlag0;
    /* 0x0000 */ bool bNavFlag1;
    /* 0x0000 */ bool bNavFlag2;
    /* 0x0000 */ bool bNavFlag3;
    /* 0x0000 */ bool bNavFlag4;
    /* 0x0000 */ bool bNavFlag5;
    /* 0x0000 */ bool bNavFlag6;
    /* 0x0000 */ bool bNavFlag7;
    /* 0x0001 */ bool bNavFlag8;
    /* 0x0001 */ bool bNavFlag9;
    /* 0x0001 */ bool bNavFlag10;
    /* 0x0001 */ bool bNavFlag11;
    /* 0x0001 */ bool bNavFlag12;
    /* 0x0001 */ bool bNavFlag13;
    /* 0x0001 */ bool bNavFlag14;
    /* 0x0001 */ bool bNavFlag15;
};

// Size: 0x500
class ANavigationGraph : public ANavigationData {
};

// Size: 0x2a8
class ANavigationGraphNode : public AActor {
};

// Size: 0x270
class UNavigationGraphNodeComponent : public USceneComponent {
    /* 0x0240 */ FNavGraphNode Node;
    /* 0x0258 */ UNavigationGraphNodeComponent* NextNodeComponent;
    /* 0x0260 */ UNavigationGraphNodeComponent* PrevNodeComponent;
};

// Size: 0xc8
class UNavigationInvokerComponent : public UActorComponent {
    /* 0x00b8 */ float TileGenerationRadius;
    /* 0x00bc */ float TileRemovalRadius;
    /* 0x00c0 */ FNavAgentSelector SupportedAgents;
    /* 0x00c4 */ ENavigationInvokerPriority Priority;
};

// Size: 0x120
class UNavigationObjectRepository : public UWorldSubsystem {
};

// Size: 0x88
class UNavigationPath : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate PathUpdatedNotifier;
    /* 0x0038 */ TArray<FVector> PathPoints;
    /* 0x0048 */ ENavigationOptionFlag RecalculateOnInvalidation;

    void EnableDebugDrawing(bool bShouldDrawDebugData, FLinearColor PathColor);
    void EnableRecalculationOnInvalidation(ENavigationOptionFlag DoRecalculation);
    FString GetDebugString() const;
    double GetPathCost() const;
    double GetPathLength() const;
    bool IsPartial() const;
    bool IsStringPulled() const;
    bool IsValid() const;
};

// Size: 0x28
class INavigationPathGenerator : public UInterface {
};

// Size: 0x48
class UNavigationQueryFilter : public UObject {
    /* 0x0028 */ TArray<FNavigationFilterArea> Areas;
    /* 0x0038 */ FNavigationFilterFlags IncludeFlags;
    /* 0x003c */ FNavigationFilterFlags ExcludeFlags;
};

// Size: 0x60
class UNavigationSystemModuleConfig : public UNavigationSystemConfig {
    /* 0x0058 */ bool bStrictlyStatic;
    /* 0x0058 */ bool bCreateOnClient;
    /* 0x0058 */ bool bAutoSpawnMissingNavData;
    /* 0x0058 */ bool bSpawnNavDataInNavBoundsLevel;
};

// Size: 0x1610
class UNavigationSystemV1 : public UNavigationSystemBase {
    /* 0x0028 */ ANavigationData* MainNavData;
    /* 0x0030 */ ANavigationData* AbstractNavData;
    /* 0x0038 */ FName DefaultAgentName;
    /* 0x0040 */ TSoftClassPtr<UCrowdManagerBase> CrowdManagerClass;
    /* 0x0068 */ bool bAutoCreateNavigationData;
    /* 0x0068 */ bool bSpawnNavDataInNavBoundsLevel;
    /* 0x0068 */ bool bAllowClientSideNavigation;
    /* 0x0068 */ bool bShouldDiscardSubLevelNavData;
    /* 0x0068 */ bool bTickWhilePaused;
    /* 0x0068 */ bool bSupportRebuilding;
    /* 0x0068 */ bool bInitialBuildingLocked;
    /* 0x0069 */ bool bSkipAgentHeightCheckWhenPickingNavData;
    /* 0x006c */ int32_t GeometryExportTriangleCountWarningThreshold;
    /* 0x0070 */ bool bGenerateNavigationOnlyAroundNavigationInvokers;
    /* 0x0074 */ float ActiveTilesUpdateInterval;
    /* 0x0078 */ double InvokersMaximumDistanceFromSeed;
    /* 0x0080 */ ENavDataGatheringModeConfig DataGatheringMode;
    /* 0x0084 */ float DirtyAreaWarningSizeThreshold;
    /* 0x0088 */ float GatheringNavModifiersWarningLimitTime;
    /* 0x0090 */ TArray<FNavDataConfig> SupportedAgents;
    /* 0x00a0 */ FNavAgentSelector SupportedAgentsMask;
    /* 0x00a8 */ FBox BuildBounds;
    /* 0x00e0 */ TArray<ANavigationData*> NavDataSet;
    /* 0x00f0 */ TArray<ANavigationData*> NavDataRegistrationQueue;
    /* 0x0110 */ FMulticastInlineDelegate OnNavDataRegisteredEvent;
    /* 0x0120 */ FMulticastInlineDelegate OnNavigationGenerationFinishedDelegate;
    /* 0x0220 */ FNavigationSystemRunMode OperationMode;
    /* 0x04a8 */ UNavigationObjectRepository* Repository;

    static UNavigationPath* FindPathToActorSynchronously(UObject* WorldContextObject, const FVector& PathStart, AActor* GoalActor, float TetherDistance, AActor* PathfindingContext, UClass* FilterClass);
    static UNavigationPath* FindPathToLocationSynchronously(UObject* WorldContextObject, const FVector& PathStart, const FVector& PathEnd, AActor* PathfindingContext, UClass* FilterClass);
    static UNavigationSystemV1* GetNavigationSystem(UObject* WorldContextObject);
    static uint8_t GetPathCost(UObject* WorldContextObject, const FVector& PathStart, const FVector& PathEnd, double& PathCost, ANavigationData* NavData, UClass* FilterClass);
    static uint8_t GetPathLength(UObject* WorldContextObject, const FVector& PathStart, const FVector& PathEnd, double& PathLength, ANavigationData* NavData, UClass* FilterClass);
    static bool IsNavigationBeingBuilt(UObject* WorldContextObject);
    static bool IsNavigationBeingBuiltOrLocked(UObject* WorldContextObject);
    static bool K2_GetRandomLocationInNavigableRadius(UObject* WorldContextObject, const FVector& Origin, FVector& RandomLocation, float Radius, ANavigationData* NavData, UClass* FilterClass);
    static bool K2_GetRandomPointInNavigableRadius(UObject* WorldContextObject, const FVector& Origin, FVector& RandomLocation, float Radius, ANavigationData* NavData, UClass* FilterClass);
    static bool K2_GetRandomReachablePointInRadius(UObject* WorldContextObject, const FVector& Origin, FVector& RandomLocation, float Radius, ANavigationData* NavData, UClass* FilterClass);
    static bool K2_ProjectPointToNavigation(UObject* WorldContextObject, const FVector& Point, FVector& ProjectedLocation, ANavigationData* NavData, UClass* FilterClass, const FVector QueryExtent);
    bool K2_ReplaceAreaInOctreeData(const UObject* Object, UClass* OldArea, UClass* NewArea);
    static bool NavigationRaycast(UObject* WorldContextObject, const FVector& RayStart, const FVector& RayEnd, FVector& HitLocation, UClass* FilterClass, AController* Querier);
    void OnNavigationBoundsUpdated(ANavMeshBoundsVolume* NavVolume);
    void RegisterNavigationInvoker(AActor* Invoker, float TileGenerationRadius, float TileRemovalRadius);
    void ResetMaxSimultaneousTileGenerationJobsCount();
    void SetGeometryGatheringMode(ENavDataGatheringModeConfig NewMode);
    void SetMaxSimultaneousTileGenerationJobsCount(int32_t MaxNumberOfJobs);
    void UnregisterNavigationInvoker(AActor* Invoker);
};

// Size: 0x400
class ANavigationTestingActor : public AActor {
    /* 0x02b8 */ UCapsuleComponent* CapsuleComponent;
    /* 0x02c0 */ UNavigationInvokerComponent* InvokerComponent;
    /* 0x02c8 */ bool bActAsNavigationInvoker;
    /* 0x02d0 */ FNavAgentProperties NavAgentProps;
    /* 0x0308 */ FVector QueryingExtent;
    /* 0x0320 */ ANavigationData* MyNavData;
    /* 0x0328 */ FVector ProjectedLocation;
    /* 0x0340 */ bool bProjectedLocationValid;
    /* 0x0340 */ bool bSearchStart;
    /* 0x0344 */ float CostLimitFactor;
    /* 0x0348 */ float MinimumCostLimit;
    /* 0x034c */ bool bBacktracking;
    /* 0x034c */ bool bUseHierarchicalPathfinding;
    /* 0x034c */ bool bGatherDetailedInfo;
    /* 0x034c */ bool bRequireNavigableEndLocation;
    /* 0x034c */ bool bDrawDistanceToWall;
    /* 0x034c */ bool bDrawIfNavDataIsReadyInRadius;
    /* 0x034c */ bool bDrawIfNavDataIsReadyToQueryTargetActor;
    /* 0x034c */ bool bDrawRaycastToQueryTargetActor;
    /* 0x0350 */ AActor* QueryTargetActor;
    /* 0x0358 */ bool bShowNodePool;
    /* 0x0358 */ bool bShowBestPath;
    /* 0x0358 */ bool bShowDiffWithPreviousStep;
    /* 0x0358 */ bool bShouldBeVisibleInGame;
    /* 0x035c */ float RadiusUsedToValidateNavData;
    /* 0x0360 */ uint8_t CostDisplayMode;
    /* 0x0368 */ FVector2D TextCanvasOffset;
    /* 0x0378 */ bool bPathExist;
    /* 0x0378 */ bool bPathIsPartial;
    /* 0x0378 */ bool bPathSearchOutOfNodes;
    /* 0x037c */ float PathfindingTime;
    /* 0x0380 */ double PathCost;
    /* 0x0388 */ int32_t PathfindingSteps;
    /* 0x0390 */ ANavigationTestingActor* OtherActor;
    /* 0x0398 */ UClass* FilterClass;
    /* 0x03a0 */ int32_t ShowStepIndex;
    /* 0x03a4 */ float OffsetFromCornersDistance;
};

// Size: 0x48
class URecastFilter_UseDefaultArea : public UNavigationQueryFilter {
};

// Size: 0x798
class ARecastNavMesh : public ANavigationData {
    /* 0x0500 */ bool bDrawTriangleEdges;
    /* 0x0500 */ bool bDrawPolyEdges;
    /* 0x0500 */ bool bDrawFilledPolys;
    /* 0x0500 */ bool bDrawNavMeshEdges;
    /* 0x0500 */ bool bDrawTileBounds;
    /* 0x0500 */ bool bDrawTileResolutions;
    /* 0x0500 */ bool bDrawPathCollidingGeometry;
    /* 0x0500 */ bool bDrawTileLabels;
    /* 0x0501 */ bool bDrawTileBuildTimes;
    /* 0x0501 */ bool bDrawTileBuildTimesHeatMap;
    /* 0x0501 */ bool bDrawPolygonLabels;
    /* 0x0501 */ bool bDrawDefaultPolygonCost;
    /* 0x0501 */ bool bDrawPolygonFlags;
    /* 0x0501 */ bool bDrawLabelsOnPathNodes;
    /* 0x0501 */ bool bDrawNavLinks;
    /* 0x0501 */ bool bDrawFailedNavLinks;
    /* 0x0502 */ bool bDrawClusters;
    /* 0x0502 */ bool bDrawOctree;
    /* 0x0502 */ bool bDrawOctreeDetails;
    /* 0x0502 */ bool bDrawMarkedForbiddenPolys;
    /* 0x0502 */ bool bDistinctlyDrawTilesBeingBuilt;
    /* 0x0504 */ float DrawOffset;
    /* 0x0508 */ FRecastNavMeshTileGenerationDebug TileGenerationDebug;
    /* 0x0538 */ bool bFixedTilePoolSize;
    /* 0x053c */ int32_t TilePoolSize;
    /* 0x0540 */ float TileSizeUU;
    /* 0x0544 */ float CellSize;
    /* 0x0548 */ float CellHeight;
    /* 0x054c */ float AgentMaxStepHeight;
    /* 0x0550 */ FNavMeshResolutionParam NavMeshResolutionParams[3];
    /* 0x0574 */ float AgentRadius;
    /* 0x0578 */ float AgentHeight;
    /* 0x057c */ float AgentMaxSlope;
    /* 0x0580 */ float MinRegionArea;
    /* 0x0584 */ float MergeRegionSize;
    /* 0x0588 */ int32_t MaxVerticalMergeError;
    /* 0x058c */ float MaxSimplificationError;
    /* 0x0590 */ float SimplificationElevationRatio;
    /* 0x0594 */ int32_t MaxSimultaneousTileGenerationJobsCount;
    /* 0x0598 */ int32_t TileNumberHardLimit;
    /* 0x059c */ int32_t ExpectedMaxLayersPerTile;
    /* 0x05a0 */ int32_t PolyRefTileBits;
    /* 0x05a4 */ int32_t PolyRefNavPolyBits;
    /* 0x05a8 */ int32_t PolyRefSaltBits;
    /* 0x05b0 */ FVector NavMeshOriginOffset;
    /* 0x05c8 */ float DefaultDrawDistance;
    /* 0x05cc */ float DefaultMaxSearchNodes;
    /* 0x05d0 */ float DefaultMaxHierarchicalSearchNodes;
    /* 0x05d4 */ ENavigationLedgeSlopeFilterMode LedgeSlopeFilterMode;
    /* 0x05d5 */ uint8_t RegionPartitioning;
    /* 0x05d6 */ uint8_t LayerPartitioning;
    /* 0x05d8 */ int32_t RegionChunkSplits;
    /* 0x05dc */ int32_t LayerChunkSplits;
    /* 0x05e0 */ bool bSortNavigationAreasByCost;
    /* 0x05e0 */ bool bIsWorldPartitioned;
    /* 0x05e0 */ bool bGenerateNavLinks;
    /* 0x05e0 */ bool bPerformVoxelFiltering;
    /* 0x05e0 */ bool bMarkLowHeightAreas;
    /* 0x05e0 */ bool bUseExtraTopCellWhenMarkingAreas;
    /* 0x05e0 */ bool bFilterLowSpanSequences;
    /* 0x05e0 */ bool bFilterLowSpanFromTileCache;
    /* 0x05e1 */ bool bDoFullyAsyncNavDataGathering;
    /* 0x05e1 */ bool bUseBetterOffsetsFromCorners;
    /* 0x05e1 */ bool bStoreEmptyTileLayers;
    /* 0x05e1 */ bool bUseVirtualFilters;
    /* 0x05e1 */ bool bUseVirtualGeometryFilteringAndDirtying;
    /* 0x05e1 */ bool bAllowNavLinkAsPathEnd;
    /* 0x05e4 */ int32_t TimeSliceFilterLedgeSpansMaxYProcess;
    /* 0x05e8 */ double TimeSliceLongDurationDebug;
    /* 0x05f0 */ uint32_t InvokerTilePriorityBumpDistanceThresholdInTileUnits;
    /* 0x05f4 */ uint8_t InvokerTilePriorityBumpIncrease;
    /* 0x05f8 */ FNavLinkGenerationJumpDownConfig NavLinkJumpDownConfig;
    /* 0x0654 */ bool bUseVoxelCache;
    /* 0x0658 */ float TileSetUpdateInterval;
    /* 0x065c */ float HeuristicScale;
    /* 0x0660 */ float VerticalDeviationFromGroundCompensation;

    bool K2_ReplaceAreaInTileBounds(FBox Bounds, UClass* OldArea, UClass* NewArea, bool ReplaceLinks);
};

// Size: 0x40
class URecastNavMeshDataChunk : public UNavigationDataChunk {
};

// Size: 0x30
struct FRecastNavMeshTileGenerationDebug {
    /* 0x0000 */ bool bEnabled;
    /* 0x0004 */ FIntVector TileCoordinate;
    /* 0x0010 */ FIntVector MaxTileCoordinate;
    /* 0x001c */ bool bGenerateDebugTileOnly;
    /* 0x001c */ bool bCollisionGeometry;
    /* 0x0020 */ EHeightFieldRenderMode HeightFieldRenderMode;
    /* 0x0024 */ bool bHeightfieldFromRasterization;
    /* 0x0024 */ bool bHeightfieldPostInclusionBoundsFiltering;
    /* 0x0024 */ bool bHeightfieldPostHeightFiltering;
    /* 0x0024 */ bool bHeightfieldBounds;
    /* 0x0024 */ bool bCompactHeightfield;
    /* 0x0024 */ bool bCompactHeightfieldEroded;
    /* 0x0024 */ bool bHeightFieldLayers;
    /* 0x0024 */ bool bCompactHeightfieldRegions;
    /* 0x0025 */ bool bCompactHeightfieldDistances;
    /* 0x0025 */ bool bTileCacheLayerAreas;
    /* 0x0025 */ bool bTileCacheLayerRegions;
    /* 0x0025 */ bool bSkipContourSimplification;
    /* 0x0025 */ bool bTileCacheContours;
    /* 0x0025 */ bool bTileCachePolyMesh;
    /* 0x0025 */ bool bTileCacheDetailMesh;
    /* 0x0025 */ bool bUseMaxTileCoordinate;
    /* 0x0028 */ uint16_t LinkGenerationDebugFlags;
    /* 0x002c */ int32_t LinkGenerationSelectedEdge;
};

// Size: 0x260
class USplineNavModifierComponent : public UNavModifierComponent {
    /* 0x01b0 */ bool bUpdateNavDataOnSplineChange;
    /* 0x01b8 */ FComponentReference AttachedSpline;
    /* 0x01e0 */ double StrokeWidth;
    /* 0x01e8 */ double StrokeHeight;
    /* 0x01f0 */ ESubdivisionLOD SubdivisionLOD;

    void UpdateNavigationWithComponentData();
};

// Size: 0x20
struct FSupportedAreaData {
    /* 0x0000 */ FString AreaClassName;
    /* 0x0010 */ int32_t AreaID;
    /* 0x0018 */ UClass* AreaClass;
};

enum class EFastArraySerializerDeltaFlags {
    None = 0,
    HasBeenSerialized = 1,
    HasDeltaBeenRequested = 2,
    IsUsingDeltaSerialization = 4,
    EFastArraySerializerDeltaFlags_MAX = 5,
};

enum class ENetCloseResult {
    NetDriverAlreadyExists = 0,
    NetDriverCreateFailure = 1,
    NetDriverListenFailure = 2,
    ConnectionLost = 3,
    ConnectionTimeout = 4,
    FailureReceived = 5,
    OutdatedClient = 6,
    OutdatedServer = 7,
    PendingConnectionFailure = 8,
    NetGuidMismatch = 9,
    NetChecksumMismatch = 10,
    SecurityMalformedPacket = 11,
    SecurityInvalidData = 12,
    SecurityClosed = 13,
    Unknown = 14,
    Success = 15,
    Extended = 16,
    HostClosedConnection = 17,
    Disconnect = 18,
    Upgrade = 19,
    PreLoginFailure = 20,
    JoinFailure = 21,
    JoinSplitFailure = 22,
    AddressResolutionFailed = 23,
    RPCDoS = 24,
    Cleanup = 25,
    MissingLevelPackage = 26,
    PacketHandlerIncomingError = 27,
    ZeroLastByte = 28,
    ZeroSize = 29,
    ReadHeaderFail = 30,
    ReadHeaderExtraFail = 31,
    AckSequenceMismatch = 32,
    BunchBadChannelIndex = 33,
    BunchChannelNameFail = 34,
    BunchWrongChannelType = 35,
    BunchHeaderOverflow = 36,
    BunchDataOverflow = 37,
    BunchServerPackageMapExports = 38,
    BunchPrematureControlChannel = 39,
    BunchPrematureChannel = 40,
    BunchPrematureControlClose = 41,
    UnknownChannelType = 42,
    PrematureSend = 43,
    CorruptData = 44,
    SocketSendFailure = 45,
    BadChildConnectionIndex = 46,
    LogLimitInstant = 47,
    LogLimitSustained = 48,
    EncryptionFailure = 49,
    EncryptionTokenMissing = 50,
    ReceivedNetGUIDBunchFail = 51,
    ReceivedNetExtBunchFail = 52,
    MaxReliableExceeded = 53,
    ReceivedNextBunchFail = 54,
    ReceivedNextBunchQueueFail = 55,
    PartialInitialReliableDestroy = 56,
    PartialMergeReliableDestroy = 57,
    PartialInitialNonByteAligned = 58,
    PartialNonByteAligned = 59,
    PartialFinalPackageMapExports = 60,
    PartialTooLarge = 61,
    AlreadyOpen = 62,
    ReliableBeforeOpen = 63,
    ReliableBufferOverflow = 64,
    RPCReliableBufferOverflow = 65,
    ControlChannelClose = 66,
    ControlChannelEndianCheck = 67,
    ControlChannelPlayerChannelFail = 68,
    ControlChannelMessageUnknown = 69,
    ControlChannelMessageFail = 70,
    ControlChannelMessagePayloadFail = 71,
    ControlChannelBunchOverflowed = 72,
    ControlChannelQueueBunchOverflowed = 73,
    ClientHasMustBeMappedGUIDs = 74,
    ClientSentDestructionInfo = 75,
    UnregisteredMustBeMappedGUID = 76,
    ObjectReplicatorReceivedBunchFail = 77,
    ContentBlockFail = 78,
    ContentBlockHeaderRepLayoutFail = 79,
    ContentBlockHeaderIsActorFail = 80,
    ContentBlockHeaderObjFail = 81,
    ContentBlockHeaderPrematureEnd = 82,
    ContentBlockHeaderSubObjectActor = 83,
    ContentBlockHeaderBadParent = 84,
    ContentBlockHeaderInvalidCreate = 85,
    ContentBlockHeaderStablyNamedFail = 86,
    ContentBlockHeaderNoSubObjectClass = 87,
    ContentBlockHeaderUObjectSubObject = 88,
    ContentBlockHeaderAActorSubObject = 89,
    ContentBlockHeaderFail = 90,
    ContentBlockPayloadBitsFail = 91,
    FieldHeaderRepIndex = 92,
    FieldHeaderBadRepIndex = 93,
    FieldHeaderPayloadBitsFail = 94,
    FieldPayloadFail = 95,
    ReplicationChannelCountMaxedOut = 96,
    BeaconControlFlowError = 97,
    BeaconUnableToParsePacket = 98,
    BeaconAuthenticationFailure = 99,
    BeaconLoginInvalidIdError = 100,
    BeaconLoginInvalidAuthHandlerError = 101,
    BeaconAuthError = 102,
    BeaconSpawnClientWorldPackageNameError = 103,
    BeaconSpawnExistingActorError = 104,
    BeaconSpawnFailureError = 105,
    BeaconSpawnNetGUIDAckNoActor = 106,
    BeaconSpawnNetGUIDAckNoHost = 107,
    BeaconSpawnUnexpectedError = 108,
    IrisProtocolMismatch = 109,
    IrisNetRefHandleError = 110,
    FaultDisconnect = 111,
    NotRecoverable = 112,
    ENetCloseResult_MAX = 113,
};

enum class ENetworkFailure {
    NetDriverAlreadyExists = 0,
    NetDriverCreateFailure = 1,
    NetDriverListenFailure = 2,
    ConnectionLost = 3,
    ConnectionTimeout = 4,
    FailureReceived = 5,
    OutdatedClient = 6,
    OutdatedServer = 7,
    PendingConnectionFailure = 8,
    NetGuidMismatch = 9,
    NetChecksumMismatch = 10,
    ENetworkFailure_MAX = 11,
};

enum class EReplicationSystem {
    Default = 0,
    Generic = 1,
    Iris = 2,
    EReplicationSystem_MAX = 3,
};

// Size: 0x88
class UEscalationManagerConfig : public UStatePerObjectConfig {
    /* 0x0068 */ TArray<FString> EscalationSeverity;
};

// Size: 0x30
struct FEscalationState : public FStateStruct {
    /* 0x0018 */ bool bLogEscalate;
    /* 0x0019 */ bool bDormant;
    /* 0x001a */ int16_t CooloffTime;
    /* 0x001c */ int16_t AutoEscalateTime;
    /* 0x001e */ int8_t HighestTimePeriod;
    /* 0x0020 */ TArray<int8_t> AllTimePeriods;
};

// Size: 0x108
struct FFastArraySerializer {
    /* 0x0050 */ int32_t IDCounter;
    /* 0x0054 */ int32_t ArrayReplicationKey;
    /* 0x0100 */ EFastArraySerializerDeltaFlags DeltaFlags;
};

// Size: 0xc
struct FFastArraySerializerItem {
    /* 0x0000 */ int32_t ReplicationID;
    /* 0x0004 */ int32_t ReplicationKey;
    /* 0x0008 */ int32_t MostRecentArrayReplicationKey;
};

// Size: 0x38
class UNetAnalyticsAggregatorConfig : public UObject {
    /* 0x0028 */ TArray<FNetAnalyticsDataConfig> NetAnalyticsData;
};

// Size: 0xc
struct FNetAnalyticsDataConfig {
    /* 0x0000 */ FName DataName;
    /* 0x0008 */ bool bEnabled;
};

// Size: 0x40
struct FNetFaultState : public FEscalationState {
    /* 0x0030 */ bool bCloseConnection;
    /* 0x0032 */ int16_t EscalateQuotaFaultsPerPeriod;
    /* 0x0034 */ int8_t EscalateQuotaFaultPercentPerPeriod;
    /* 0x0036 */ int16_t DescalateQuotaFaultsPerPeriod;
    /* 0x0038 */ int8_t DescalateQuotaFaultPercentPerPeriod;
    /* 0x0039 */ int8_t EscalateQuotaTimePeriod;
};

// Size: 0x68
class UStatePerObjectConfig : public UObject {
    /* 0x0050 */ FString PerObjectConfigSection;
    /* 0x0060 */ bool bEnabled;
};

// Size: 0x18
struct FStateStruct {
    /* 0x0008 */ FString StateName;
};

// Size: 0x130
class UAsyncNiagaraCaptureSimCache : public UCancellableAsyncAction {
    /* 0x0030 */ UNiagaraSimCache* CaptureSimCache;
    /* 0x0038 */ UNiagaraComponent* CaptureComponent;
    /* 0x0040 */ FMulticastInlineDelegate CaptureComplete;

    static UAsyncNiagaraCaptureSimCache* CaptureNiagaraSimCache(UNiagaraSimCache* SimCache, FNiagaraSimCacheCreateParameters CreateParameters, UNiagaraComponent* NiagaraComponent, FNiagaraSimCacheCaptureParameters CaptureParameters, UNiagaraSimCache*& OutSimCache);
    static UAsyncNiagaraCaptureSimCache* CaptureNiagaraSimCacheMultiFrame(UNiagaraSimCache* SimCache, FNiagaraSimCacheCreateParameters CreateParameters, UNiagaraComponent* NiagaraComponent, UNiagaraSimCache*& OutSimCache, int32_t NumFrames, int32_t CaptureRate, bool bAdvanceSimulation, float AdvanceDeltaTime);
    static UAsyncNiagaraCaptureSimCache* CaptureNiagaraSimCacheUntilComplete(UNiagaraSimCache* SimCache, FNiagaraSimCacheCreateParameters CreateParameters, UNiagaraComponent* NiagaraComponent, UNiagaraSimCache*& OutSimCache, int32_t CaptureRate, bool bAdvanceSimulation, float AdvanceDeltaTime);
    void OnCaptureComplete__DelegateSignature(bool bSuccess);
};

// Size: 0x38
struct FBasicParticleData {
    /* 0x0000 */ FVector position;
    /* 0x0018 */ float Size;
    /* 0x0020 */ FVector Velocity;
};

enum class ENCPoolMethod {
    None = 0,
    AutoRelease = 1,
    ManualRelease = 2,
    ManualRelease_OnComplete = 3,
    FreeInPool = 4,
    ENCPoolMethod_MAX = 5,
};

enum class ENDIActorComponentSourceMode {
    Default = 0,
    AttachParent = 1,
    LocalPlayer = 2,
    ENDIActorComponentSourceMode_MAX = 3,
};

enum class ENDICollisionQuery_AsyncGpuTraceProvider {
    Default = 0,
    HWRT = 1,
    GSDF = 2,
    None = 3,
    ENDICollisionQuery_MAX = 4,
};

enum class ENDIDataChannelSpawnMode {
    Override = 0,
    Accumulate = 1,
    None = 2,
    Max = 3,
};

enum class ENDIDataChannelSpawnScaleMode {
    Override = 0,
    Scale = 1,
    Max = 2,
};

enum class ENDIExport_GPUAllocationMode {
    FixedSize = 0,
    PerParticle = 1,
    ENDIExport_MAX = 2,
};

enum class ENDILandscape_SourceMode {
    Default = 0,
    Source = 1,
    AttachParent = 2,
    ENDILandscape_MAX = 3,
};

enum class ENDIObjectPropertyReaderSourceMode {
    Binding = 0,
    AttachParentActor = 1,
    BindingThenAttachParentActor = 2,
    AttachParent = 3,
    BindingThenAttachParent = 4,
    ENDIObjectPropertyReaderSourceMode_MAX = 5,
};

enum class ENDISceneCapture2DOffsetMode {
    Disabled = 0,
    RelativeLocal = 1,
    RelativeWorld = 2,
    AbsoluteWorld = 3,
    ENDISceneCapture2DOffsetMode_MAX = 4,
};

enum class ENDISceneCapture2DSourceMode {
    UserParameterThenAttachParent = 0,
    UserParameterOnly = 1,
    AttachParentOnly = 2,
    Managed = 3,
    ENDISceneCapture2DSourceMode_MAX = 4,
};

enum class ENDISkelMesh_AdjacencyTriangleIndexFormat {
    Full = 0,
    Half = 1,
    ENDISkelMesh_MAX = 2,
};

enum class ENDISkelMesh_GpuMaxInfluences {
    AllowMax4 = 0,
    AllowMax8 = 1,
    Unlimited = 2,
    ENDISkelMesh_MAX = 3,
};

enum class ENDISkelMesh_GpuUniformSamplingFormat {
    Full = 0,
    Limited_24_8 = 1,
    Limited_23_9 = 2,
    ENDISkelMesh_MAX = 3,
};

enum class ENDISkeletalMesh_SkinningMode {
    Invalid = 255,
    None = 0,
    SkinOnTheFly = 1,
    PreSkin = 2,
    ENDISkeletalMesh_MAX = 256,
};

enum class ENDISkeletalMesh_SourceMode {
    Default = 0,
    Source = 1,
    AttachParent = 2,
    DefaultMeshOnly = 3,
    ENDISkeletalMesh_MAX = 4,
};

enum class ENDISocketReaderSourceMode {
    Default = 0,
    ParameterBindingOnly = 1,
    AttachedParentOnly = 2,
    SourceOnly = 3,
    ENDISocketReaderSourceMode_MAX = 4,
};

enum class ENDIStaticMesh_SourceMode {
    Default = 0,
    Source = 1,
    AttachParent = 2,
    DefaultMeshOnly = 3,
    MeshParameterBinding = 4,
    ENDIStaticMesh_MAX = 5,
};

enum class ENSMInitialMeshOrientationMode {
    None = 0,
    Random = 1,
    OrientToAxis = 2,
    ENSMInitialMeshOrientationMode_MAX = 3,
};

enum class ENSMSubUVAnimation_Mode {
    DirectSet = 0,
    InfiniteLoop = 1,
    Linear = 2,
    Random = 3,
    ENSMSubUVAnimation_MAX = 4,
};

enum class ENSM_ShapePrimitive {
    Box = 0,
    Cylinder = 1,
    Plane = 2,
    Ring = 3,
    Sphere = 4,
    Max = 5,
};

enum class ENSM_SurfaceExpansionMode {
    Inner = 0,
    Centered = 1,
    Outside = 2,
    ENSM_MAX = 3,
};

enum class ENSM_VelocityType {
    Linear = 0,
    FromPoint = 1,
    InCone = 2,
    ENSM_MAX = 3,
};

enum class ENiagaraAgeUpdateMode {
    TickDeltaTime = 0,
    DesiredAge = 1,
    DesiredAgeNoSeek = 2,
    ENiagaraAgeUpdateMode_MAX = 3,
};

enum class ENiagaraAssetLibraryAssetTypes {
    Emitters = 1,
    Systems = 2,
    Scripts = 4,
    ENiagaraAssetLibraryAssetTypes_MAX = 5,
};

enum class ENiagaraAssetTagDefinitionImportance {
    Primary = 0,
    Secondary = 1,
    Internal = 2,
    ENiagaraAssetTagDefinitionImportance_MAX = 3,
};

enum class ENiagaraBakerViewMode {
    Perspective = 0,
    OrthoFront = 1,
    OrthoBack = 2,
    OrthoLeft = 3,
    OrthoRight = 4,
    OrthoTop = 5,
    OrthoBottom = 6,
    Num = 7,
    ENiagaraBakerViewMode_MAX = 8,
};

enum class ENiagaraBaseTypes {
    Half = 0,
    Float = 1,
    Int32 = 2,
    Bool = 3,
    Max = 4,
};

enum class ENiagaraBindingSource {
    ImplicitFromSource = 0,
    ExplicitParticles = 1,
    ExplicitEmitter = 2,
    ExplicitSystem = 3,
    ExplicitUser = 4,
    MaxBindingSource = 5,
    ENiagaraBindingSource_MAX = 6,
};

enum class ENiagaraBoolDisplayMode {
    DisplayAlways = 0,
    DisplayIfTrue = 1,
    DisplayIfFalse = 2,
    ENiagaraBoolDisplayMode_MAX = 3,
};

enum class ENiagaraCVarConditionResponse {
    None = 0,
    Enable = 1,
    Disable = 2,
    ENiagaraCVarConditionResponse_MAX = 3,
};

enum class ENiagaraCollisionMode {
    None = 0,
    SceneGeometry = 1,
    DepthBuffer = 2,
    DistanceField = 3,
    ENiagaraCollisionMode_MAX = 4,
};

enum class ENiagaraCompilationState {
    CheckDDC = 0,
    Precompile = 1,
    StartCompileJob = 2,
    AwaitResult = 3,
    OptimizeByteCode = 4,
    ProcessResult = 5,
    PutToDDC = 6,
    Finished = 7,
    Aborted = 8,
    ENiagaraCompilationState_MAX = 9,
};

enum class ENiagaraCompileErrorSeverity {
    Ignore = 0,
    LogOnly = 1,
    Warning = 2,
    Error = 3,
    ENiagaraCompileErrorSeverity_MAX = 4,
};

enum class ENiagaraCompileUsageStaticSwitch {
    Spawn = 0,
    Update = 1,
    Event = 2,
    SimulationStage = 3,
    Default = 4,
    ENiagaraCompileUsageStaticSwitch_MAX = 5,
};

enum class ENiagaraConditionalOperator {
    Equals = 0,
    NotEqual = 1,
    LessThan = 2,
    LessThanOrEqual = 3,
    GreaterThan = 4,
    GreaterThanOrEqual = 5,
    Max = 6,
};

enum class ENiagaraCoordinateSpace {
    Simulation = 0,
    World = 1,
    Local = 2,
    ENiagaraCoordinateSpace_MAX = 3,
};

enum class ENiagaraCullProxyMode {
    None = 0,
    Instanced_Rendered = 1,
    ENiagaraCullProxyMode_MAX = 2,
};

enum class ENiagaraCullReaction {
    Deactivate = 0,
    DeactivateImmediate = 1,
    DeactivateResume = 2,
    DeactivateImmediateResume = 3,
    PauseResume = 4,
    ENiagaraCullReaction_MAX = 5,
};

enum class ENiagaraDataChannelAllocationMode {
    Static = 0,
    Dynamic = 1,
    ENiagaraDataChannelAllocationMode_MAX = 2,
};

enum class ENiagaraDataInterfaceEmitterBindingMode {
    Self = 0,
    Other = 1,
    ENiagaraDataInterfaceEmitterBindingMode_MAX = 2,
};

enum class ENiagaraDataSetType {
    ParticleData = 0,
    Shared = 1,
    Event = 2,
    ENiagaraDataSetType_MAX = 3,
};

enum class ENiagaraDebugHUDDOverviewSort {
    Name = 0,
    NumberRegistered = 1,
    NumberActive = 2,
    NumberScalability = 3,
    MemoryUsage = 4,
    RecentlyVisibilty = 5,
    ENiagaraDebugHUDDOverviewSort_MAX = 6,
};

enum class ENiagaraDebugHUDOverviewMode {
    Overview = 0,
    Scalability = 1,
    Performance = 2,
    PerformanceGraph = 3,
    GpuComputePerformance = 4,
    ENiagaraDebugHUDOverviewMode_MAX = 5,
};

enum class ENiagaraDebugHUDPerfGraphMode {
    GameThread = 0,
    RenderThread = 1,
    GPU = 2,
    ENiagaraDebugHUDPerfGraphMode_MAX = 3,
};

enum class ENiagaraDebugHUDPerfSampleMode {
    FrameTotal = 0,
    PerInstanceAverage = 1,
    ENiagaraDebugHUDPerfSampleMode_MAX = 2,
};

enum class ENiagaraDebugHUDPerfUnits {
    Microseconds = 0,
    Milliseconds = 1,
    ENiagaraDebugHUDPerfUnits_MAX = 2,
};

enum class ENiagaraDebugHudFont {
    Small = 0,
    Normal = 1,
    ENiagaraDebugHudFont_MAX = 2,
};

enum class ENiagaraDebugHudHAlign {
    Left = 0,
    Center = 1,
    Right = 2,
    ENiagaraDebugHudHAlign_MAX = 3,
};

enum class ENiagaraDebugHudVAlign {
    Top = 0,
    Center = 1,
    Bottom = 2,
    ENiagaraDebugHudVAlign_MAX = 3,
};

enum class ENiagaraDebugHudVerbosity {
    None = 0,
    Basic = 1,
    Verbose = 2,
    ENiagaraDebugHudVerbosity_MAX = 3,
};

enum class ENiagaraDebugPlaybackMode {
    Play = 0,
    Loop = 1,
    Paused = 2,
    Step = 3,
    ENiagaraDebugPlaybackMode_MAX = 4,
};

enum class ENiagaraDefaultGpuTranslucentLatency {
    Immediate = 0,
    Latent = 1,
    ENiagaraDefaultGpuTranslucentLatency_MAX = 2,
};

enum class ENiagaraDefaultMode {
    Value = 0,
    Binding = 1,
    Custom = 2,
    FailIfPreviouslyNotSet = 3,
    ENiagaraDefaultMode_MAX = 4,
};

enum class ENiagaraDefaultRendererMotionVectorSetting {
    Precise = 0,
    Approximate = 1,
    ENiagaraDefaultRendererMotionVectorSetting_MAX = 2,
};

enum class ENiagaraDefaultRendererPixelCoverageMode {
    Enabled = 0,
    Disabled = 1,
    ENiagaraDefaultRendererPixelCoverageMode_MAX = 2,
};

enum class ENiagaraDefaultSortPrecision {
    Low = 0,
    High = 1,
    ENiagaraDefaultSortPrecision_MAX = 2,
};

enum class ENiagaraDeviceProfileRedirectMode {
    CVar = 0,
    DeviceProfile = 1,
    ENiagaraDeviceProfileRedirectMode_MAX = 2,
};

enum class ENiagaraDistributionMode {
    Binding = 0,
    Expression = 1,
    UniformConstant = 2,
    NonUniformConstant = 3,
    UniformRange = 4,
    NonUniformRange = 5,
    UniformCurve = 6,
    NonUniformCurve = 7,
    ColorGradient = 8,
    ENiagaraDistributionMode_MAX = 9,
};

enum class ENiagaraEmitterCalculateBoundMode {
    Dynamic = 0,
    Fixed = 1,
    Programmable = 2,
    ENiagaraEmitterCalculateBoundMode_MAX = 3,
};

enum class ENiagaraEmitterDefaultSummaryState {
    Default = 0,
    Summary = 1,
    ENiagaraEmitterDefaultSummaryState_MAX = 2,
};

enum class ENiagaraEmitterInactiveResponse {
    Complete = 0,
    Kill = 1,
    ENiagaraEmitterInactiveResponse_MAX = 2,
};

enum class ENiagaraEmitterMode {
    Standard = 0,
    Stateless = 1,
    ENiagaraEmitterMode_MAX = 2,
};

enum class ENiagaraExecutionState {
    Active = 0,
    Inactive = 1,
    InactiveClear = 2,
    Complete = 3,
    Disabled = 4,
    Num = 5,
    ENiagaraExecutionState_MAX = 6,
};

enum class ENiagaraExecutionStateManagement {
    Awaken = 0,
    SleepAndLetParticlesFinish = 1,
    SleepAndClearParticles = 2,
    KillImmediately = 3,
    KillAfterParticlesFinish = 4,
    Num = 5,
    ENiagaraExecutionStateManagement_MAX = 6,
};

enum class ENiagaraExecutionStateSource {
    Scalability = 0,
    Internal = 1,
    Owner = 2,
    InternalCompletion = 3,
    ENiagaraExecutionStateSource_MAX = 4,
};

enum class ENiagaraFunctionDebugState {
    NoDebug = 0,
    Basic = 1,
    ENiagaraFunctionDebugState_MAX = 2,
};

enum class ENiagaraGpuBufferFormat {
    Float = 0,
    HalfFloat = 1,
    UnsignedNormalizedByte = 2,
    Max = 3,
};

enum class ENiagaraGpuComputeTickStage {
    PreInitViews = 0,
    PostInitViews = 1,
    PostOpaqueRender = 2,
    Max = 3,
    First = 0,
    Last = 2,
};

enum class ENiagaraGpuSyncMode {
    None = 0,
    SyncCpuToGpu = 1,
    SyncGpuToCpu = 2,
    SyncBoth = 3,
    ENiagaraGpuSyncMode_MAX = 4,
};

enum class ENiagaraInlineDynamicInputFormatTokenUsage {
    Input = 0,
    Decorator = 1,
    LineBreak = 2,
    ENiagaraInlineDynamicInputFormatTokenUsage_MAX = 3,
};

enum class ENiagaraInputNodeUsage {
    Undefined = 0,
    Parameter = 1,
    Attribute = 2,
    SystemConstant = 3,
    TranslatorConstant = 4,
    RapidIterationParameter = 5,
    ENiagaraInputNodeUsage_MAX = 6,
};

enum class ENiagaraInputWidgetType {
    Default = 0,
    Slider = 1,
    Volume = 2,
    NumericDropdown = 3,
    EnumStyle = 4,
    SegmentedButtons = 5,
    ENiagaraInputWidgetType_MAX = 6,
};

enum class ENiagaraInterpolatedSpawnMode {
    NoInterpolation = 0,
    RunUpdateScript = 1,
    Interpolation = 2,
    ENiagaraInterpolatedSpawnMode_MAX = 3,
};

enum class ENiagaraLegacyTrailWidthMode {
    FromCentre = 0,
    FromFirst = 1,
    FromSecond = 2,
    ENiagaraLegacyTrailWidthMode_MAX = 3,
};

enum class ENiagaraLoopBehavior {
    Infinite = 0,
    Multiple = 1,
    Once = 2,
    ENiagaraLoopBehavior_MAX = 3,
};

enum class ENiagaraLoopDurationMode {
    Fixed = 0,
    Infinite = 1,
    ENiagaraLoopDurationMode_MAX = 2,
};

enum class ENiagaraLwcTileUpdateMode {
    ResetSimulation = 0,
    Rebase = 1,
    RebaseOrResetSimulation = 2,
    ENiagaraLwcTileUpdateMode_MAX = 3,
};

enum class ENiagaraMeshFacingMode {
    Default = 0,
    Velocity = 1,
    CameraPosition = 2,
    CameraPlane = 3,
    ENiagaraMeshFacingMode_MAX = 4,
};

enum class ENiagaraMeshLODMode {
    LODLevel = 0,
    LODBias = 1,
    ByComponentBounds = 2,
    ComponentOrigin = 3,
    PerParticle = 4,
    ENiagaraMeshLODMode_MAX = 5,
};

enum class ENiagaraMeshLockedAxisSpace {
    Simulation = 0,
    World = 1,
    Local = 2,
    ENiagaraMeshLockedAxisSpace_MAX = 3,
};

enum class ENiagaraMeshPivotOffsetSpace {
    Mesh = 0,
    Simulation = 1,
    World = 2,
    Local = 3,
    ENiagaraMeshPivotOffsetSpace_MAX = 4,
};

enum class ENiagaraMipMapGeneration {
    Disabled = 0,
    PostStage = 1,
    PostSimulate = 2,
    ENiagaraMipMapGeneration_MAX = 3,
};

enum class ENiagaraModuleDependencyScriptConstraint {
    SameScript = 0,
    AllScripts = 1,
    ENiagaraModuleDependencyScriptConstraint_MAX = 2,
};

enum class ENiagaraModuleDependencyType {
    PreDependency = 0,
    PostDependency = 1,
    ENiagaraModuleDependencyType_MAX = 2,
};

enum class ENiagaraModuleDependencyUsage {
    None = 0,
    Spawn = 1,
    Update = 2,
    Event = 3,
    SimulationStage = 4,
    ENiagaraModuleDependencyUsage_MAX = 5,
};

enum class ENiagaraNumericOutputTypeSelectionMode {
    None = 0,
    Largest = 1,
    Smallest = 2,
    Scalar = 3,
    Custom = 4,
    ENiagaraNumericOutputTypeSelectionMode_MAX = 5,
};

enum class ENiagaraOcclusionQueryMode {
    Default = 0,
    AlwaysEnabled = 1,
    AlwaysDisabled = 2,
    ENiagaraOcclusionQueryMode_MAX = 3,
};

enum class ENiagaraOrientationAxis {
    XAxis = 0,
    YAxis = 1,
    ZAxis = 2,
    ENiagaraOrientationAxis_MAX = 3,
};

enum class ENiagaraPlatformSelectionState {
    Default = 0,
    Enabled = 1,
    Disabled = 2,
    ENiagaraPlatformSelectionState_MAX = 3,
};

enum class ENiagaraPlatformSetState {
    Disabled = 0,
    Enabled = 1,
    Active = 2,
    Unknown = 3,
    ENiagaraPlatformSetState_MAX = 4,
};

enum class ENiagaraPreviewGridResetMode {
    Never = 0,
    Individual = 1,
    All = 2,
    ENiagaraPreviewGridResetMode_MAX = 3,
};

enum class ENiagaraPythonUpdateScriptReference {
    None = 0,
    ScriptAsset = 1,
    DirectTextEntry = 2,
    ENiagaraPythonUpdateScriptReference_MAX = 3,
};

enum class ENiagaraRendererGpuTranslucentLatency {
    ProjectDefault = 0,
    Immediate = 1,
    Latent = 2,
    ENiagaraRendererGpuTranslucentLatency_MAX = 3,
};

enum class ENiagaraRendererMotionVectorSetting {
    AutoDetect = 0,
    Precise = 1,
    Approximate = 2,
    Disable = 3,
    ENiagaraRendererMotionVectorSetting_MAX = 4,
};

enum class ENiagaraRendererPixelCoverageMode {
    Automatic = 0,
    Disabled = 1,
    Enabled = 2,
    Enabled_RGBA = 3,
    Enabled_RGB = 4,
    Enabled_A = 5,
    ENiagaraRendererPixelCoverageMode_MAX = 6,
};

enum class ENiagaraRendererSortPrecision {
    Default = 0,
    Low = 1,
    High = 2,
    ENiagaraRendererSortPrecision_MAX = 3,
};

enum class ENiagaraRendererSourceDataMode {
    Particles = 0,
    Emitter = 1,
    ENiagaraRendererSourceDataMode_MAX = 2,
};

enum class ENiagaraRibbonAgeOffsetMode {
    Scale = 0,
    Clip = 1,
    ENiagaraRibbonAgeOffsetMode_MAX = 2,
};

enum class ENiagaraRibbonDrawDirection {
    FrontToBack = 0,
    BackToFront = 1,
    ENiagaraRibbonDrawDirection_MAX = 2,
};

enum class ENiagaraRibbonFacingMode {
    Screen = 0,
    Custom = 1,
    CustomSideVector = 2,
    ENiagaraRibbonFacingMode_MAX = 3,
};

enum class ENiagaraRibbonShapeMode {
    Plane = 0,
    MultiPlane = 1,
    Tube = 2,
    Custom = 3,
    ENiagaraRibbonShapeMode_MAX = 4,
};

enum class ENiagaraRibbonTessellationMode {
    Automatic = 0,
    Custom = 1,
    Disabled = 2,
    ENiagaraRibbonTessellationMode_MAX = 3,
};

enum class ENiagaraRibbonUVDistributionMode {
    ScaledUniformly = 0,
    ScaledUsingRibbonSegmentLength = 1,
    TiledOverRibbonLength = 2,
    TiledFromStartOverRibbonLength = 3,
    ENiagaraRibbonUVDistributionMode_MAX = 4,
};

enum class ENiagaraRibbonUVEdgeMode {
    SmoothTransition = 0,
    Locked = 1,
    ENiagaraRibbonUVEdgeMode_MAX = 2,
};

enum class ENiagaraScalabilityUpdateFrequency {
    SpawnOnly = 0,
    Low = 1,
    Medium = 2,
    High = 3,
    Continuous = 4,
    ENiagaraScalabilityUpdateFrequency_MAX = 5,
};

enum class ENiagaraScriptCompileStatus {
    NCS_Unknown = 0,
    NCS_Dirty = 1,
    NCS_Error = 2,
    NCS_UpToDate = 3,
    NCS_BeingCreated = 4,
    NCS_UpToDateWithWarnings = 5,
    NCS_ComputeUpToDateWithWarnings = 6,
    NCS_MAX = 7,
};

enum class ENiagaraScriptContextStaticSwitch {
    System = 0,
    Emitter = 1,
    Particle = 2,
    ENiagaraScriptContextStaticSwitch_MAX = 3,
};

enum class ENiagaraScriptGroup {
    Particle = 0,
    Emitter = 1,
    System = 2,
    Max = 3,
};

enum class ENiagaraScriptLibraryVisibility {
    Invalid = 0,
    Unexposed = 1,
    Library = 2,
    Hidden = 3,
    ENiagaraScriptLibraryVisibility_MAX = 4,
};

enum class ENiagaraScriptTemplateSpecification {
    None = 0,
    Template = 1,
    Behavior = 2,
    ENiagaraScriptTemplateSpecification_MAX = 3,
};

enum class ENiagaraScriptUsage {
    Function = 0,
    Module = 1,
    DynamicInput = 2,
    ParticleSpawnScript = 3,
    ParticleSpawnScriptInterpolated = 4,
    ParticleUpdateScript = 5,
    ParticleEventScript = 6,
    ParticleSimulationStageScript = 7,
    ParticleGPUComputeScript = 8,
    EmitterSpawnScript = 9,
    EmitterUpdateScript = 10,
    SystemSpawnScript = 11,
    SystemUpdateScript = 12,
    ENiagaraScriptUsage_MAX = 13,
};

enum class ENiagaraSimCacheAttributeCaptureMode {
    All = 0,
    RenderingOnly = 1,
    ExplicitAttributes = 2,
    ENiagaraSimCacheAttributeCaptureMode_MAX = 3,
};

enum class ENiagaraSimTarget {
    CPUSim = 0,
    GPUComputeSim = 1,
    ENiagaraSimTarget_MAX = 2,
};

enum class ENiagaraSortMode {
    None = 0,
    ViewDepth = 1,
    ViewDistance = 2,
    CustomAscending = 3,
    CustomDecending = 4,
    ENiagaraSortMode_MAX = 5,
};

enum class ENiagaraSpriteAlignment {
    Unaligned = 0,
    VelocityAligned = 1,
    CustomAlignment = 2,
    Automatic = 3,
    ENiagaraSpriteAlignment_MAX = 4,
};

enum class ENiagaraSpriteFacingMode {
    FaceCamera = 0,
    FaceCameraPlane = 1,
    CustomFacingVector = 2,
    FaceCameraPosition = 3,
    FaceCameraDistanceBlend = 4,
    Automatic = 5,
    ENiagaraSpriteFacingMode_MAX = 6,
};

enum class ENiagaraStatDisplayMode {
    Percent = 0,
    Absolute = 1,
    ENiagaraStatDisplayMode_MAX = 2,
};

enum class ENiagaraStatEvaluationType {
    Average = 0,
    Maximum = 1,
    ENiagaraStatEvaluationType_MAX = 2,
};

enum class ENiagaraStatelessFeatureMask {
    ExecuteGPU = 1,
    ExecuteCPU = 2,
    None = 0,
    ExecuteAll = 3,
    All = 3,
    ENiagaraStatelessFeatureMask_MAX = 4,
};

enum class ENiagaraStatelessSpawnInfoType {
    Burst = 0,
    Rate = 1,
    ENiagaraStatelessSpawnInfoType_MAX = 2,
};

enum class ENiagaraStripScriptByteCodeOption {
    Default = 0,
    Strip_Original = 1,
    Strip_Experimental = 2,
    ENiagaraStripScriptByteCodeOption_MAX = 3,
};

enum class ENiagaraStructConversionType {
    CopyOnly = 0,
    DoubleToFloat = 1,
    Vector2 = 2,
    Vector3 = 3,
    Vector4 = 4,
    Quat = 5,
    ENiagaraStructConversionType_MAX = 6,
};

enum class ENiagaraSystemInactiveResponse {
    Complete = 0,
    Kill = 1,
    ENiagaraSystemInactiveResponse_MAX = 2,
};

enum class ENiagaraSystemInstanceState {
    None = 0,
    PendingSpawn = 1,
    PendingSpawnPaused = 2,
    Spawning = 3,
    Running = 4,
    Paused = 5,
    Num = 6,
    ENiagaraSystemInstanceState_MAX = 7,
};

enum class ENiagaraSystemSpawnSectionEndBehavior {
    SetSystemInactive = 0,
    Deactivate = 1,
    None = 2,
    ENiagaraSystemSpawnSectionEndBehavior_MAX = 3,
};

enum class ENiagaraSystemSpawnSectionEvaluateBehavior {
    ActivateIfInactive = 0,
    None = 1,
    ENiagaraSystemSpawnSectionEvaluateBehavior_MAX = 2,
};

enum class ENiagaraSystemSpawnSectionStartBehavior {
    Activate = 0,
    ENiagaraSystemSpawnSectionStartBehavior_MAX = 1,
};

enum class ENiagaraTickBehavior {
    UsePrereqs = 0,
    UseComponentTickGroup = 1,
    ForceTickFirst = 2,
    ForceTickLast = 3,
    ENiagaraTickBehavior_MAX = 4,
};

enum class ENiagaraValidationSeverity {
    Info = 0,
    Warning = 1,
    Error = 2,
    ENiagaraValidationSeverity_MAX = 3,
};

enum class ENiagaraVariantMode {
    None = 0,
    Object = 1,
    DataInterface = 2,
    Bytes = 3,
    ENiagaraVariantMode_MAX = 4,
};

enum class ENiagartaDataChannelReadResult {
    Success = 0,
    Failure = 1,
    ENiagartaDataChannelReadResult_MAX = 2,
};

enum class ENiagraDataChannel_IslandMode {
    AlignedStatic = 0,
    Dynamic = 1,
    ENiagraDataChannel_MAX = 2,
};

enum class EParticleAllocationMode {
    AutomaticEstimate = 0,
    ManualEstimate = 1,
    FixedCount = 2,
    EParticleAllocationMode_MAX = 3,
};

enum class EScriptExecutionMode {
    EveryParticle = 0,
    SpawnedParticles = 1,
    SingleParticle = 2,
    EScriptExecutionMode_MAX = 3,
};

enum class ESetResolutionMethod {
    Independent = 0,
    MaxAxis = 1,
    CellSize = 2,
    ESetResolutionMethod_MAX = 3,
};

enum class EUnusedAttributeBehaviour {
    Copy = 0,
    Zero = 1,
    None = 2,
    MarkInvalid = 3,
    PassThrough = 4,
    EUnusedAttributeBehaviour_MAX = 5,
};

enum class EVolumeCacheType {
    OpenVDB = 0,
    EVolumeCacheType_MAX = 1,
};

// Size: 0x70
struct FEmitterCompiledScriptPair {
};

// Size: 0x10
struct FMeshTriCoordinate {
    /* 0x0000 */ int32_t Tri;
    /* 0x0004 */ FVector3f BaryCoord;
};

// Size: 0x148
struct FMovieSceneNiagaraBoolParameterSectionTemplate : public FMovieSceneNiagaraParameterSectionTemplate {
    /* 0x0040 */ FMovieSceneBoolChannel BoolChannel;
};

// Size: 0x148
class UMovieSceneNiagaraBoolParameterTrack : public UMovieSceneNiagaraParameterTrack {
};

// Size: 0x480
struct FMovieSceneNiagaraColorParameterSectionTemplate : public FMovieSceneNiagaraParameterSectionTemplate {
    /* 0x0040 */ FMovieSceneFloatChannel RedChannel;
    /* 0x0150 */ FMovieSceneFloatChannel GreenChannel;
    /* 0x0260 */ FMovieSceneFloatChannel BlueChannel;
    /* 0x0370 */ FMovieSceneFloatChannel AlphaChannel;
};

// Size: 0x148
class UMovieSceneNiagaraColorParameterTrack : public UMovieSceneNiagaraParameterTrack {
};

// Size: 0x150
struct FMovieSceneNiagaraFloatParameterSectionTemplate : public FMovieSceneNiagaraParameterSectionTemplate {
    /* 0x0040 */ FMovieSceneFloatChannel FloatChannel;
};

// Size: 0x148
class UMovieSceneNiagaraFloatParameterTrack : public UMovieSceneNiagaraParameterTrack {
};

// Size: 0x148
struct FMovieSceneNiagaraIntegerParameterSectionTemplate : public FMovieSceneNiagaraParameterSectionTemplate {
    /* 0x0040 */ FMovieSceneIntegerChannel IntegerChannel;
};

// Size: 0x148
class UMovieSceneNiagaraIntegerParameterTrack : public UMovieSceneNiagaraParameterTrack {
};

// Size: 0x40
struct FMovieSceneNiagaraParameterSectionTemplate : public FMovieSceneEvalTemplate {
    /* 0x0020 */ FNiagaraVariable Parameter;
};

// Size: 0x140
class UMovieSceneNiagaraParameterTrack : public UMovieSceneNiagaraTrack {
    /* 0x0120 */ FNiagaraVariable Parameter;
};

// Size: 0x118
class UMovieSceneNiagaraSystemSpawnSection : public UMovieSceneSection {
    /* 0x0108 */ ENiagaraSystemSpawnSectionStartBehavior SectionStartBehavior;
    /* 0x010c */ ENiagaraSystemSpawnSectionEvaluateBehavior SectionEvaluateBehavior;
    /* 0x0110 */ ENiagaraSystemSpawnSectionEndBehavior SectionEndBehavior;
    /* 0x0114 */ ENiagaraAgeUpdateMode AgeUpdateMode;
    /* 0x0115 */ bool bAllowScalability;
};

// Size: 0x128
class UMovieSceneNiagaraSystemTrack : public UMovieSceneNiagaraTrack {
};

// Size: 0x28
struct FMovieSceneNiagaraSystemTrackImplementation : public FMovieSceneTrackImplementation {
    /* 0x0010 */ FFrameNumber SpawnSectionStartFrame;
    /* 0x0014 */ FFrameNumber SpawnSectionEndFrame;
    /* 0x0018 */ ENiagaraSystemSpawnSectionStartBehavior SpawnSectionStartBehavior;
    /* 0x001c */ ENiagaraSystemSpawnSectionEvaluateBehavior SpawnSectionEvaluateBehavior;
    /* 0x0020 */ ENiagaraSystemSpawnSectionEndBehavior SpawnSectionEndBehavior;
    /* 0x0024 */ ENiagaraAgeUpdateMode AgeUpdateMode;
    /* 0x0025 */ bool bAllowScalability;
};

// Size: 0x20
struct FMovieSceneNiagaraSystemTrackTemplate : public FMovieSceneEvalTemplate {
};

// Size: 0x120
class UMovieSceneNiagaraTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x488
struct FMovieSceneNiagaraVectorParameterSectionTemplate : public FMovieSceneNiagaraParameterSectionTemplate {
    /* 0x0040 */ FMovieSceneFloatChannel VectorChannels[4];
    /* 0x0480 */ int32_t ChannelsUsed;
};

// Size: 0x150
class UMovieSceneNiagaraVectorParameterTrack : public UMovieSceneNiagaraParameterTrack {
    /* 0x0148 */ int32_t ChannelsUsed;
};

// Size: 0x10
struct FNCPool {
    /* 0x0000 */ TArray<FNCPoolElement> FreeElements;
};

// Size: 0x10
struct FNCPoolElement {
    /* 0x0000 */ UNiagaraComponent* Component;
};

// Size: 0x60
struct FNDCIsland {
    /* 0x0000 */ UNiagaraDataChannelHandler_Islands* Owner;
    /* 0x0008 */ FBoxSphereBounds Bounds;
    /* 0x0040 */ TArray<UNiagaraComponent*> SpawnedComponents;
};

// Size: 0x4
struct FNDCIslandDebugDrawSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0000 */ bool bShowIslandBounds;
};

// Size: 0x60
class UNDIArraySimCacheData : public UObject {
    /* 0x0028 */ TArray<FNDIArraySimCacheDataFrame> CpuFrameData;
    /* 0x0038 */ TArray<FNDIArraySimCacheDataFrame> GpuFrameData;
    /* 0x0048 */ TArray<uint8_t> BufferData;
};

// Size: 0x8
struct FNDIArraySimCacheDataFrame {
    /* 0x0000 */ int32_t NumElements;
    /* 0x0004 */ int32_t DataOffset;
};

// Size: 0x70
struct FNDIDataChannelCompiledData {
    /* 0x0000 */ TArray<FNDIDataChannelFunctionInfo> FunctionInfo;
    /* 0x0010 */ TMap<FNiagaraCompileHash, FNDIDataChannel_GPUScriptParameterAccessInfo> GPUScriptParameterInfos;
    /* 0x0060 */ uint32_t TotalParams;
    /* 0x0064 */ bool bUsedByCPU;
    /* 0x0065 */ bool bUsedByGPU;
    /* 0x0066 */ bool bNeedsSpawnDataTable;
    /* 0x0067 */ bool bSpawnsParticles;
    /* 0x0068 */ bool bCallsWrite;
};

// Size: 0x28
struct FNDIDataChannelFunctionInfo {
    /* 0x0000 */ FName FunctionName;
    /* 0x0008 */ TArray<FNiagaraVariableBase> Inputs;
    /* 0x0018 */ TArray<FNiagaraVariableBase> Outputs;
};

// Size: 0xb8
struct FNDIDataChannelWriteCompiledData : public FNDIDataChannelCompiledData {
    /* 0x0070 */ FNiagaraDataSetCompiledData DataLayout;
};

// Size: 0x68
class UNDIDataChannelWriteSimCacheData : public UObject {
    /* 0x0028 */ TArray<FNDIDataChannelWriteSimCacheFrame> FrameData;
    /* 0x0038 */ FSoftObjectPath DataChannelReference;
    /* 0x0058 */ UNiagaraDataInterfaceDataChannelWrite* DataInterface;
};

// Size: 0x20
struct FNDIDataChannelWriteSimCacheFrame {
    /* 0x0000 */ int32_t NumElements;
    /* 0x0008 */ TArray<FNDIDataChannelWriteSimCacheFrameBuffer> VariableData;
    /* 0x0018 */ bool bVisibleToGame;
    /* 0x0019 */ bool bVisibleToCPUSims;
    /* 0x001a */ bool bVisibleToGPUSims;
};

// Size: 0x20
struct FNDIDataChannelWriteSimCacheFrameBuffer {
    /* 0x0000 */ TArray<uint8_t> Data;
    /* 0x0010 */ int32_t Size;
    /* 0x0014 */ FNiagaraVariableBase SourceVar;
};

// Size: 0x10
struct FNDIDataChannel_GPUScriptParameterAccessInfo {
    /* 0x0000 */ TArray<FNiagaraVariableBase> SortedParameters;
};

// Size: 0x38
class UNDILandscapeSimCacheData : public UObject {
    /* 0x0028 */ TArray<UTexture2D*> HeightFieldTextures;
};

// Size: 0x48
class UNDIMemoryBufferSimCacheData : public UObject {
    /* 0x0028 */ TArray<FNDIMemoryBufferSimCacheDataFrame> FrameData;
    /* 0x0038 */ TArray<uint32_t> BufferData;
};

// Size: 0x10
struct FNDIMemoryBufferSimCacheDataFrame {
    /* 0x0000 */ int32_t CpuBufferSize;
    /* 0x0004 */ int32_t CpuDataOffset;
    /* 0x0008 */ int32_t GpuBufferSize;
    /* 0x000c */ int32_t GpuDataOffset;
};

// Size: 0x50
class UNDIRenderTargetSimCacheData : public UObject {
    /* 0x0028 */ FName CompressionType;
    /* 0x0030 */ TArray<FNDIRenderTargetSimCacheFrame> Frames;
};

// Size: 0x40
struct FNDIRenderTargetSimCacheFrame {
    /* 0x0000 */ FIntVector Size;
    /* 0x000c */ uint8_t Format;
    /* 0x0010 */ int32_t UncompressedSize;
    /* 0x0014 */ int32_t CompressedSize;
};

// Size: 0x38
class UNDISimpleCounterSimCacheData : public UObject {
    /* 0x0028 */ TArray<int32_t> Values;
};

// Size: 0x10
struct FNDIStaticMeshSectionFilter {
    /* 0x0000 */ TArray<int32_t> AllowedMaterialSlots;
};

// Size: 0x2b8
class ANiagaraActor : public AActor {
    /* 0x02a8 */ UNiagaraComponent* NiagaraComponent;
    /* 0x02b0 */ bool bDestroyOnSystemFinish;

    bool GetDestroyOnSystemFinish() const;
    void OnNiagaraSystemFinished(UNiagaraComponent* FinishedComponent);
    void SetDestroyOnSystemFinish(bool bShouldDestroyOnSystemFinish);
};

// Size: 0x50
struct FNiagaraAssetTagDefinition {
    /* 0x0000 */ FText AssetTag;
    /* 0x0010 */ int32_t AssetFlags;
    /* 0x0018 */ FText Description;
    /* 0x0028 */ ENiagaraAssetTagDefinitionImportance DisplayType;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ FGuid TagGuid;
};

// Size: 0x10
struct FNiagaraAssetTagDefinitionReference {
    /* 0x0000 */ FGuid AssetTagDefinitionGuid;
};

// Size: 0x60
class UNiagaraAssetTagDefinitions : public UObject {
    /* 0x0028 */ FText DisplayName;
    /* 0x0038 */ FText Description;
    /* 0x0048 */ TArray<FNiagaraAssetTagDefinition> TagDefinitions;
    /* 0x0058 */ bool bDisplayTagsAsFlatList;
    /* 0x005c */ int32_t SortOrder;
};

// Size: 0x1c
struct FNiagaraAssetVersion {
    /* 0x0000 */ int32_t MajorVersion;
    /* 0x0004 */ int32_t MinorVersion;
    /* 0x0008 */ FGuid VersionGuid;
    /* 0x0018 */ bool bIsVisibleInVersionSelector;
};

// Size: 0x50
struct FNiagaraBakerCameraSettings {
    /* 0x0000 */ ENiagaraBakerViewMode ViewMode;
    /* 0x0008 */ FVector ViewportLocation;
    /* 0x0020 */ FRotator ViewportRotation;
    /* 0x0038 */ float OrbitDistance;
    /* 0x003c */ float FOV;
    /* 0x0040 */ float OrthoWidth;
    /* 0x0044 */ bool bUseAspectRatio;
    /* 0x0048 */ float AspectRatio;
};

// Size: 0x38
class UNiagaraBakerOutput : public UObject {
    /* 0x0028 */ FString OutputName;
};

// Size: 0xa0
class UNiagaraBakerOutputSimCache : public UNiagaraBakerOutput {
    /* 0x0038 */ FString SimCacheAssetPathFormat;
    /* 0x0048 */ FNiagaraSimCacheCreateParameters CreateParameters;
};

// Size: 0x90
class UNiagaraBakerOutputSparseVolumeTexture : public UNiagaraBakerOutput {
    /* 0x0038 */ FNiagaraBakerTextureSource SourceBinding;
    /* 0x0050 */ FNiagaraParameterBinding VolumeWorldSpaceSizeBinding;
    /* 0x0060 */ FString SparseVolumeTextureAssetPathFormat;
    /* 0x0070 */ bool bEnableLoopedOutput;
    /* 0x0078 */ FString LoopedSparseVolumeTextureAssetPathFormat;
    /* 0x0088 */ float StartTime;
    /* 0x008c */ float BlendDuration;
};

// Size: 0x60
class UNiagaraBakerOutputStaticMesh : public UNiagaraBakerOutput {
    /* 0x0038 */ FString FramesAssetPathFormat;
    /* 0x0048 */ FNiagaraRendererReadbackParameters ExportParameters;
};

// Size: 0xa0
class UNiagaraBakerOutputTexture2D : public UNiagaraBakerOutput {
    /* 0x0038 */ FNiagaraBakerTextureSource SourceBinding;
    /* 0x0050 */ bool bGenerateAtlas;
    /* 0x0050 */ bool bGenerateFrames;
    /* 0x0050 */ bool bExportFrames;
    /* 0x0050 */ bool bSetTextureAddressX;
    /* 0x0050 */ bool bSetTextureAddressY;
    /* 0x0054 */ FIntPoint FrameSize;
    /* 0x005c */ FIntPoint AtlasTextureSize;
    /* 0x006c */ uint8_t TextureAddressX;
    /* 0x006d */ uint8_t TextureAddressY;
    /* 0x0070 */ FString AtlasAssetPathFormat;
    /* 0x0080 */ FString FramesAssetPathFormat;
    /* 0x0090 */ FString FramesExportPathFormat;
};

// Size: 0x88
class UNiagaraBakerOutputVolumeTexture : public UNiagaraBakerOutput {
    /* 0x0038 */ FNiagaraBakerTextureSource SourceBinding;
    /* 0x0050 */ bool bGenerateAtlas;
    /* 0x0050 */ bool bGenerateFrames;
    /* 0x0050 */ bool bExportFrames;
    /* 0x0058 */ FString AtlasAssetPathFormat;
    /* 0x0068 */ FString FramesAssetPathFormat;
    /* 0x0078 */ FString FramesExportPathFormat;
};

// Size: 0x1f0
class UNiagaraBakerSettings : public UObject {
    /* 0x0028 */ float StartSeconds;
    /* 0x002c */ float DurationSeconds;
    /* 0x0030 */ int32_t FramesPerSecond;
    /* 0x0034 */ bool bLockToSimulationFrameRate;
    /* 0x0034 */ bool bPreviewLooping;
    /* 0x0038 */ FIntPoint FramesPerDimension;
    /* 0x0040 */ TArray<UNiagaraBakerOutput*> Outputs;
    /* 0x0050 */ TArray<FNiagaraBakerCameraSettings> CameraSettings;
    /* 0x0060 */ int32_t CurrentCameraIndex;
    /* 0x0064 */ FName BakeQualityLevel;
    /* 0x006c */ bool bRenderComponentOnly;
    /* 0x006c */ bool bPreviewLoopedOutput;
    /* 0x0070 */ TArray<FNiagaraBakerTextureSettings> OutputTextures;
    /* 0x0080 */ ENiagaraBakerViewMode CameraViewportMode;
    /* 0x0088 */ FVector CameraViewportLocation[7];
    /* 0x0130 */ FRotator CameraViewportRotation[7];
    /* 0x01d8 */ float CameraOrbitDistance;
    /* 0x01dc */ float cameraFov;
    /* 0x01e0 */ float CameraOrthoWidth;
    /* 0x01e4 */ bool bUseCameraAspectRatio;
    /* 0x01e8 */ float CameraAspectRatio;
};

// Size: 0x40
struct FNiagaraBakerTextureSettings {
    /* 0x0000 */ FName OutputName;
    /* 0x0008 */ FNiagaraBakerTextureSource SourceBinding;
    /* 0x0020 */ bool bUseFrameSize;
    /* 0x0024 */ FIntPoint FrameSize;
    /* 0x002c */ FIntPoint TextureSize;
    /* 0x0038 */ UTexture2D* GeneratedTexture;
};

// Size: 0x18
struct FNiagaraBakerTextureSource {
    /* 0x0000 */ FString DisplayString;
    /* 0x0010 */ FName SourceName;
};

// Size: 0x68
class UNiagaraBaselineController : public UObject {
    /* 0x0028 */ float TestDuration;
    /* 0x0030 */ UNiagaraEffectType* EffectType;
    /* 0x0038 */ ANiagaraPerfBaselineActor* Owner;
    /* 0x0040 */ TSoftObjectPtr<UNiagaraSystem> System;

    UNiagaraSystem* GetSystem();
    void OnBeginTest();
    void OnEndTest(FNiagaraPerfBaselineStats Stats);
    void OnOwnerTick(float deltaTime);
    bool OnTickTest();
};

// Size: 0x80
class UNiagaraBaselineController_Basic : public UNiagaraBaselineController {
    /* 0x0068 */ int32_t NumInstances;
    /* 0x0070 */ TArray<UNiagaraComponent*> SpawnedComponents;
};

// Size: 0x4
struct FNiagaraBool {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x28
struct FNiagaraBoolParameterMetaData {
    /* 0x0000 */ ENiagaraBoolDisplayMode DisplayMode;
    /* 0x0004 */ FName OverrideNameTrue;
    /* 0x000c */ FName OverrideNameFalse;
    /* 0x0018 */ UTexture2D* IconOverrideTrue;
    /* 0x0020 */ UTexture2D* IconOverrideFalse;
};

// Size: 0x14
struct FNiagaraBoundParameter {
    /* 0x0000 */ FNiagaraVariableBase Parameter;
    /* 0x000c */ int32_t SrcOffset;
    /* 0x0010 */ int32_t DestOffset;
};

// Size: 0x50
struct FNiagaraCollisionEventPayload {
    /* 0x0000 */ FVector CollisionPos;
    /* 0x0018 */ FVector collisionNormal;
    /* 0x0030 */ FVector CollisionVelocity;
    /* 0x0048 */ int32_t ParticleIndex;
    /* 0x004c */ int32_t PhysicalMaterialIndex;
};

// Size: 0x50
struct FNiagaraCompileDependency {
    /* 0x0000 */ FString LinkerErrorMessage;
    /* 0x0010 */ FGuid NodeGuid;
    /* 0x0020 */ FGuid PinGuid;
    /* 0x0030 */ TArray<FGuid> StackGuids;
    /* 0x0040 */ FNiagaraVariableBase DependentVariable;
    /* 0x004c */ bool bDependentVariableFromCustomIterationNamespace;
};

// Size: 0x30
struct FNiagaraCompileHashVisitorDebugInfo {
    /* 0x0000 */ FString Object;
    /* 0x0010 */ TArray<FString> PropertyKeys;
    /* 0x0020 */ TArray<FString> PropertyValues;
};

// Size: 0x30
struct FNiagaraCompilerTag {
    /* 0x0000 */ FNiagaraVariable Variable;
    /* 0x0020 */ FString StringValue;
};

// Size: 0x7b0
class UNiagaraComponent : public UFXSystemComponent {
    /* 0x0520 */ UNiagaraSystem* Asset;
    /* 0x0528 */ ENiagaraTickBehavior TickBehavior;
    /* 0x052c */ int32_t RandomSeedOffset;
    /* 0x0530 */ FNiagaraUserRedirectionParameterStore OverrideParameters;
    /* 0x0608 */ bool bEnableGpuComputeDebug;
    /* 0x0608 */ bool bOverrideWarmupSettings;
    /* 0x060c */ int32_t WarmupTickCount;
    /* 0x0610 */ float WarmupTickDelta;
    /* 0x0648 */ bool bAutoDestroy;
    /* 0x0648 */ bool bRenderingEnabled;
    /* 0x0648 */ bool bAutoManageAttachment;
    /* 0x0648 */ bool bAutoAttachWeldSimulatedBodies;
    /* 0x064c */ float MaxTimeBeforeForceUpdateTransform;
    /* 0x0651 */ ENiagaraOcclusionQueryMode OcclusionQueryMode;
    /* 0x0658 */ FMulticastInlineDelegate OnSystemFinished;
    /* 0x0668 */ TWeakObjectPtr<USceneComponent> AutoAttachParent;
    /* 0x0670 */ FName AutoAttachSocketName;
    /* 0x0678 */ EAttachmentRule AutoAttachLocationRule;
    /* 0x0679 */ EAttachmentRule AutoAttachRotationRule;
    /* 0x067a */ EAttachmentRule AutoAttachScaleRule;
    /* 0x0684 */ bool bAllowScalability;
    /* 0x07a0 */ UNiagaraSimCache* SimCache;
    /* 0x07a8 */ UNiagaraCullProxyComponent* CullProxy;

    void AdvanceSimulation(int32_t TickCount, float TickDeltaSeconds);
    void AdvanceSimulationByTime(float SimulateTime, float TickDeltaSeconds);
    void ClearEmitterFixedBounds(FName EmitterName);
    void ClearSimCache(bool bResetSystem);
    void ClearSystemFixedBounds();
    ENiagaraAgeUpdateMode GetAgeUpdateMode() const;
    bool GetAllowScalability() const;
    UNiagaraSystem* GetAsset() const;
    float GetCustomTimeDilation() const;
    UNiagaraDataInterface* GetDataInterface(FString Name);
    float GetDesiredAge() const;
    FBox GetEmitterFixedBounds(FName EmitterName) const;
    bool GetForceLocalPlayerEffect() const;
    bool GetForceSolo() const;
    bool GetLockDesiredAgeDeltaTimeToSeekDelta() const;
    float GetMaxSimTime() const;
    ENiagaraOcclusionQueryMode GetOcclusionQueryMode() const;
    float GetPreviewLODDistance() const;
    bool GetPreviewLODDistanceEnabled() const;
    int32_t GetRandomSeedOffset() const;
    float GetSeekDelta() const;
    UNiagaraSimCache* GetSimCache() const;
    FBox GetSystemFixedBounds() const;
    ENiagaraTickBehavior GetTickBehavior() const;
    void InitForPerformanceBaseline();
    bool IsPaused() const;
    void ReinitializeSystem();
    void ResetSystem();
    void SeekToDesiredAge(float InDesiredAge);
    void SetAgeUpdateMode(ENiagaraAgeUpdateMode InAgeUpdateMode);
    void SetAllowScalability(bool bAllow);
    void SetAsset(UNiagaraSystem* InAsset, bool bResetExistingOverrideParameters);
    void SetAutoDestroy(bool bInAutoDestroy);
    void SetCanRenderWhileSeeking(bool bInCanRenderWhileSeeking);
    void SetCustomTimeDilation(float Dilation);
    void SetDesiredAge(float InDesiredAge);
    void SetEmitterFixedBounds(FName EmitterName, FBox LocalBounds);
    void SetForceLocalPlayerEffect(bool bIsPlayerEffect);
    void SetForceSolo(bool bInForceSolo);
    void SetGpuComputeDebug(bool bEnableDebug);
    void SetLockDesiredAgeDeltaTimeToSeekDelta(bool bLock);
    void SetMaxSimTime(float InMaxTime);
    void SetNiagaraVariableActor(FString InVariableName, AActor* Actor);
    void SetNiagaraVariableBool(FString InVariableName, bool InValue);
    void SetNiagaraVariableFloat(FString InVariableName, float InValue);
    void SetNiagaraVariableInt(FString InVariableName, int32_t InValue);
    void SetNiagaraVariableLinearColor(FString InVariableName, const FLinearColor& InValue);
    void SetNiagaraVariableMatrix(FString InVariableName, const FMatrix& InValue);
    void SetNiagaraVariableObject(FString InVariableName, UObject* Object);
    void SetNiagaraVariablePosition(FString InVariableName, FVector InValue);
    void SetNiagaraVariableQuat(FString InVariableName, const FQuat& InValue);
    void SetNiagaraVariableVec2(FString InVariableName, FVector2D InValue);
    void SetNiagaraVariableVec3(FString InVariableName, FVector InValue);
    void SetNiagaraVariableVec4(FString InVariableName, const FVector4& InValue);
    void SetOcclusionQueryMode(ENiagaraOcclusionQueryMode Mode);
    void SetPaused(bool bInPaused);
    void SetPreviewLODDistance(bool bEnablePreviewLODDistance, float PreviewLODDistance, float PreviewMaxDistance);
    void SetRandomSeedOffset(int32_t NewRandomSeedOffset);
    void SetRenderingEnabled(bool bInRenderingEnabled);
    void SetSeekDelta(float InSeekDelta);
    void SetSimCache(UNiagaraSimCache* SimCache, bool bResetSystem);
    void SetSystemFixedBounds(FBox LocalBounds);
    void SetTickBehavior(ENiagaraTickBehavior NewTickBehavior);
    void SetVariableActor(FName InVariableName, AActor* Actor);
    void SetVariableBool(FName InVariableName, bool InValue);
    void SetVariableFloat(FName InVariableName, float InValue);
    void SetVariableInt(FName InVariableName, int32_t InValue);
    void SetVariableLinearColor(FName InVariableName, const FLinearColor& InValue);
    void SetVariableMaterial(FName InVariableName, UMaterialInterface* Object);
    void SetVariableMatrix(FName InVariableName, const FMatrix& InValue);
    void SetVariableObject(FName InVariableName, UObject* Object);
    void SetVariablePosition(FName InVariableName, FVector InValue);
    void SetVariableQuat(FName InVariableName, const FQuat& InValue);
    void SetVariableStaticMesh(FName InVariableName, UStaticMesh* InValue);
    void SetVariableTexture(FName InVariableName, UTexture* Texture);
    void SetVariableTextureRenderTarget(FName InVariableName, UTextureRenderTarget* TextureRenderTarget);
    void SetVariableVec2(FName InVariableName, FVector2D InValue);
    void SetVariableVec3(FName InVariableName, FVector InValue);
    void SetVariableVec4(FName InVariableName, const FVector4& InValue);
};

// Size: 0x80
class UNiagaraComponentPool : public UObject {
    /* 0x0028 */ TMap<UNiagaraSystem*, FNCPool> WorldParticleSystemPools;
};

// Size: 0xb0
struct FNiagaraComponentPropertyBinding {
    /* 0x0000 */ FNiagaraVariableAttributeBinding AttributeBinding;
    /* 0x0038 */ FName PropertyName;
    /* 0x0040 */ FNiagaraTypeDefinition PropertyType;
    /* 0x0058 */ FName MetadataSetterName;
    /* 0x0060 */ TMap<FString, FString> PropertySetterParameterDefaults;
};

// Size: 0x1b0
class UNiagaraComponentRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ UClass* ComponentType;
    /* 0x00c0 */ uint32_t ComponentCountLimit;
    /* 0x00c8 */ FNiagaraVariableAttributeBinding EnabledBinding;
    /* 0x0100 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x0138 */ bool bAssignComponentsOnParticleID;
    /* 0x0139 */ bool bCreateComponentFirstParticleFrame;
    /* 0x013a */ bool bOnlyActivateNewlyAquiredComponents;
    /* 0x013c */ int32_t RendererVisibility;
    /* 0x0140 */ USceneComponent* TemplateComponent;
    /* 0x0148 */ TArray<FNiagaraComponentPropertyBinding> PropertyBindings;
};

// Size: 0x28
class UNiagaraConvertInPlaceUtilityBase : public UObject {
};

// Size: 0x7c0
class UNiagaraCullProxyComponent : public UNiagaraComponent {
    /* 0x07b0 */ TArray<FNiagaraCulledComponentInfo> Instances;
};

// Size: 0x8
struct FNiagaraCulledComponentInfo {
};

// Size: 0x28
class UNiagaraDIRigidMeshCollisionFunctionLibrary : public UBlueprintFunctionLibrary {

    static void SetSourceActors(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<AActor*>& SourceActors);
};

// Size: 0x58
class UNiagaraDataChannel : public UObject {
    /* 0x0028 */ TArray<FNiagaraDataChannelVariable> ChannelVariables;
    /* 0x0038 */ bool bKeepPreviousFrameData;
    /* 0x0039 */ bool bEnforceTickGroupReadWriteOrder;
    /* 0x003a */ uint8_t FinalWriteTickGroup;
};

// Size: 0x30
class UNiagaraDataChannelAsset : public UObject {
    /* 0x0028 */ UNiagaraDataChannel* DataChannel;
};

// Size: 0x60
struct FNiagaraDataChannelGameDataLayout {
    /* 0x0000 */ TMap<FNiagaraVariableBase, int32_t> VariableIndices;
    /* 0x0050 */ TArray<FNiagaraLwcStructConverter> LwcConverters;
};

// Size: 0x78
class UNiagaraDataChannelHandler : public UObject {
    /* 0x0028 */ TWeakObjectPtr<UNiagaraDataChannel> DataChannel;
    /* 0x0030 */ UNiagaraDataChannelWriter* Writer;
    /* 0x0038 */ UNiagaraDataChannelReader* Reader;

    UNiagaraDataChannelReader* GetDataChannelReader();
    UNiagaraDataChannelWriter* GetDataChannelWriter();
    void SubscribeToDataChannelUpdates(FDelegate UpdateDelegate, FNiagaraDataChannelSearchParameters SearchParams, int32_t& UnsubscribeToken);
    void UnsubscribeFromDataChannelUpdates(const int32_t& UnsubscribeToken);
};

// Size: 0x88
class UNiagaraDataChannelHandler_Global : public UNiagaraDataChannelHandler {
};

// Size: 0xa8
class UNiagaraDataChannelHandler_Islands : public UNiagaraDataChannelHandler {
    /* 0x0078 */ TArray<int32_t> ActiveIslands;
    /* 0x0088 */ TArray<int32_t> FreeIslands;
    /* 0x0098 */ TArray<FNDCIsland> IslandPool;
};

// Size: 0x28
class UNiagaraDataChannelLibrary : public UBlueprintFunctionLibrary {

    static int32_t GetDataChannelElementCount(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, FNiagaraDataChannelSearchParameters SearchParams, bool bReadPreviousFrame);
    static UNiagaraDataChannelHandler* GetNiagaraDataChannel(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel);
    static UNiagaraDataChannelReader* ReadFromNiagaraDataChannel(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, FNiagaraDataChannelSearchParameters SearchParams, bool bReadPreviousFrame);
    static void ReadFromNiagaraDataChannelSingle(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, int32_t Index, FNiagaraDataChannelSearchParameters SearchParams, bool bReadPreviousFrame, ENiagartaDataChannelReadResult& ReadResult);
    static void SubscribeToNiagaraDataChannel(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, FNiagaraDataChannelSearchParameters SearchParams, const FDelegate& UpdateDelegate, int32_t& UnsubscribeToken);
    static void UnsubscribeFromNiagaraDataChannel(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, const int32_t& UnsubscribeToken);
    static UNiagaraDataChannelWriter* WriteToNiagaraDataChannel(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, FNiagaraDataChannelSearchParameters SearchParams, int32_t Count, bool bVisibleToGame, bool bVisibleToCPU, bool bVisibleToGPU, FString DebugSource);
    static void WriteToNiagaraDataChannelSingle(const UObject* WorldContextObject, const UNiagaraDataChannelAsset* Channel, FNiagaraDataChannelSearchParameters SearchParams, bool bVisibleToBlueprint, bool bVisibleToNiagaraCPU, bool bVisibleToNiagaraGPU);
};

// Size: 0x48
class UNiagaraDataChannelReader : public UObject {
    /* 0x0040 */ UNiagaraDataChannelHandler* Owner;

    bool InitAccess(FNiagaraDataChannelSearchParameters SearchParams, bool bReadPrevFrameData);
    int32_t Num() const;
    bool ReadBool(FName VarName, int32_t Index, bool& IsValid) const;
    uint8_t ReadEnum(FName VarName, int32_t Index, bool& IsValid) const;
    double ReadFloat(FName VarName, int32_t Index, bool& IsValid) const;
    FNiagaraID ReadID(FName VarName, int32_t Index, bool& IsValid) const;
    int32_t ReadInt(FName VarName, int32_t Index, bool& IsValid) const;
    FLinearColor ReadLinearColor(FName VarName, int32_t Index, bool& IsValid) const;
    FVector ReadPosition(FName VarName, int32_t Index, bool& IsValid) const;
    FQuat ReadQuat(FName VarName, int32_t Index, bool& IsValid) const;
    FNiagaraSpawnInfo ReadSpawnInfo(FName VarName, int32_t Index, bool& IsValid) const;
    FVector ReadVector(FName VarName, int32_t Index, bool& IsValid) const;
    FVector2D ReadVector2D(FName VarName, int32_t Index, bool& IsValid) const;
    FVector4 ReadVector4(FName VarName, int32_t Index, bool& IsValid) const;
};

// Size: 0x28
struct FNiagaraDataChannelSearchParameters {
    /* 0x0000 */ USceneComponent* OwningComponent;
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ bool bOverrideLocation;
};

// Size: 0x18
struct FNiagaraDataChannelUpdateContext {
    /* 0x0000 */ UNiagaraDataChannelReader* Reader;
    /* 0x0008 */ int32_t FirstNewDataIndex;
    /* 0x000c */ int32_t LastNewDataIndex;
    /* 0x0010 */ int32_t NewElementCount;
};

// Size: 0xc
struct FNiagaraDataChannelVariable : public FNiagaraVariableBase {
};

// Size: 0x48
class UNiagaraDataChannelWriter : public UObject {
    /* 0x0040 */ UNiagaraDataChannelHandler* Owner;

    bool InitWrite(FNiagaraDataChannelSearchParameters SearchParams, int32_t Count, bool bVisibleToGame, bool bVisibleToCPU, bool bVisibleToGPU, FString DebugSource);
    int32_t Num() const;
    void WriteBool(FName VarName, int32_t Index, bool InData);
    void WriteEnum(FName VarName, int32_t Index, uint8_t InData);
    void WriteFloat(FName VarName, int32_t Index, double InData);
    void WriteID(FName VarName, int32_t Index, FNiagaraID InData);
    void WriteInt(FName VarName, int32_t Index, int32_t InData);
    void WriteLinearColor(FName VarName, int32_t Index, FLinearColor InData);
    void WritePosition(FName VarName, int32_t Index, FVector InData);
    void WriteQuat(FName VarName, int32_t Index, FQuat InData);
    void WriteSpawnInfo(FName VarName, int32_t Index, FNiagaraSpawnInfo InData);
    void WriteVector(FName VarName, int32_t Index, FVector InData);
    void WriteVector2D(FName VarName, int32_t Index, FVector2D InData);
    void WriteVector4(FName VarName, int32_t Index, FVector4 InData);
};

// Size: 0x58
class UNiagaraDataChannel_Global : public UNiagaraDataChannel {
};

// Size: 0xe0
class UNiagaraDataChannel_Islands : public UNiagaraDataChannel {
    /* 0x0058 */ ENiagraDataChannel_IslandMode Mode;
    /* 0x0060 */ FVector InitialExtents;
    /* 0x0078 */ FVector MaxExtents;
    /* 0x0090 */ FVector PerElementExtents;
    /* 0x00a8 */ TArray<TSoftObjectPtr<UNiagaraSystem>> Systems;
    /* 0x00b8 */ int32_t IslandPoolSize;
    /* 0x00bc */ FNDCIslandDebugDrawSettings DebugDrawSettings;
    /* 0x00c0 */ TArray<UNiagaraSystem*> SystemsInternal;
};

// Size: 0x38
class UNiagaraDataInterface : public UNiagaraDataInterfaceBase {
};

// Size: 0x60
class UNiagaraDataInterface2DArrayTexture : public UNiagaraDataInterface {
    /* 0x0038 */ UTexture* Texture;
    /* 0x0040 */ FNiagaraUserParameterBinding TextureUserParameter;
};

// Size: 0x80
class UNiagaraDataInterfaceActorComponent : public UNiagaraDataInterface {
    /* 0x0038 */ ENDIActorComponentSourceMode SourceMode;
    /* 0x003c */ int32_t LocalPlayerIndex;
    /* 0x0040 */ TLazyObjectPtr<AActor> SourceActor;
    /* 0x0058 */ FNiagaraUserParameterBinding ActorOrComponentParameter;
    /* 0x0078 */ bool bRequireCurrentFrameData;
};

// Size: 0x50
class UNiagaraDataInterfaceArray : public UNiagaraDataInterfaceRWBase {
    /* 0x0048 */ ENiagaraGpuSyncMode GpuSyncMode;
    /* 0x004c */ int32_t MaxElements;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayBool : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<bool> BoolData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayColor : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FLinearColor> ColorData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayFloat : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<float> FloatData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayFloat2 : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FVector2f> InternalFloatData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayFloat3 : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FVector3f> InternalFloatData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayFloat4 : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FVector4f> InternalFloatData;
};

// Size: 0x28
class UNiagaraDataInterfaceArrayFunctionLibrary : public UBlueprintFunctionLibrary {

    static TArray<bool> GetNiagaraArrayBool(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static bool GetNiagaraArrayBoolValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<FLinearColor> GetNiagaraArrayColor(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static FLinearColor GetNiagaraArrayColorValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<float> GetNiagaraArrayFloat(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static float GetNiagaraArrayFloatValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<int32_t> GetNiagaraArrayInt32(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static int32_t GetNiagaraArrayInt32Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<FMatrix> GetNiagaraArrayMatrix(UNiagaraComponent* NiagaraSystem, FName OverrideName, bool bApplyLWCRebase);
    static FMatrix GetNiagaraArrayMatrixValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, bool bApplyLWCRebase);
    static TArray<FVector> GetNiagaraArrayPosition(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static FVector GetNiagaraArrayPositionValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<FQuat> GetNiagaraArrayQuat(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static FQuat GetNiagaraArrayQuatValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<int32_t> GetNiagaraArrayUInt8(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static int32_t GetNiagaraArrayUInt8Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<FVector> GetNiagaraArrayVector(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static TArray<FVector2D> GetNiagaraArrayVector2D(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static FVector2D GetNiagaraArrayVector2DValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static TArray<FVector4> GetNiagaraArrayVector4(UNiagaraComponent* NiagaraSystem, FName OverrideName);
    static FVector4 GetNiagaraArrayVector4Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static FVector GetNiagaraArrayVectorValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index);
    static void SetNiagaraArrayBool(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<bool>& ArrayData);
    static void SetNiagaraArrayBoolValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const bool& Value, bool bSizeToFit);
    static void SetNiagaraArrayColor(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FLinearColor>& ArrayData);
    static void SetNiagaraArrayColorValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FLinearColor& Value, bool bSizeToFit);
    static void SetNiagaraArrayFloat(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<float>& ArrayData);
    static void SetNiagaraArrayFloatValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, float Value, bool bSizeToFit);
    static void SetNiagaraArrayInt32(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<int32_t>& ArrayData);
    static void SetNiagaraArrayInt32Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, int32_t Value, bool bSizeToFit);
    static void SetNiagaraArrayMatrix(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FMatrix>& ArrayData, bool bApplyLWCRebase);
    static void SetNiagaraArrayMatrixValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FMatrix& Value, bool bSizeToFit, bool bApplyLWCRebase);
    static void SetNiagaraArrayPosition(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FVector>& ArrayData);
    static void SetNiagaraArrayPositionValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FVector& Value, bool bSizeToFit);
    static void SetNiagaraArrayQuat(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FQuat>& ArrayData);
    static void SetNiagaraArrayQuatValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FQuat& Value, bool bSizeToFit);
    static void SetNiagaraArrayUInt8(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<int32_t>& ArrayData);
    static void SetNiagaraArrayUInt8Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, int32_t Value, bool bSizeToFit);
    static void SetNiagaraArrayVector(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FVector>& ArrayData);
    static void SetNiagaraArrayVector2D(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FVector2D>& ArrayData);
    static void SetNiagaraArrayVector2DValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FVector2D& Value, bool bSizeToFit);
    static void SetNiagaraArrayVector4(UNiagaraComponent* NiagaraSystem, FName OverrideName, const TArray<FVector4>& ArrayData);
    static void SetNiagaraArrayVector4Value(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FVector4& Value, bool bSizeToFit);
    static void SetNiagaraArrayVectorValue(UNiagaraComponent* NiagaraSystem, FName OverrideName, int32_t Index, const FVector& Value, bool bSizeToFit);
};

// Size: 0x60
class UNiagaraDataInterfaceArrayInt32 : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<int32_t> IntData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayMatrix : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FMatrix44f> InternalMatrixData;
};

// Size: 0x68
class UNiagaraDataInterfaceArrayMesh : public UNiagaraDataInterfaceArray {
    /* 0x0058 */ TArray<FNiagaraMeshRendererMeshPropertiesBase> MeshData;

    static void SetNiagaraArrayMesh(UNiagaraComponent* NiagaraComponent, FName OverrideName, const TArray<FNiagaraMeshRendererMeshPropertiesBase>& ArrayData);
    static void SetNiagaraArrayMeshSM(UNiagaraComponent* NiagaraComponent, FName OverrideName, const TArray<UStaticMesh*>& ArrayData);
};

// Size: 0x60
class UNiagaraDataInterfaceArrayNiagaraID : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FNiagaraID> IntData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayPosition : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FNiagaraPosition> PositionData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayQuat : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<FQuat4f> InternalQuatData;
};

// Size: 0x60
class UNiagaraDataInterfaceArrayUInt8 : public UNiagaraDataInterfaceArray {
    /* 0x0050 */ TArray<uint8_t> InternalIntData;
};

// Size: 0x48
class UNiagaraDataInterfaceAsyncGpuTrace : public UNiagaraDataInterface {
    /* 0x0038 */ int32_t MaxTracesPerParticle;
    /* 0x003c */ int32_t MaxRetraces;
    /* 0x0040 */ uint8_t TraceProvider;
};

// Size: 0x48
class UNiagaraDataInterfaceAudioOscilloscope : public UNiagaraDataInterface {
    /* 0x0038 */ USoundSubmix* Submix;
    /* 0x0040 */ int32_t Resolution;
    /* 0x0044 */ float ScopeInMilliseconds;
};

// Size: 0x90
class UNiagaraDataInterfaceAudioPlayer : public UNiagaraDataInterface {
    /* 0x0038 */ USoundBase* SoundToPlay;
    /* 0x0040 */ USoundAttenuation* Attenuation;
    /* 0x0048 */ USoundConcurrency* Concurrency;
    /* 0x0050 */ TArray<FName> ParameterNames;
    /* 0x0060 */ FNiagaraUserParameterBinding ConfigurationUserParameter;
    /* 0x0080 */ bool bLimitPlaysPerTick;
    /* 0x0084 */ int32_t MaxPlaysPerTick;
    /* 0x0088 */ bool bStopWhenComponentIsDestroyed;
    /* 0x0089 */ bool bAllowLoopingOneShotSounds;
};

// Size: 0x410
class UNiagaraDataInterfaceAudioPlayerSettings : public UObject {
    /* 0x0028 */ bool bOverrideConcurrency;
    /* 0x0030 */ USoundConcurrency* Concurrency;
    /* 0x0038 */ bool bOverrideAttenuationSettings;
    /* 0x0040 */ FSoundAttenuationSettings AttenuationSettings;
};

// Size: 0x50
class UNiagaraDataInterfaceAudioSpectrum : public UNiagaraDataInterfaceAudioSubmix {
    /* 0x0040 */ int32_t Resolution;
    /* 0x0044 */ float MinimumFrequency;
    /* 0x0048 */ float MaximumFrequency;
    /* 0x004c */ float NoiseFloorDb;
};

// Size: 0x40
class UNiagaraDataInterfaceAudioSubmix : public UNiagaraDataInterface {
    /* 0x0038 */ USoundSubmix* Submix;
};

// Size: 0x40
class UNiagaraDataInterfaceCamera : public UNiagaraDataInterface {
    /* 0x0038 */ int32_t PlayerControllerIndex;
    /* 0x003c */ bool bRequireCurrentFrameData;
};

// Size: 0x40
class UNiagaraDataInterfaceCollisionQuery : public UNiagaraDataInterface {
};

// Size: 0x270
class UNiagaraDataInterfaceColorCurve : public UNiagaraDataInterfaceCurveBase {
    /* 0x0070 */ FRichCurve RedCurve;
    /* 0x00f0 */ FRichCurve GreenCurve;
    /* 0x0170 */ FRichCurve BlueCurve;
    /* 0x01f0 */ FRichCurve AlphaCurve;
};

// Size: 0x38
class UNiagaraDataInterfaceConsoleVariable : public UNiagaraDataInterface {
};

// Size: 0x60
class UNiagaraDataInterfaceCubeTexture : public UNiagaraDataInterface {
    /* 0x0038 */ UTexture* Texture;
    /* 0x0040 */ FNiagaraUserParameterBinding TextureUserParameter;
};

// Size: 0x48
class UNiagaraDataInterfaceCurlNoise : public UNiagaraDataInterface {
    /* 0x0038 */ uint32_t Seed;
};

// Size: 0xf0
class UNiagaraDataInterfaceCurve : public UNiagaraDataInterfaceCurveBase {
    /* 0x0070 */ FRichCurve Curve;
};

// Size: 0x70
class UNiagaraDataInterfaceCurveBase : public UNiagaraDataInterface {
    /* 0x0038 */ TArray<float> ShaderLUT;
    /* 0x0048 */ float LUTMinTime;
    /* 0x004c */ float LUTMaxTime;
    /* 0x0050 */ float LUTInvTimeRange;
    /* 0x0054 */ float LUTNumSamplesMinusOne;
    /* 0x005c */ bool bUseLUT;
    /* 0x005c */ bool bExposeCurve;
    /* 0x0060 */ FName ExposedName;
    /* 0x0068 */ UTexture2D* ExposedTexture;
};

// Size: 0xb8
class UNiagaraDataInterfaceDataChannelRead : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ UNiagaraDataChannelAsset* Channel;
    /* 0x0040 */ bool bReadCurrentFrame;
    /* 0x0041 */ bool bUpdateSourceDataEveryTick;
    /* 0x0042 */ bool bOverrideSpawnGroupToDataChannelIndex;
    /* 0x0043 */ bool bOnlySpawnOnceOnSubticks;
    /* 0x0048 */ FNDIDataChannelCompiledData CompiledData;
};

// Size: 0x110
class UNiagaraDataInterfaceDataChannelWrite : public UNiagaraDataInterface {
    /* 0x0040 */ ENiagaraDataChannelAllocationMode AllocationMode;
    /* 0x0044 */ uint32_t AllocationCount;
    /* 0x0048 */ bool bPublishToGame;
    /* 0x0049 */ bool bPublishToCPU;
    /* 0x004a */ bool bPublishToGPU;
    /* 0x004b */ bool bUpdateDestinationDataEveryTick;
    /* 0x004c */ bool bOnlyWriteOnceOnSubticks;
    /* 0x0050 */ UNiagaraDataChannelAsset* Channel;
    /* 0x0058 */ FNDIDataChannelWriteCompiledData CompiledData;
};

// Size: 0x78
class UNiagaraDataInterfaceDataTable : public UNiagaraDataInterface {
    /* 0x0038 */ UDataTable* DataTable;
    /* 0x0040 */ TArray<FName> FilteredRowNames;
    /* 0x0050 */ FNiagaraUserParameterBinding ObjectParameterBinding;
    /* 0x0070 */ bool bCreateFilteredTable;
};

// Size: 0x40
class UNiagaraDataInterfaceDebugDraw : public UNiagaraDataInterface {
    /* 0x0038 */ uint32_t OverrideMaxLineInstances;
};

// Size: 0xa8
class UNiagaraDataInterfaceDynamicMesh : public UNiagaraDataInterface {
    /* 0x0040 */ TArray<FNiagaraDynamicMeshSection> Sections;
    /* 0x0050 */ TArray<FNiagaraDynamicMeshMaterial> Materials;
    /* 0x0060 */ int32_t NumVertices;
    /* 0x0064 */ int32_t NumTexCoords;
    /* 0x0068 */ bool bHasColors;
    /* 0x0069 */ bool bHasTangentBasis;
    /* 0x006a */ bool bClearTrianglesPerFrame;
    /* 0x0070 */ FBox DefaultBounds;
};

// Size: 0xc
struct FNiagaraDataInterfaceEmitterBinding {
    /* 0x0000 */ ENiagaraDataInterfaceEmitterBindingMode BindingMode;
    /* 0x0004 */ FName EmitterName;
};

// Size: 0x48
class UNiagaraDataInterfaceEmitterProperties : public UNiagaraDataInterface {
    /* 0x0038 */ FNiagaraDataInterfaceEmitterBinding EmitterBinding;
};

// Size: 0x68
class UNiagaraDataInterfaceExport : public UNiagaraDataInterface {
    /* 0x0038 */ FNiagaraUserParameterBinding CallbackHandlerParameter;
    /* 0x0058 */ ENDIExport_GPUAllocationMode GPUAllocationMode;
    /* 0x005c */ int32_t GPUAllocationFixedSize;
    /* 0x0060 */ float GPUAllocationPerParticleSize;
};

// Size: 0x38
class UNiagaraDataInterfaceGBuffer : public UNiagaraDataInterface {
};

// Size: 0x60
class UNiagaraDataInterfaceGrid2D : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ bool ClearBeforeNonIterationStage;
    /* 0x003c */ int32_t NumCellsX;
    /* 0x0040 */ int32_t NumCellsY;
    /* 0x0044 */ int32_t NumCellsMaxAxis;
    /* 0x0048 */ int32_t NumAttributes;
    /* 0x004c */ bool SetGridFromMaxAxis;
    /* 0x0050 */ FVector2D WorldBBoxSize;
};

// Size: 0x128
class UNiagaraDataInterfaceGrid2DCollection : public UNiagaraDataInterfaceGrid2D {
    /* 0x0060 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
    /* 0x0080 */ ENiagaraGpuBufferFormat OverrideBufferFormat;
    /* 0x0081 */ bool bOverrideFormat;
    /* 0x00d8 */ TMap<uint64_t, UTextureRenderTarget2DArray*> ManagedRenderTargets;

    bool FillRawTexture2D(const UNiagaraComponent* Component, UTextureRenderTarget2D* Dest, int32_t& TilesX, int32_t& TilesY);
    bool FillTexture2D(const UNiagaraComponent* Component, UTextureRenderTarget2D* Dest, int32_t AttributeIndex);
    void GetRawTextureSize(const UNiagaraComponent* Component, int32_t& SizeX, int32_t& SizeY);
    void GetTextureSize(const UNiagaraComponent* Component, int32_t& SizeX, int32_t& SizeY);
};

// Size: 0x148
class UNiagaraDataInterfaceGrid2DCollectionReader : public UNiagaraDataInterfaceGrid2DCollection {
    /* 0x0128 */ FString EmitterName;
    /* 0x0138 */ FString DIName;
};

// Size: 0x70
class UNiagaraDataInterfaceGrid3D : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ bool ClearBeforeNonIterationStage;
    /* 0x003c */ FIntVector NumCells;
    /* 0x0048 */ float CellSize;
    /* 0x004c */ int32_t NumCellsMaxAxis;
    /* 0x0050 */ ESetResolutionMethod SetResolutionMethod;
    /* 0x0058 */ FVector WorldBBoxSize;
};

// Size: 0xf0
class UNiagaraDataInterfaceGrid3DCollection : public UNiagaraDataInterfaceGrid3D {
    /* 0x0070 */ int32_t NumAttributes;
    /* 0x0078 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
    /* 0x0098 */ ENiagaraGpuBufferFormat OverrideBufferFormat;
    /* 0x0099 */ bool bOverrideFormat;

    bool FillRawVolumeTexture(const UNiagaraComponent* Component, UVolumeTexture* Dest, int32_t& TilesX, int32_t& TilesY, int32_t& TileZ);
    bool FillVolumeTexture(const UNiagaraComponent* Component, UVolumeTexture* Dest, int32_t AttributeIndex);
    void GetRawTextureSize(const UNiagaraComponent* Component, int32_t& SizeX, int32_t& SizeY, int32_t& SizeZ);
    void GetTextureSize(const UNiagaraComponent* Component, int32_t& SizeX, int32_t& SizeY, int32_t& SizeZ);
};

// Size: 0x110
class UNiagaraDataInterfaceGrid3DCollectionReader : public UNiagaraDataInterfaceGrid3DCollection {
    /* 0x00f0 */ FString EmitterName;
    /* 0x0100 */ FString DIName;
};

// Size: 0x60
class UNiagaraDataInterfaceIntRenderTarget2D : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ FIntPoint Size;
    /* 0x0040 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
};

// Size: 0x60
class UNiagaraDataInterfaceLandscape : public UNiagaraDataInterface {
    /* 0x0038 */ AActor* SourceLandscape;
    /* 0x0040 */ ENDILandscape_SourceMode SourceMode;
    /* 0x0048 */ TArray<UPhysicalMaterial*> PhysicalMaterials;
    /* 0x0058 */ bool bVirtualTexturesSupported;
};

// Size: 0x48
class UNiagaraDataInterfaceMemoryBuffer : public UNiagaraDataInterface {
    /* 0x0040 */ int32_t DefaultNumElements;
    /* 0x0044 */ ENiagaraGpuSyncMode GpuSyncMode;
};

// Size: 0x50
class UNiagaraDataInterfaceMeshRendererInfo : public UNiagaraDataInterface {
    /* 0x0038 */ UNiagaraMeshRendererProperties* MeshRenderer;
};

// Size: 0x78
class UNiagaraDataInterfaceNeighborGrid3D : public UNiagaraDataInterfaceGrid3D {
    /* 0x0070 */ uint32_t MaxNeighborsPerCell;
};

// Size: 0x38
class UNiagaraDataInterfaceOcclusion : public UNiagaraDataInterface {
};

// Size: 0x48
class UNiagaraDataInterfaceParticleRead : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ FNiagaraDataInterfaceEmitterBinding EmitterBinding;
};

// Size: 0xa8
class UNiagaraDataInterfacePhysicsAsset : public UNiagaraDataInterface {
    /* 0x0038 */ UPhysicsAsset* DefaultSource;
    /* 0x0040 */ TSoftObjectPtr<AActor> SoftSourceActor;
    /* 0x0068 */ FNiagaraUserParameterBinding MeshUserParameter;
};

// Size: 0x68
class UNiagaraDataInterfacePlatformSet : public UNiagaraDataInterface {
    /* 0x0038 */ FNiagaraPlatformSet Platforms;
};

// Size: 0x38
class UNiagaraDataInterfaceRWBase : public UNiagaraDataInterface {
};

// Size: 0x80
class UNiagaraDataInterfaceRasterizationGrid3D : public UNiagaraDataInterfaceGrid3D {
    /* 0x0070 */ int32_t NumAttributes;
    /* 0x0074 */ float Precision;
    /* 0x0078 */ int32_t ResetValue;
};

// Size: 0xc0
class UNiagaraDataInterfaceRenderTarget2D : public UNiagaraDataInterfaceRWBase {
    /* 0x0040 */ FIntPoint Size;
    /* 0x0048 */ ENiagaraMipMapGeneration MipMapGeneration;
    /* 0x0049 */ ENiagaraMipMapGenerationType MipMapGenerationType;
    /* 0x004a */ uint8_t OverrideRenderTargetFormat;
    /* 0x004b */ uint8_t OverrideRenderTargetFilter;
    /* 0x004c */ bool bInheritUserParameterSettings;
    /* 0x004c */ bool bOverrideFormat;
    /* 0x0050 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
};

// Size: 0x68
class UNiagaraDataInterfaceRenderTarget2DArray : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ FIntVector Size;
    /* 0x0044 */ uint8_t OverrideRenderTargetFormat;
    /* 0x0045 */ uint8_t OverrideRenderTargetFilter;
    /* 0x0046 */ bool bInheritUserParameterSettings;
    /* 0x0046 */ bool bOverrideFormat;
    /* 0x0048 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
};

// Size: 0x60
class UNiagaraDataInterfaceRenderTargetCube : public UNiagaraDataInterfaceRWBase {
    /* 0x0038 */ int32_t Size;
    /* 0x003c */ uint8_t OverrideRenderTargetFormat;
    /* 0x003d */ uint8_t OverrideRenderTargetFilter;
    /* 0x003e */ bool bInheritUserParameterSettings;
    /* 0x003e */ bool bOverrideFormat;
    /* 0x0040 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
};

// Size: 0x70
class UNiagaraDataInterfaceRenderTargetVolume : public UNiagaraDataInterfaceRWBase {
    /* 0x0040 */ FIntVector Size;
    /* 0x004c */ uint8_t OverrideRenderTargetFormat;
    /* 0x004d */ uint8_t OverrideRenderTargetFilter;
    /* 0x004e */ bool bInheritUserParameterSettings;
    /* 0x004e */ bool bOverrideFormat;
    /* 0x0050 */ FNiagaraUserParameterBinding RenderTargetUserParameter;
};

// Size: 0x78
class UNiagaraDataInterfaceRigidMeshCollisionQuery : public UNiagaraDataInterface {
    /* 0x0038 */ TArray<FName> ActorTags;
    /* 0x0048 */ TArray<FName> ComponentTags;
    /* 0x0058 */ TArray<TSoftObjectPtr<AActor>> SourceActors;
    /* 0x0068 */ bool OnlyUseMoveable;
    /* 0x0069 */ bool UseComplexCollisions;
    /* 0x006a */ bool bFilterByObjectType;
    /* 0x006b */ bool GlobalSearchAllowed;
    /* 0x006c */ bool GlobalSearchForced;
    /* 0x006d */ bool GlobalSearchFallback_Unscripted;
    /* 0x0070 */ int32_t MaxNumPrimitives;
};

// Size: 0x128
class UNiagaraDataInterfaceSceneCapture2D : public UNiagaraDataInterface {
    /* 0x0038 */ ENDISceneCapture2DSourceMode SourceMode;
    /* 0x0040 */ FNiagaraUserParameterBinding SceneCaptureUserParameter;
    /* 0x0060 */ bool bAutoMoveWithComponent;
    /* 0x0061 */ ENDISceneCapture2DOffsetMode AutoMoveOffsetLocationMode;
    /* 0x0068 */ FVector AutoMoveOffsetLocation;
    /* 0x0080 */ ENDISceneCapture2DOffsetMode AutoMoveOffsetRotationMode;
    /* 0x0088 */ FRotator AutoMoveOffsetRotation;
    /* 0x00a0 */ uint8_t ManagedCaptureSource;
    /* 0x00a4 */ FIntPoint ManagedTextureSize;
    /* 0x00ac */ uint8_t ManagedTextureFormat;
    /* 0x00ad */ uint8_t ManagedProjectionType;
    /* 0x00b0 */ float ManagedFOVAngle;
    /* 0x00b4 */ float ManagedOrthoWidth;
    /* 0x00b8 */ bool bManagedCaptureEveryFrame;
    /* 0x00b9 */ bool bManagedCaptureOnMovement;
    /* 0x00c0 */ TArray<AActor*> ManagedShowOnlyActors;
    /* 0x00d8 */ TMap<uint64_t, USceneCaptureComponent2D*> ManagedCaptureComponents;

    static void SetSceneCapture2DManagedShowOnlyActors(UNiagaraComponent* NiagaraSystem, const FName ParameterName, TArray<AActor*> ShowOnlyActors);
};

// Size: 0x68
class UNiagaraDataInterfaceSimCacheReader : public UNiagaraDataInterface {
    /* 0x0038 */ FNiagaraUserParameterBinding SimCacheBinding;
    /* 0x0058 */ UNiagaraSimCache* SimCache;
    /* 0x0060 */ FName EmitterBinding;
};

// Size: 0x48
class UNiagaraDataInterfaceSimpleCounter : public UNiagaraDataInterfaceRWBase {
    /* 0x0040 */ ENiagaraGpuSyncMode GpuSyncMode;
    /* 0x0044 */ int32_t InitialValue;
};

// Size: 0x100
class UNiagaraDataInterfaceSkeletalMesh : public UNiagaraDataInterface {
    /* 0x0038 */ ENDISkeletalMesh_SourceMode SourceMode;
    /* 0x0040 */ USkeletalMesh* DefaultMesh;
    /* 0x0048 */ TSoftObjectPtr<AActor> SoftSourceActor;
    /* 0x0070 */ TArray<FName> ComponentTags;
    /* 0x0080 */ USkeletalMeshComponent* SourceComponent;
    /* 0x0088 */ FNiagaraUserParameterBinding MeshUserParameter;
    /* 0x00a8 */ ENDISkeletalMesh_SkinningMode SkinningMode;
    /* 0x00b0 */ TArray<FName> SamplingRegions;
    /* 0x00c0 */ int32_t WholeMeshLOD;
    /* 0x00c8 */ TArray<FName> FilteredBones;
    /* 0x00d8 */ TArray<FName> FilteredSockets;
    /* 0x00e8 */ FName ExcludeBoneName;
    /* 0x00f0 */ bool bExcludeBone;
    /* 0x00f4 */ int32_t UvSetIndex;
    /* 0x00f8 */ bool bRequireCurrentFrameData;
    /* 0x00f9 */ bool bReadDeformedGeometry;

    void OnSourceEndPlay(AActor* InSource, uint8_t Reason);
};

// Size: 0xa8
class UNiagaraDataInterfaceSocketReader : public UNiagaraDataInterface {
    /* 0x0038 */ ENDISocketReaderSourceMode SourceMode;
    /* 0x0040 */ TArray<FName> FilteredSockets;
    /* 0x0050 */ TLazyObjectPtr<AActor> SourceActor;
    /* 0x0068 */ UObject* SourceAsset;
    /* 0x0070 */ UClass* AttachComponentClass;
    /* 0x0078 */ FName AttachComponentTag;
    /* 0x0080 */ FNiagaraUserParameterBinding ObjectParameterBinding;
    /* 0x00a0 */ bool bUpdateSocketsPerFrame;
    /* 0x00a1 */ bool bRequireCurrentFrameData;
};

// Size: 0x68
class UNiagaraDataInterfaceSparseVolumeTexture : public UNiagaraDataInterface {
    /* 0x0038 */ USparseVolumeTexture* SparseVolumeTexture;
    /* 0x0040 */ FNiagaraUserParameterBinding SparseVolumeTextureUserParameter;
    /* 0x0060 */ bool BlockingStreamingRequests;
};

// Size: 0xd8
class UNiagaraDataInterfaceSpline : public UNiagaraDataInterface {
    /* 0x0038 */ TSoftObjectPtr<AActor> SoftSourceActor;
    /* 0x0060 */ FNiagaraUserParameterBinding SplineUserParameter;
    /* 0x0080 */ bool bUseLUT;
    /* 0x0084 */ int32_t NumLUTSteps;
};

// Size: 0x40
struct FNiagaraDataInterfaceSplineLUT {
    /* 0x0000 */ TArray<FVector> Positions;
    /* 0x0010 */ TArray<FVector> Scales;
    /* 0x0020 */ TArray<FQuat> Rotations;
    /* 0x0030 */ float SplineLength;
    /* 0x0034 */ float SplineDistanceStep;
    /* 0x0038 */ float InvSplineDistanceStep;
    /* 0x003c */ int32_t MaxIndex;
};

// Size: 0x40
class UNiagaraDataInterfaceSpriteRendererInfo : public UNiagaraDataInterface {
    /* 0x0038 */ UNiagaraSpriteRendererProperties* SpriteRenderer;
};

// Size: 0xf0
class UNiagaraDataInterfaceStaticMesh : public UNiagaraDataInterface {
    /* 0x0038 */ ENDIStaticMesh_SourceMode SourceMode;
    /* 0x0040 */ UStaticMesh* DefaultMesh;
    /* 0x0048 */ TSoftObjectPtr<AActor> SoftSourceActor;
    /* 0x0070 */ TWeakObjectPtr<UStaticMeshComponent> SourceComponent;
    /* 0x0078 */ FNDIStaticMeshSectionFilter SectionFilter;
    /* 0x0088 */ bool bCaptureTransformsPerFrame;
    /* 0x0089 */ bool bUsePhysicsBodyVelocity;
    /* 0x008a */ bool bAllowSamplingFromStreamingLODs;
    /* 0x008c */ int32_t LODIndex;
    /* 0x0090 */ FNiagaraUserParameterBinding LODIndexUserParameter;
    /* 0x00b0 */ FNiagaraUserParameterBinding MeshParameterBinding;
    /* 0x00d0 */ int32_t InstanceIndex;
    /* 0x00d8 */ TArray<FName> FilteredSockets;

    void OnSourceEndPlay(AActor* InSource, uint8_t Reason);
    static void SetNiagaraStaticMeshDIInstanceIndex(UNiagaraComponent* NiagaraSystem, const FName UserParameterName, int32_t NewInstanceIndex);
};

// Size: 0x60
class UNiagaraDataInterfaceTexture : public UNiagaraDataInterface {
    /* 0x0038 */ UTexture* Texture;
    /* 0x0040 */ FNiagaraUserParameterBinding TextureUserParameter;
};

// Size: 0xa8
class UNiagaraDataInterfaceUObjectPropertyReader : public UNiagaraDataInterface {
    /* 0x0038 */ ENDIObjectPropertyReaderSourceMode SourceMode;
    /* 0x0040 */ FNiagaraUserParameterBinding UObjectParameterBinding;
    /* 0x0060 */ TArray<FNiagaraUObjectPropertyReaderRemap> PropertyRemap;
    /* 0x0070 */ TSoftObjectPtr<AActor> SourceActor;
    /* 0x0098 */ UClass* SourceActorComponentClass;

    static void SetUObjectReaderPropertyRemap(UNiagaraComponent* NiagaraComponent, FName UserParameterName, FName GraphName, FName RemapName);
};

// Size: 0x170
class UNiagaraDataInterfaceVector2DCurve : public UNiagaraDataInterfaceCurveBase {
    /* 0x0070 */ FRichCurve XCurve;
    /* 0x00f0 */ FRichCurve YCurve;
};

// Size: 0x270
class UNiagaraDataInterfaceVector4Curve : public UNiagaraDataInterfaceCurveBase {
    /* 0x0070 */ FRichCurve XCurve;
    /* 0x00f0 */ FRichCurve YCurve;
    /* 0x0170 */ FRichCurve ZCurve;
    /* 0x01f0 */ FRichCurve WCurve;
};

// Size: 0x1f0
class UNiagaraDataInterfaceVectorCurve : public UNiagaraDataInterfaceCurveBase {
    /* 0x0070 */ FRichCurve XCurve;
    /* 0x00f0 */ FRichCurve YCurve;
    /* 0x0170 */ FRichCurve ZCurve;
};

// Size: 0x48
class UNiagaraDataInterfaceVectorField : public UNiagaraDataInterface {
    /* 0x0038 */ UVectorField* Field;
    /* 0x0040 */ bool bTileX;
    /* 0x0041 */ bool bTileY;
    /* 0x0042 */ bool bTileZ;
};

// Size: 0x60
class UNiagaraDataInterfaceVirtualTexture : public UNiagaraDataInterface {
    /* 0x0038 */ URuntimeVirtualTexture* Texture;
    /* 0x0040 */ FNiagaraUserParameterBinding TextureUserParameter;
};

// Size: 0x90
class UNiagaraDataInterfaceVolumeCache : public UNiagaraDataInterface {
    /* 0x0038 */ UVolumeCache* VolumeCache;
};

// Size: 0x60
class UNiagaraDataInterfaceVolumeTexture : public UNiagaraDataInterface {
    /* 0x0038 */ UTexture* Texture;
    /* 0x0040 */ FNiagaraUserParameterBinding TextureUserParameter;
};

// Size: 0x48
struct FNiagaraDataSetCompiledData {
    /* 0x0000 */ TArray<FNiagaraVariableBase> Variables;
    /* 0x0010 */ TArray<FNiagaraVariableLayoutInfo> VariableLayouts;
    /* 0x0020 */ FNiagaraDataSetID ID;
    /* 0x002c */ uint32_t TotalFloatComponents;
    /* 0x0030 */ uint32_t TotalInt32Components;
    /* 0x0034 */ uint32_t TotalHalfComponents;
    /* 0x0038 */ bool bRequiresPersistentIDs;
    /* 0x003c */ ENiagaraSimTarget SimTarget;
};

// Size: 0xc
struct FNiagaraDataSetID {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ ENiagaraDataSetType Type;
};

// Size: 0x20
struct FNiagaraDataSetProperties {
    /* 0x0000 */ FNiagaraDataSetID ID;
    /* 0x0010 */ TArray<FNiagaraVariableBase> Variables;
};

// Size: 0x288
class UNiagaraDebugHUDSettings : public UObject {
    /* 0x0048 */ FNiagaraDebugHUDSettingsData Data;
};

// Size: 0x240
struct FNiagaraDebugHUDSettingsData {
    /* 0x0000 */ bool bHudEnabled;
    /* 0x0001 */ bool bHudRenderingEnabled;
    /* 0x0002 */ bool bValidationEnabled;
    /* 0x0003 */ bool bOverviewEnabled;
    /* 0x0004 */ ENiagaraDebugHUDOverviewMode OverviewMode;
    /* 0x0008 */ ENiagaraDebugHUDDOverviewSort OverviewSortMode;
    /* 0x000c */ bool bIncludeCascade;
    /* 0x000d */ bool bShowRegisteredComponents;
    /* 0x000e */ bool bOverviewShowFilteredSystemOnly;
    /* 0x000f */ bool bShowGlobalBudgetInfo;
    /* 0x0010 */ bool bSystemFilterEnabled;
    /* 0x0018 */ FString SystemFilter;
    /* 0x0028 */ bool bEmitterFilterEnabled;
    /* 0x0030 */ FString EmitterFilter;
    /* 0x0040 */ bool bActorFilterEnabled;
    /* 0x0048 */ FString ActorFilter;
    /* 0x0058 */ bool bComponentFilterEnabled;
    /* 0x0060 */ FString ComponentFilter;
    /* 0x0070 */ bool bValidateSystemSimulationDataBuffers;
    /* 0x0071 */ bool bValidateParticleDataBuffers;
    /* 0x0072 */ bool bValidationLogErrors;
    /* 0x0074 */ int32_t ValidationAttributeDisplayTruncate;
    /* 0x0078 */ ENiagaraDebugHudVerbosity SystemDebugVerbosity;
    /* 0x007c */ ENiagaraDebugHudVerbosity SystemEmitterVerbosity;
    /* 0x0080 */ ENiagaraDebugHudVerbosity DataInterfaceVerbosity;
    /* 0x0088 */ TArray<FNiagaraDebugHUDVariable> SystemVariables;
    /* 0x0098 */ bool bSystemShowActiveOnlyInWorld;
    /* 0x0099 */ bool bShowParticleVariables;
    /* 0x00a0 */ TArray<FNiagaraDebugHUDVariable> ParticlesVariables;
    /* 0x00b0 */ bool bEnableGpuParticleReadback;
    /* 0x00b1 */ bool bShowParticleIndex;
    /* 0x00b2 */ bool bShowParticlesVariablesWithSystem;
    /* 0x00b3 */ bool bShowParticleVariablesVertical;
    /* 0x00b4 */ bool bUseMaxParticlesToDisplay;
    /* 0x00b8 */ int32_t MaxParticlesToDisplay;
    /* 0x00bc */ bool bUseParticleDisplayClip;
    /* 0x00c0 */ FVector2D ParticleDisplayClip;
    /* 0x00d0 */ bool bUseParticleDisplayCenterRadius;
    /* 0x00d4 */ float ParticleDisplayCenterRadius;
    /* 0x00d8 */ int32_t PerfReportFrames;
    /* 0x00dc */ ENiagaraDebugHUDPerfSampleMode PerfSampleMode;
    /* 0x00e0 */ ENiagaraDebugHUDPerfUnits PerfUnits;
    /* 0x00e4 */ bool bShowPerfColumGameThreadOnly;
    /* 0x00e8 */ ENiagaraDebugHUDPerfGraphMode PerfGraphMode;
    /* 0x00ec */ int32_t PerfHistoryFrames;
    /* 0x00f0 */ bool bUsePerfGraphTimeRange;
    /* 0x00f4 */ float PerfGraphTimeRange;
    /* 0x00f8 */ FVector2D PerfGraphSize;
    /* 0x0108 */ FLinearColor PerfGraphAxisColor;
    /* 0x0118 */ int32_t SmoothingWidth;
    /* 0x011c */ ENiagaraDebugHudFont OverviewFont;
    /* 0x0120 */ FVector2D OverviewLocation;
    /* 0x0130 */ FNiagaraDebugHudTextOptions SystemTextOptions;
    /* 0x0148 */ FNiagaraDebugHudTextOptions ParticleTextOptions;
    /* 0x0160 */ bool bDrawBoundsEnabled;
    /* 0x0161 */ bool bDrawBoundsWireframe;
    /* 0x0164 */ float DrawBoundsAlpha;
    /* 0x0168 */ FLinearColor DefaultBackgroundColor;
    /* 0x0178 */ FLinearColor OverviewHeadingColor;
    /* 0x0188 */ FLinearColor OverviewDetailColor;
    /* 0x0198 */ FLinearColor OverviewDetailHighlightColor;
    /* 0x01a8 */ FLinearColor InWorldErrorTextColor;
    /* 0x01b8 */ FLinearColor InWorldTextColor;
    /* 0x01c8 */ FLinearColor MessageInfoTextColor;
    /* 0x01d8 */ FLinearColor MessageWarningTextColor;
    /* 0x01e8 */ FLinearColor MessageErrorTextColor;
    /* 0x01f8 */ float SystemColorTableOpacity;
    /* 0x01fc */ uint32_t SystemColorSeed;
    /* 0x0200 */ FVector SystemColorHSVMin;
    /* 0x0218 */ FVector SystemColorHSVMax;
    /* 0x0230 */ ENiagaraDebugPlaybackMode PlaybackMode;
    /* 0x0231 */ bool bPlaybackRateEnabled;
    /* 0x0234 */ float PlaybackRate;
    /* 0x0238 */ bool bLoopTimeEnabled;
    /* 0x023c */ float LoopTime;
};

// Size: 0x18
struct FNiagaraDebugHUDVariable {
    /* 0x0000 */ bool bEnabled;
    /* 0x0008 */ FString Name;
};

// Size: 0x18
struct FNiagaraDebugHudTextOptions {
    /* 0x0000 */ ENiagaraDebugHudFont Font;
    /* 0x0004 */ ENiagaraDebugHudHAlign HorizontalAlignment;
    /* 0x0005 */ ENiagaraDebugHudVAlign VerticalAlignment;
    /* 0x0008 */ FVector2D ScreenOffset;
};

// Size: 0x20
struct FNiagaraDebuggerAcceptConnection {
    /* 0x0000 */ FGuid SessionId;
    /* 0x0010 */ FGuid InstanceId;
};

// Size: 0x20
struct FNiagaraDebuggerConnectionClosed {
    /* 0x0000 */ FGuid SessionId;
    /* 0x0010 */ FGuid InstanceId;
};

// Size: 0x18
struct FNiagaraDebuggerExecuteConsoleCommand {
    /* 0x0000 */ FString Command;
    /* 0x0010 */ bool bRequiresWorld;
};

// Size: 0x50
struct FNiagaraDebuggerOutlinerUpdate {
    /* 0x0000 */ FNiagaraOutlinerData OutlinerData;
};

// Size: 0x20
struct FNiagaraDebuggerRequestConnection {
    /* 0x0000 */ FGuid SessionId;
    /* 0x0010 */ FGuid InstanceId;
};

// Size: 0x320
class UNiagaraDecalRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ UMaterialInterface* Material;
    /* 0x00c0 */ FNiagaraParameterBinding MaterialParameterBinding;
    /* 0x00cc */ ENiagaraRendererSourceDataMode SourceMode;
    /* 0x00d0 */ int32_t RendererVisibility;
    /* 0x00d4 */ float DecalScreenSizeFade;
    /* 0x00d8 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x0110 */ FNiagaraVariableAttributeBinding DecalOrientationBinding;
    /* 0x0148 */ FNiagaraVariableAttributeBinding DecalSizeBinding;
    /* 0x0180 */ FNiagaraVariableAttributeBinding DecalFadeBinding;
    /* 0x01b8 */ FNiagaraVariableAttributeBinding DecalSortOrderBinding;
    /* 0x01f0 */ FNiagaraVariableAttributeBinding DecalColorBinding;
    /* 0x0228 */ FNiagaraVariableAttributeBinding DecalVisibleBinding;
    /* 0x0260 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x0298 */ FNiagaraRendererMaterialParameters MaterialParameters;
};

// Size: 0x14
struct FNiagaraDetailsLevelScaleOverrides {
    /* 0x0000 */ float Low;
    /* 0x0004 */ float Medium;
    /* 0x0008 */ float High;
    /* 0x000c */ float Epic;
    /* 0x0010 */ float Cine;
};

// Size: 0x10
struct FNiagaraDeviceProfileStateEntry {
    /* 0x0000 */ FName ProfileName;
    /* 0x0008 */ uint32_t QualityLevelMask;
    /* 0x000c */ uint32_t SetQualityLevelMask;
};

// Size: 0x28
struct FNiagaraDistributionBase {
    /* 0x0008 */ ENiagaraDistributionMode Mode;
    /* 0x000c */ FNiagaraVariableBase ParameterBinding;
    /* 0x0018 */ FInstancedStruct ParameterExpression;
};

// Size: 0x40
struct FNiagaraDistributionColor : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<FLinearColor> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x40
struct FNiagaraDistributionCurveFloat : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<float> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x40
struct FNiagaraDistributionCurveVector3 : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<FVector3f> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x40
struct FNiagaraDistributionFloat : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<float> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x40
struct FNiagaraDistributionPosition : public FNiagaraDistributionVector3 {
};

// Size: 0x48
struct FNiagaraDistributionRangeColor : public FNiagaraDistributionBase {
    /* 0x0028 */ FLinearColor min;
    /* 0x0038 */ FLinearColor max;
};

// Size: 0x30
struct FNiagaraDistributionRangeFloat : public FNiagaraDistributionBase {
    /* 0x0028 */ float min;
    /* 0x002c */ float max;
};

// Size: 0x28
struct FNiagaraDistributionRangeInt {
    /* 0x0000 */ ENiagaraDistributionMode Mode;
    /* 0x0004 */ FNiagaraVariableBase ParameterBinding;
    /* 0x0010 */ FInstancedStruct ParameterExpression;
    /* 0x0020 */ int32_t min;
    /* 0x0024 */ int32_t max;
};

// Size: 0x38
struct FNiagaraDistributionRangeVector2 : public FNiagaraDistributionBase {
    /* 0x0028 */ FVector2f min;
    /* 0x0030 */ FVector2f max;
};

// Size: 0x40
struct FNiagaraDistributionRangeVector3 : public FNiagaraDistributionBase {
    /* 0x0028 */ FVector3f min;
    /* 0x0034 */ FVector3f max;
};

// Size: 0x40
struct FNiagaraDistributionVector2 : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<FVector2f> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x40
struct FNiagaraDistributionVector3 : public FNiagaraDistributionBase {
    /* 0x0028 */ TArray<FVector3f> Values;
    /* 0x0038 */ FVector2f ValuesTimeRange;
};

// Size: 0x8
struct FNiagaraDouble {
    /* 0x0000 */ double Value;
};

// Size: 0x28
struct FNiagaraDynamicMeshMaterial {
    /* 0x0000 */ UMaterialInterface* Material;
    /* 0x0008 */ FNiagaraUserParameterBinding MaterialUserParamBinding;
};

// Size: 0x8
struct FNiagaraDynamicMeshSection {
    /* 0x0000 */ int32_t NumTriangles;
    /* 0x0004 */ int32_t MaterialIndex;
};

// Size: 0x28
class UNiagaraEditorDataBase : public UObject {
};

// Size: 0x28
class UNiagaraEditorParametersAdapterBase : public UObject {
};

// Size: 0xa0
class UNiagaraEffectType : public UObject {
    /* 0x0028 */ bool bAllowCullingForLocalPlayers;
    /* 0x002c */ ENiagaraScalabilityUpdateFrequency UpdateFrequency;
    /* 0x0030 */ ENiagaraCullReaction CullReaction;
    /* 0x0038 */ UNiagaraSignificanceHandler* SignificanceHandler;
    /* 0x0040 */ TArray<FNiagaraSystemScalabilitySettings> DetailLevelScalabilitySettings;
    /* 0x0050 */ FNiagaraSystemScalabilitySettingsArray SystemScalabilitySettings;
    /* 0x0060 */ FNiagaraEmitterScalabilitySettingsArray EmitterScalabilitySettings;
    /* 0x0078 */ UNiagaraBaselineController* PerformanceBaselineController;
    /* 0x0080 */ FNiagaraPerfBaselineStats PerfBaselineStats;
    /* 0x0090 */ FGuid PerfBaselineVersion;
};

// Size: 0x70
class UNiagaraEmitter : public UObject {
    /* 0x0030 */ FGuid ExposedVersion;
    /* 0x0040 */ bool bVersioningEnabled;
    /* 0x0048 */ TArray<FVersionedNiagaraEmitterData> VersionData;
    /* 0x0060 */ FString UniqueEmitterName;
};

// Size: 0x138
struct FNiagaraEmitterCompiledData {
    /* 0x0000 */ TArray<FName> SpawnAttributes;
    /* 0x0010 */ FNiagaraVariable EmitterSpawnIntervalVar;
    /* 0x0030 */ FNiagaraVariable EmitterInterpSpawnStartDTVar;
    /* 0x0050 */ FNiagaraVariable EmitterSpawnGroupVar;
    /* 0x0070 */ FNiagaraVariable EmitterAgeVar;
    /* 0x0090 */ FNiagaraVariable EmitterRandomSeedVar;
    /* 0x00b0 */ FNiagaraVariable EmitterInstanceSeedVar;
    /* 0x00d0 */ FNiagaraVariable EmitterTotalSpawnedParticlesVar;
    /* 0x00f0 */ FNiagaraDataSetCompiledData DataSetCompiledData;
};

// Size: 0x48
struct FNiagaraEmitterHandle {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FGuid ID;
    /* 0x0018 */ FName IdName;
    /* 0x0020 */ bool bIsEnabled;
    /* 0x0021 */ ENiagaraEmitterMode EmitterMode;
    /* 0x0028 */ FVersionedNiagaraEmitter VersionedInstance;
    /* 0x0040 */ UNiagaraStatelessEmitter* StatelessEmitter;
};

// Size: 0x4
struct FNiagaraEmitterID {
    /* 0x0000 */ int32_t ID;
};

// Size: 0x40
struct FNiagaraEmitterScalabilityOverride : public FNiagaraEmitterScalabilitySettings {
    /* 0x0038 */ bool bOverrideSpawnCountScale;
};

// Size: 0x10
struct FNiagaraEmitterScalabilityOverrides {
    /* 0x0000 */ TArray<FNiagaraEmitterScalabilityOverride> Overrides;
};

// Size: 0x38
struct FNiagaraEmitterScalabilitySettings {
    /* 0x0000 */ FNiagaraPlatformSet Platforms;
    /* 0x0030 */ bool bScaleSpawnCount;
    /* 0x0034 */ float SpawnCountScale;
};

// Size: 0x10
struct FNiagaraEmitterScalabilitySettingsArray {
    /* 0x0000 */ TArray<FNiagaraEmitterScalabilitySettings> Settings;
};

// Size: 0x28
struct FNiagaraEmitterScriptProperties {
    /* 0x0000 */ UNiagaraScript* Script;
    /* 0x0008 */ TArray<FNiagaraEventReceiverProperties> EventReceivers;
    /* 0x0018 */ TArray<FNiagaraEventGeneratorProperties> EventGenerators;
};

// Size: 0x90
struct FNiagaraEmitterStateData {
    /* 0x0000 */ ENiagaraEmitterInactiveResponse InactiveResponse;
    /* 0x0001 */ ENiagaraLoopBehavior LoopBehavior;
    /* 0x0004 */ int32_t LoopCount;
    /* 0x0008 */ ENiagaraLoopDurationMode LoopDurationMode;
    /* 0x0010 */ FNiagaraDistributionRangeFloat LoopDuration;
    /* 0x0040 */ FNiagaraDistributionRangeFloat LoopDelay;
    /* 0x0070 */ bool bLoopDelayEnabled;
    /* 0x0070 */ bool bRecalculateDurationEachLoop;
    /* 0x0070 */ bool bDelayFirstLoopOnly;
    /* 0x0070 */ bool bRecalculateDelayEachLoop;
    /* 0x0070 */ bool bEnableDistanceCulling;
    /* 0x0070 */ bool bEnableVisibilityCulling;
    /* 0x0070 */ bool bMinDistanceEnabled;
    /* 0x0070 */ bool bMaxDistanceEnabled;
    /* 0x0071 */ bool bResetAgeOnAwaken;
    /* 0x0074 */ float MinDistance;
    /* 0x0078 */ ENiagaraExecutionStateManagement MinDistanceReaction;
    /* 0x007c */ float MaxDistance;
    /* 0x0080 */ ENiagaraExecutionStateManagement MaxDistanceReaction;
    /* 0x0084 */ ENiagaraExecutionStateManagement VisibilityCullReaction;
    /* 0x0088 */ float VisibilityCullDelay;
};

// Size: 0x28
struct FNiagaraEnumParameterMetaData {
    /* 0x0000 */ FName OverrideName;
    /* 0x0008 */ UTexture2D* IconOverride;
    /* 0x0010 */ bool bUseColorOverride;
    /* 0x0014 */ FLinearColor ColorOverride;
};

// Size: 0x58
struct FNiagaraEventGeneratorProperties {
    /* 0x0000 */ int32_t MaxEventsPerFrame;
    /* 0x0004 */ FName ID;
    /* 0x0010 */ FNiagaraDataSetCompiledData DataSetCompiledData;
};

// Size: 0x28
class UNiagaraEventReceiverEmitterAction : public UObject {
};

// Size: 0x30
class UNiagaraEventReceiverEmitterAction_SpawnParticles : public UNiagaraEventReceiverEmitterAction {
    /* 0x0028 */ uint32_t NumParticles;
};

// Size: 0x18
struct FNiagaraEventReceiverProperties {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName SourceEventGenerator;
    /* 0x0010 */ FName SourceEmitter;
};

// Size: 0x58
struct FNiagaraEventScriptProperties : public FNiagaraEmitterScriptProperties {
    /* 0x0028 */ EScriptExecutionMode ExecutionMode;
    /* 0x002c */ uint32_t SpawnNumber;
    /* 0x0030 */ uint32_t MaxEventsPerFrame;
    /* 0x0034 */ FGuid SourceEmitterID;
    /* 0x0044 */ FName SourceEventName;
    /* 0x004c */ bool bRandomSpawnNumber;
    /* 0x0050 */ uint32_t MinSpawnNumber;
    /* 0x0054 */ bool UpdateAttributeInitialValues;
};

// Size: 0x14
struct FNiagaraExternalUObjectInfo {
    /* 0x0000 */ FNiagaraVariableBase Variable;
    /* 0x000c */ FName externalName;
};

// Size: 0x4
struct FNiagaraFloat {
    /* 0x0000 */ float Value;
};

// Size: 0x28
class UNiagaraFunctionLibrary : public UBlueprintFunctionLibrary {

    static int32_t AcquireNiagaraGPURayTracedCollisionGroup(UObject* WorldContextObject);
    static UNiagaraParameterCollectionInstance* GetNiagaraParameterCollection(UObject* WorldContextObject, UNiagaraParameterCollection* Collection);
    static void OverrideSystemUserVariableSkeletalMeshComponent(UNiagaraComponent* NiagaraSystem, FString OverrideName, USkeletalMeshComponent* SkeletalMeshComponent);
    static void OverrideSystemUserVariableStaticMesh(UNiagaraComponent* NiagaraSystem, FString OverrideName, UStaticMesh* StaticMesh);
    static void OverrideSystemUserVariableStaticMeshComponent(UNiagaraComponent* NiagaraSystem, FString OverrideName, UStaticMeshComponent* StaticMeshComponent);
    static void ReleaseNiagaraGPURayTracedCollisionGroup(UObject* WorldContextObject, int32_t CollisionGroup);
    static void SetActorNiagaraGPURayTracedCollisionGroup(UObject* WorldContextObject, AActor* Actor, int32_t CollisionGroup);
    static void SetComponentNiagaraGPURayTracedCollisionGroup(UObject* WorldContextObject, UPrimitiveComponent* Primitive, int32_t CollisionGroup);
    static void SetSceneCapture2DDataInterfaceManagedMode(UNiagaraComponent* NiagaraSystem, const FName& DIName, uint8_t ManagedCaptureSource, FIntPoint ManagedTextureSize, uint8_t ManagedTextureFormat, uint8_t ManagedProjectionType, float ManagedFOVAngle, float ManagedOrthoWidth, bool bManagedCaptureEveryFrame, bool bManagedCaptureOnMovement, const TArray<AActor*>& ShowOnlyActors);
    static void SetSkeletalMeshDataInterfaceFilteredBones(UNiagaraComponent* NiagaraSystem, FString OverrideName, const TArray<FName>& FilteredBones);
    static void SetSkeletalMeshDataInterfaceFilteredSockets(UNiagaraComponent* NiagaraSystem, FString OverrideName, const TArray<FName>& FilteredSockets);
    static void SetSkeletalMeshDataInterfaceSamplingRegions(UNiagaraComponent* NiagaraSystem, FString OverrideName, const TArray<FName>& SamplingRegions);
    static void SetTexture2DArrayObject(UNiagaraComponent* NiagaraSystem, FString OverrideName, UTexture2DArray* Texture);
    static void SetTextureObject(UNiagaraComponent* NiagaraSystem, FString OverrideName, UTexture* Texture);
    static void SetVolumeTextureObject(UNiagaraComponent* NiagaraSystem, FString OverrideName, UVolumeTexture* Texture);
    static UNiagaraComponent* SpawnSystemAtLocation(const UObject* WorldContextObject, UNiagaraSystem* SystemTemplate, FVector Location, FRotator Rotation, FVector Scale, bool bAutoDestroy, bool bAutoActivate, ENCPoolMethod PoolingMethod, bool bPreCullCheck);
    static UNiagaraComponent* SpawnSystemAtLocationWithParams(const FFXSystemSpawnParameters& SpawnParams);
    static UNiagaraComponent* SpawnSystemAttached(UNiagaraSystem* SystemTemplate, USceneComponent* AttachToComponent, FName AttachPointName, FVector Location, FRotator Rotation, uint8_t LocationType, bool bAutoDestroy, bool bAutoActivate, ENCPoolMethod PoolingMethod, bool bPreCullCheck);
    static UNiagaraComponent* SpawnSystemAttachedWithParams(const FFXSystemSpawnParameters& SpawnParams);
};

// Size: 0x98
struct FNiagaraFunctionSignature {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ TArray<FNiagaraVariable> Inputs;
    /* 0x0018 */ TArray<FNiagaraVariableBase> Outputs;
    /* 0x0028 */ FName OwnerName;
    /* 0x0030 */ bool bRequiresContext;
    /* 0x0030 */ bool bRequiresExecPin;
    /* 0x0030 */ bool bMemberFunction;
    /* 0x0030 */ bool bExperimental;
    /* 0x0030 */ bool bSupportsCPU;
    /* 0x0030 */ bool bSupportsGPU;
    /* 0x0030 */ bool bWriteFunction;
    /* 0x0030 */ bool bReadFunction;
    /* 0x0031 */ bool bSoftDeprecatedFunction;
    /* 0x0031 */ bool bIsCompileTagGenerator;
    /* 0x0031 */ bool bHidden;
    /* 0x0034 */ int32_t ModuleUsageBitmask;
    /* 0x0038 */ uint16_t MiscUsageBitMask;
    /* 0x003c */ int32_t ContextStageIndex;
    /* 0x0040 */ int16_t RequiredInputs;
    /* 0x0042 */ int16_t RequiredOutputs;
    /* 0x0048 */ TMap<FName, FName> FunctionSpecifiers;
};

// Size: 0x38
struct FNiagaraGlobalBudgetScaling {
    /* 0x0000 */ bool bCullByGlobalBudget;
    /* 0x0000 */ bool bScaleMaxDistanceByGlobalBudgetUse;
    /* 0x0000 */ bool bScaleMaxInstanceCountByGlobalBudgetUse;
    /* 0x0000 */ bool bScaleSystemInstanceCountByGlobalBudgetUse;
    /* 0x0004 */ float MaxGlobalBudgetUsage;
    /* 0x0008 */ FNiagaraLinearRamp MaxDistanceScaleByGlobalBudgetUse;
    /* 0x0018 */ FNiagaraLinearRamp MaxInstanceCountScaleByGlobalBudgetUse;
    /* 0x0028 */ FNiagaraLinearRamp MaxSystemInstanceCountScaleByGlobalBudgetUse;
};

// Size: 0x10
struct FNiagaraGraphViewSettings {
    /* 0x0000 */ FDeprecateSlateVector2D Location;
    /* 0x0008 */ float Zoom;
    /* 0x000c */ bool bIsValid;
};

// Size: 0x2
struct FNiagaraHalf {
    /* 0x0000 */ uint16_t Value;
};

// Size: 0x4
struct FNiagaraHalfVector2 {
    /* 0x0000 */ uint16_t X;
    /* 0x0002 */ uint16_t Y;
};

// Size: 0x6
struct FNiagaraHalfVector3 {
    /* 0x0000 */ uint16_t X;
    /* 0x0002 */ uint16_t Y;
    /* 0x0004 */ uint16_t Z;
};

// Size: 0x8
struct FNiagaraHalfVector4 {
    /* 0x0000 */ uint16_t X;
    /* 0x0002 */ uint16_t Y;
    /* 0x0004 */ uint16_t Z;
    /* 0x0006 */ uint16_t W;
};

// Size: 0x8
struct FNiagaraID {
    /* 0x0000 */ int32_t Index;
    /* 0x0004 */ int32_t AcquireTag;
};

// Size: 0x1
struct FNiagaraInlineDynamicInputFormatToken {
};

// Size: 0x18
struct FNiagaraInputConditionMetadata {
    /* 0x0000 */ FName InputName;
    /* 0x0008 */ TArray<FString> TargetValues;
};

// Size: 0x58
struct FNiagaraInputParameterCustomization {
    /* 0x0000 */ ENiagaraInputWidgetType WidgetType;
    /* 0x0001 */ bool bHasMinValue;
    /* 0x0004 */ float MinValue;
    /* 0x0008 */ bool bHasMaxValue;
    /* 0x000c */ float MaxValue;
    /* 0x0010 */ bool bHasStepWidth;
    /* 0x0014 */ float StepWidth;
    /* 0x0018 */ TArray<FWidgetNamedInputValue> InputDropdownValues;
    /* 0x0028 */ TArray<FNiagaraWidgetNamedIntegerInputValue> EnumStyleDropdownValues;
    /* 0x0038 */ int32_t MaxSegmentsPerRow;
    /* 0x0040 */ TArray<FWidgetSegmentValueOverride> SegmentValueOverrides;
    /* 0x0050 */ bool bBroadcastValueChangesOnCommitOnly;
};

// Size: 0x4
struct FNiagaraInt32 {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x340
class ANiagaraLensEffectBase : public ANiagaraActor {
    /* 0x02c0 */ FTransform DesiredRelativeTransform;
    /* 0x0320 */ float BaseAuthoredFOV;
    /* 0x0324 */ bool bAllowMultipleInstances;
    /* 0x0324 */ bool bResetWhenRetriggered;
    /* 0x0328 */ TArray<UClass*> EmittersToTreatAsSame;
    /* 0x0338 */ APlayerCameraManager* OwningCameraManager;
};

// Size: 0x320
class UNiagaraLightRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ ENiagaraRendererSourceDataMode SourceMode;
    /* 0x00bc */ bool bUseInverseSquaredFalloff;
    /* 0x00bc */ bool bAffectsTranslucency;
    /* 0x00bc */ bool bAlphaScalesBrightness;
    /* 0x00bc */ bool bOverrideInverseExposureBlend;
    /* 0x00c0 */ float RadiusScale;
    /* 0x00c4 */ float DefaultExponent;
    /* 0x00c8 */ float SpecularScale;
    /* 0x00cc */ float DiffuseScale;
    /* 0x00d0 */ FVector3f ColorAdd;
    /* 0x00dc */ float InverseExposureBlend;
    /* 0x00e0 */ int32_t RendererVisibility;
    /* 0x00e8 */ FNiagaraVariableAttributeBinding LightRenderingEnabledBinding;
    /* 0x0120 */ FNiagaraVariableAttributeBinding LightExponentBinding;
    /* 0x0158 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x0190 */ FNiagaraVariableAttributeBinding ColorBinding;
    /* 0x01c8 */ FNiagaraVariableAttributeBinding RadiusBinding;
    /* 0x0200 */ FNiagaraVariableAttributeBinding VolumetricScatteringBinding;
    /* 0x0238 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x0270 */ FNiagaraVariableAttributeBinding SpecularScaleBinding;
    /* 0x02a8 */ FNiagaraVariableAttributeBinding DiffuseScaleBinding;
};

// Size: 0x10
struct FNiagaraLinearRamp {
    /* 0x0000 */ float StartX;
    /* 0x0004 */ float StartY;
    /* 0x0008 */ float EndX;
    /* 0x000c */ float EndY;
};

// Size: 0x18
struct FNiagaraLwcStructConverter {
    /* 0x0000 */ int32_t LWCSize;
    /* 0x0004 */ int32_t SWCSize;
    /* 0x0008 */ TArray<FNiagaraStructConversionStep> ConversionSteps;
};

// Size: 0x2c
struct FNiagaraMaterialAttributeBinding {
    /* 0x0000 */ FName MaterialParameterName;
    /* 0x0008 */ FNiagaraVariableBase NiagaraVariable;
    /* 0x0014 */ FNiagaraVariableBase ResolvedNiagaraVariable;
    /* 0x0020 */ FNiagaraVariableBase NiagaraChildVariable;
};

// Size: 0x40
struct FNiagaraMatrix {
    /* 0x0000 */ FVector4f Row0;
    /* 0x0010 */ FVector4f Row1;
    /* 0x0020 */ FVector4f Row2;
    /* 0x0030 */ FVector4f Row3;
};

// Size: 0x10
struct FNiagaraMeshMICOverride {
    /* 0x0000 */ UMaterialInterface* OriginalMaterial;
    /* 0x0008 */ UMaterialInstanceConstant* ReplacementMaterial;
};

// Size: 0x28
struct FNiagaraMeshMaterialOverride {
    /* 0x0000 */ UMaterialInterface* ExplicitMat;
    /* 0x0008 */ FNiagaraUserParameterBinding UserParamBinding;
};

// Size: 0x80
struct FNiagaraMeshRendererMeshProperties : public FNiagaraMeshRendererMeshPropertiesBase {
    /* 0x0058 */ FNiagaraParameterBinding MeshParameterBinding;
    /* 0x0064 */ ENiagaraMeshLODMode LODMode;
    /* 0x0068 */ int32_t LODLevel;
    /* 0x006c */ int32_t LODBias;
    /* 0x0070 */ float LODDistanceFactor;
    /* 0x0074 */ bool bUseLODRange;
    /* 0x0078 */ FIntVector2 LODRange;
};

// Size: 0x58
struct FNiagaraMeshRendererMeshPropertiesBase {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ FVector Scale;
    /* 0x0020 */ FRotator Rotation;
    /* 0x0038 */ FVector PivotOffset;
    /* 0x0050 */ ENiagaraMeshPivotOffsetSpace PivotOffsetSpace;
};

// Size: 0x698
class UNiagaraMeshRendererProperties : public UNiagaraRendererProperties {
    /* 0x00c0 */ TArray<FNiagaraMeshRendererMeshProperties> Meshes;
    /* 0x00d0 */ FNiagaraParameterBinding MeshesBinding;
    /* 0x00dc */ ENiagaraRendererSourceDataMode SourceMode;
    /* 0x00dd */ ENiagaraSortMode SortMode;
    /* 0x00de */ ENiagaraRendererSortPrecision SortPrecision;
    /* 0x00df */ ENiagaraRendererGpuTranslucentLatency GpuTranslucentLatency;
    /* 0x00e0 */ bool bOverrideMaterials;
    /* 0x00e0 */ bool bSortOnlyWhenTranslucent;
    /* 0x00e0 */ bool bSubImageBlend;
    /* 0x00e0 */ bool bEnableFrustumCulling;
    /* 0x00e0 */ bool bEnableCameraDistanceCulling;
    /* 0x00e0 */ bool bEnableMeshFlipbook;
    /* 0x00e0 */ bool bLockedAxisEnable;
    /* 0x00e4 */ bool bCastShadows;
    /* 0x00e8 */ TArray<FNiagaraMeshMaterialOverride> OverrideMaterials;
    /* 0x00f8 */ TArray<FNiagaraMeshMICOverride> MICOverrideMaterials;
    /* 0x0108 */ FVector2D SubImageSize;
    /* 0x0118 */ FVector LockedAxis;
    /* 0x0130 */ FVector MeshBoundsScale;
    /* 0x0148 */ ENiagaraMeshFacingMode FacingMode;
    /* 0x0149 */ ENiagaraMeshLockedAxisSpace LockedAxisSpace;
    /* 0x014c */ float MinCameraDistance;
    /* 0x0150 */ float MaxCameraDistance;
    /* 0x0154 */ uint32_t RendererVisibility;
    /* 0x0158 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x0190 */ FNiagaraVariableAttributeBinding ColorBinding;
    /* 0x01c8 */ FNiagaraVariableAttributeBinding VelocityBinding;
    /* 0x0200 */ FNiagaraVariableAttributeBinding MeshOrientationBinding;
    /* 0x0238 */ FNiagaraVariableAttributeBinding ScaleBinding;
    /* 0x0270 */ FNiagaraVariableAttributeBinding SubImageIndexBinding;
    /* 0x02a8 */ FNiagaraVariableAttributeBinding DynamicMaterialBinding;
    /* 0x02e0 */ FNiagaraVariableAttributeBinding DynamicMaterial1Binding;
    /* 0x0318 */ FNiagaraVariableAttributeBinding DynamicMaterial2Binding;
    /* 0x0350 */ FNiagaraVariableAttributeBinding DynamicMaterial3Binding;
    /* 0x0388 */ FNiagaraVariableAttributeBinding MaterialRandomBinding;
    /* 0x03c0 */ FNiagaraVariableAttributeBinding CustomSortingBinding;
    /* 0x03f8 */ FNiagaraVariableAttributeBinding NormalizedAgeBinding;
    /* 0x0430 */ FNiagaraVariableAttributeBinding CameraOffsetBinding;
    /* 0x0468 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x04a0 */ FNiagaraVariableAttributeBinding MeshIndexBinding;
    /* 0x04d8 */ FNiagaraRendererMaterialParameters MaterialParameters;
    /* 0x0528 */ FNiagaraVariableAttributeBinding PrevPositionBinding;
    /* 0x0560 */ FNiagaraVariableAttributeBinding PrevScaleBinding;
    /* 0x0598 */ FNiagaraVariableAttributeBinding PrevMeshOrientationBinding;
    /* 0x05d0 */ FNiagaraVariableAttributeBinding PrevCameraOffsetBinding;
    /* 0x0608 */ FNiagaraVariableAttributeBinding PrevVelocityBinding;
    /* 0x0640 */ uint32_t MaterialParamValidMask;
};

// Size: 0x28
class UNiagaraMessageDataBase : public UObject {
};

// Size: 0x1
struct FNiagaraMessageStore {
};

// Size: 0x60
struct FNiagaraModuleDependency {
    /* 0x0000 */ FName ID;
    /* 0x0008 */ ENiagaraModuleDependencyType Type;
    /* 0x0009 */ ENiagaraModuleDependencyScriptConstraint ScriptConstraint;
    /* 0x0010 */ FString RequiredVersion;
    /* 0x0020 */ int32_t OnlyEvaluateInScriptUsage;
    /* 0x0028 */ FText Description;
};

// Size: 0x1
struct FNiagaraNumeric {
};

// Size: 0x10
struct FNiagaraOutlinerCaptureSettings {
    /* 0x0000 */ bool bTriggerCapture;
    /* 0x0004 */ uint32_t CaptureDelayFrames;
    /* 0x0008 */ bool bGatherPerfData;
    /* 0x000c */ uint32_t SimCacheCaptureFrames;
};

// Size: 0x50
struct FNiagaraOutlinerData {
    /* 0x0000 */ TMap<FString, FNiagaraOutlinerWorldData> WorldData;
};

// Size: 0x20
struct FNiagaraOutlinerEmitterInstanceData {
    /* 0x0000 */ FString EmitterName;
    /* 0x0010 */ ENiagaraSimTarget SimTarget;
    /* 0x0014 */ ENiagaraExecutionState ExecState;
    /* 0x0018 */ int32_t NumParticles;
    /* 0x001c */ bool bRequiresPersistentIDs;
};

// Size: 0x30
struct FNiagaraOutlinerSystemData {
    /* 0x0000 */ TArray<FNiagaraOutlinerSystemInstanceData> SystemInstances;
    /* 0x0010 */ FNiagaraOutlinerTimingData AveragePerFrameTime;
    /* 0x0018 */ FNiagaraOutlinerTimingData MaxPerFrameTime;
    /* 0x0020 */ FNiagaraOutlinerTimingData AveragePerInstanceTime;
    /* 0x0028 */ FNiagaraOutlinerTimingData MaxPerInstanceTime;
};

// Size: 0x68
struct FNiagaraOutlinerSystemInstanceData {
    /* 0x0000 */ FString ComponentName;
    /* 0x0010 */ FVector3f LWCTile;
    /* 0x0020 */ TArray<FNiagaraOutlinerEmitterInstanceData> Emitters;
    /* 0x0030 */ ENiagaraExecutionState ActualExecutionState;
    /* 0x0034 */ ENiagaraExecutionState RequestedExecutionState;
    /* 0x0038 */ FNiagaraScalabilityState ScalabilityState;
    /* 0x0044 */ bool bPendingKill;
    /* 0x0044 */ bool bUsingCullProxy;
    /* 0x0048 */ ENCPoolMethod PoolMethod;
    /* 0x004c */ FNiagaraOutlinerTimingData AverageTime;
    /* 0x0054 */ FNiagaraOutlinerTimingData MaxTime;
    /* 0x005c */ uint8_t TickGroup;
    /* 0x005d */ uint8_t GpuTickStage;
    /* 0x0060 */ bool bIsSolo;
    /* 0x0060 */ bool bRequiresGlobalDistanceField;
    /* 0x0060 */ bool bRequiresDepthBuffer;
    /* 0x0060 */ bool bRequiresEarlyViewData;
    /* 0x0060 */ bool bRequiresViewUniformBuffer;
    /* 0x0060 */ bool bRequiresRayTracingScene;
    /* 0x0060 */ bool bRequiresCurrentFrameNDC;
};

// Size: 0x8
struct FNiagaraOutlinerTimingData {
    /* 0x0000 */ float GameThread;
    /* 0x0004 */ float RenderThread;
};

// Size: 0x68
struct FNiagaraOutlinerWorldData {
    /* 0x0000 */ TMap<FString, FNiagaraOutlinerSystemData> Systems;
    /* 0x0050 */ bool bHasBegunPlay;
    /* 0x0051 */ uint8_t WorldType;
    /* 0x0052 */ uint8_t NetMode;
    /* 0x0054 */ FNiagaraOutlinerTimingData AveragePerFrameTime;
    /* 0x005c */ FNiagaraOutlinerTimingData MaxPerFrameTime;
};

// Size: 0xc
struct FNiagaraParameterBinding {
    /* 0x0000 */ FNiagaraVariableBase ResolvedParameter;
};

// Size: 0x20
struct FNiagaraParameterBindingWithValue : public FNiagaraParameterBinding {
    /* 0x0010 */ TArray<uint8_t> DefaultValue;
};

// Size: 0x68
class UNiagaraParameterCollection : public UObject {
    /* 0x0028 */ FName Namespace;
    /* 0x0030 */ TArray<FNiagaraVariable> Parameters;
    /* 0x0040 */ UMaterialParameterCollection* SourceMaterialCollection;
    /* 0x0048 */ UNiagaraParameterCollectionInstance* DefaultInstance;
    /* 0x0050 */ FGuid CompileId;
};

// Size: 0xf8
class UNiagaraParameterCollectionInstance : public UObject {
    /* 0x0028 */ UNiagaraParameterCollection* Collection;
    /* 0x0030 */ TArray<FNiagaraVariable> OverridenParameters;
    /* 0x0040 */ FNiagaraParameterStore ParameterStorage;
    /* 0x00c8 */ UMaterialParameterCollectionInstance* SourceMaterialCollectionInstance;

    bool GetBoolParameter(FString InVariableName);
    FLinearColor GetColorParameter(FString InVariableName);
    float GetFloatParameter(FString InVariableName);
    int32_t GetIntParameter(FString InVariableName);
    FQuat GetQuatParameter(FString InVariableName);
    FVector2D GetVector2DParameter(FString InVariableName);
    FVector4 GetVector4Parameter(FString InVariableName);
    FVector GetVectorParameter(FString InVariableName);
    void SetBoolParameter(FString InVariableName, bool InValue);
    void SetColorParameter(FString InVariableName, FLinearColor InValue);
    void SetFloatParameter(FString InVariableName, float InValue);
    void SetIntParameter(FString InVariableName, int32_t InValue);
    void SetQuatParameter(FString InVariableName, const FQuat& InValue);
    void SetVector2DParameter(FString InVariableName, FVector2D InValue);
    void SetVector4Parameter(FString InVariableName, const FVector4& InValue);
    void SetVectorParameter(FString InVariableName, FVector InValue);
};

// Size: 0x8
struct FNiagaraParameterDataSetBinding {
    /* 0x0000 */ int32_t ParameterOffset;
    /* 0x0004 */ int32_t DataSetComponentOffset;
};

// Size: 0x20
struct FNiagaraParameterDataSetBindingCollection {
    /* 0x0000 */ TArray<FNiagaraParameterDataSetBinding> FloatOffsets;
    /* 0x0010 */ TArray<FNiagaraParameterDataSetBinding> Int32Offsets;
};

// Size: 0x28
class UNiagaraParameterDefinitionsBase : public UObject {
};

// Size: 0x1
struct FNiagaraParameterMap {
};

// Size: 0x88
struct FNiagaraParameterStore {
    /* 0x0008 */ TWeakObjectPtr<UObject> Owner;
    /* 0x0010 */ TArray<FNiagaraVariableWithOffset> SortedParameterOffsets;
    /* 0x0020 */ TArray<uint8_t> ParameterData;
    /* 0x0030 */ TArray<UNiagaraDataInterface*> DataInterfaces;
    /* 0x0040 */ TArray<UObject*> UObjects;
    /* 0x0050 */ TArray<FNiagaraPositionSource> OriginalPositionData;
};

// Size: 0x10
struct FNiagaraParameters {
    /* 0x0000 */ TArray<FNiagaraVariable> Parameters;
};

// Size: 0x28
class INiagaraParticleCallbackHandler : public UInterface {

    void ReceiveParticleData(const TArray<FBasicParticleData>& Data, UNiagaraSystem* NiagaraSystem, const FVector& SimulationPositionOffset);
};

// Size: 0x2b8
class ANiagaraPerfBaselineActor : public AActor {
    /* 0x02a8 */ UNiagaraBaselineController* Controller;
    /* 0x02b0 */ UTextRenderComponent* Label;
};

// Size: 0x10
struct FNiagaraPerfBaselineStats {
    /* 0x0000 */ float PerInstanceAvg_GT;
    /* 0x0004 */ float PerInstanceAvg_RT;
    /* 0x0008 */ float PerInstanceMax_GT;
    /* 0x000c */ float PerInstanceMax_RT;
};

// Size: 0x28
class INiagaraPhysicsAssetDICollectorInterface : public UInterface {
};

// Size: 0x30
struct FNiagaraPlatformSet {
    /* 0x0000 */ TArray<FNiagaraDeviceProfileStateEntry> DeviceProfileStates;
    /* 0x0010 */ TArray<FNiagaraPlatformSetCVarCondition> CVarConditions;
    /* 0x0020 */ int32_t QualityLevelMask;
};

// Size: 0x30
struct FNiagaraPlatformSetCVarCondition {
    /* 0x0000 */ FName CVarName;
    /* 0x0008 */ ENiagaraCVarConditionResponse PassResponse;
    /* 0x0009 */ ENiagaraCVarConditionResponse FailResponse;
    /* 0x000a */ bool Value;
    /* 0x000c */ int32_t MinInt;
    /* 0x0010 */ int32_t MaxInt;
    /* 0x0014 */ float MinFloat;
    /* 0x0018 */ float MaxFloat;
    /* 0x001c */ bool bUseMinInt;
    /* 0x001c */ bool bUseMaxInt;
    /* 0x001c */ bool bUseMinFloat;
    /* 0x001c */ bool bUseMaxFloat;
};

// Size: 0xc
struct FNiagaraPlatformSetConflictEntry {
    /* 0x0000 */ FName ProfileName;
    /* 0x0008 */ int32_t QualityLevelMask;
};

// Size: 0x18
struct FNiagaraPlatformSetConflictInfo {
    /* 0x0000 */ int32_t SetAIndex;
    /* 0x0004 */ int32_t SetBIndex;
    /* 0x0008 */ TArray<FNiagaraPlatformSetConflictEntry> conflicts;
};

// Size: 0x80
struct FNiagaraPlatformSetRedirect {
    /* 0x0000 */ TArray<FName> ProfileNames;
    /* 0x0010 */ ENiagaraDeviceProfileRedirectMode Mode;
    /* 0x0014 */ FName RedirectProfileName;
    /* 0x0020 */ FNiagaraPlatformSetCVarCondition CVarConditionEnabled;
    /* 0x0050 */ FNiagaraPlatformSetCVarCondition CVarConditionDisabled;
};

// Size: 0xc
struct FNiagaraPosition : public FVector3f {
};

// Size: 0x20
struct FNiagaraPositionSource {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FVector Value;
};

// Size: 0x40
class UNiagaraPrecompileContainer : public UObject {
    /* 0x0028 */ TArray<UNiagaraScript*> Scripts;
    /* 0x0038 */ UNiagaraSystem* System;
};

// Size: 0x28
class UNiagaraPreviewAxis : public UObject {

    void ApplyToPreview(UNiagaraComponent* PreviewComponent, int32_t PreviewIndex, bool bIsXAxis, FString& OutLabelText);
    int32_t Num();
};

// Size: 0x38
class UNiagaraPreviewAxis_InterpParamBase : public UNiagaraPreviewAxis {
    /* 0x0028 */ FName Param;
    /* 0x0030 */ int32_t Count;
};

// Size: 0x40
class UNiagaraPreviewAxis_InterpParamFloat : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0038 */ float min;
    /* 0x003c */ float max;
};

// Size: 0x40
class UNiagaraPreviewAxis_InterpParamInt32 : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0038 */ int32_t min;
    /* 0x003c */ int32_t max;
};

// Size: 0x58
class UNiagaraPreviewAxis_InterpParamLinearColor : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0038 */ FLinearColor min;
    /* 0x0048 */ FLinearColor max;
};

// Size: 0x68
class UNiagaraPreviewAxis_InterpParamVector : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0038 */ FVector min;
    /* 0x0050 */ FVector max;
};

// Size: 0x58
class UNiagaraPreviewAxis_InterpParamVector2D : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0038 */ FVector2D min;
    /* 0x0048 */ FVector2D max;
};

// Size: 0x80
class UNiagaraPreviewAxis_InterpParamVector4 : public UNiagaraPreviewAxis_InterpParamBase {
    /* 0x0040 */ FVector4 min;
    /* 0x0060 */ FVector4 max;
};

// Size: 0x2a8
class ANiagaraPreviewBase : public AActor {

    void SetLabelText(const FText& InXAxisText, const FText& InYAxisText);
    void SetSystem(UNiagaraSystem* InSystem);
};

// Size: 0x2f8
class ANiagaraPreviewGrid : public AActor {
    /* 0x02a8 */ UNiagaraSystem* System;
    /* 0x02b0 */ ENiagaraPreviewGridResetMode ResetMode;
    /* 0x02b8 */ UNiagaraPreviewAxis* PreviewAxisX;
    /* 0x02c0 */ UNiagaraPreviewAxis* PreviewAxisY;
    /* 0x02c8 */ UClass* PreviewClass;
    /* 0x02d0 */ float SpacingX;
    /* 0x02d4 */ float SpacingY;
    /* 0x02d8 */ int32_t NumX;
    /* 0x02dc */ int32_t NumY;
    /* 0x02e0 */ TArray<UChildActorComponent*> PreviewComponents;

    void ActivatePreviews(bool bReset);
    void DeactivatePreviews();
    void GetPreviews(TArray<UNiagaraComponent*>& OutPreviews);
    void SetPaused(bool bPaused);
};

// Size: 0xc
struct FNiagaraRandInfo {
    /* 0x0000 */ int32_t Seed1;
    /* 0x0004 */ int32_t Seed2;
    /* 0x0008 */ int32_t Seed3;
};

// Size: 0x28
class INiagaraRenderableMeshArrayInterface : public UInterface {
};

// Size: 0x28
class INiagaraRenderableMeshInterface : public UInterface {
};

// Size: 0x50
struct FNiagaraRendererMaterialParameters {
    /* 0x0000 */ TArray<FNiagaraMaterialAttributeBinding> AttributeBindings;
    /* 0x0010 */ TArray<FNiagaraRendererMaterialScalarParameter> ScalarParameters;
    /* 0x0020 */ TArray<FNiagaraRendererMaterialVectorParameter> VectorParameters;
    /* 0x0030 */ TArray<FNiagaraRendererMaterialTextureParameter> TextureParameters;
    /* 0x0040 */ TArray<FNiagaraRendererMaterialStaticBoolParameter> StaticBoolParameters;
};

// Size: 0xc
struct FNiagaraRendererMaterialScalarParameter {
    /* 0x0000 */ FName MaterialParameterName;
    /* 0x0008 */ float Value;
};

// Size: 0x14
struct FNiagaraRendererMaterialStaticBoolParameter {
    /* 0x0000 */ FName MaterialParameterName;
    /* 0x0008 */ FName StaticVariableName;
    /* 0x0010 */ TOptional<bool> StaticValue;
};

// Size: 0x10
struct FNiagaraRendererMaterialTextureParameter {
    /* 0x0000 */ FName MaterialParameterName;
    /* 0x0008 */ UTexture* Texture;
};

// Size: 0x18
struct FNiagaraRendererMaterialVectorParameter {
    /* 0x0000 */ FName MaterialParameterName;
    /* 0x0008 */ FLinearColor Value;
};

// Size: 0xb8
class UNiagaraRendererProperties : public UNiagaraMergeable {
    /* 0x0028 */ FNiagaraPlatformSet Platforms;
    /* 0x0058 */ int32_t SortOrderHint;
    /* 0x005c */ ENiagaraRendererMotionVectorSetting MotionVectorSetting;
    /* 0x005d */ bool bIsEnabled;
    /* 0x005e */ bool bAllowInCullProxies;
    /* 0x0060 */ FNiagaraVariableAttributeBinding RendererEnabledBinding;
    /* 0x0098 */ FGuid OuterEmitterVersion;
};

// Size: 0x14
struct FNiagaraRendererReadbackParameters {
    /* 0x0000 */ bool bExportPosition;
    /* 0x0001 */ bool bExportTangentBasis;
    /* 0x0002 */ bool bExportColor;
    /* 0x0004 */ int32_t ExportNumTexCoords;
    /* 0x0008 */ bool bExportMaterials;
    /* 0x0009 */ bool bApplyWPO;
    /* 0x000c */ TOptional<int32_t> ViewIndexToCapture;
};

// Size: 0x1
struct FNiagaraRequestSimpleClientInfoMessage {
};

// Size: 0x20
struct FNiagaraResolvedUObjectInfo {
    /* 0x0000 */ FName ReadVariableName;
    /* 0x0008 */ FNiagaraVariableBase ResolvedVariable;
    /* 0x0018 */ UObject* Object;
};

// Size: 0x8
struct FNiagaraResolvedUserDataInterfaceBinding {
    /* 0x0000 */ int32_t UserParameterStoreDataInterfaceIndex;
    /* 0x0004 */ int32_t ScriptParameterStoreDataInterfaceIndex;
};

// Size: 0x760
class UNiagaraRibbonRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ UMaterialInterface* Material;
    /* 0x00c0 */ FNiagaraUserParameterBinding MaterialUserParamBinding;
    /* 0x00e0 */ FNiagaraRibbonUVSettings UV0Settings;
    /* 0x0108 */ FNiagaraRibbonUVSettings UV1Settings;
    /* 0x0130 */ ENiagaraRibbonFacingMode FacingMode;
    /* 0x0134 */ int32_t MaxNumRibbons;
    /* 0x0138 */ ENiagaraRibbonDrawDirection DrawDirection;
    /* 0x0139 */ ENiagaraRibbonShapeMode Shape;
    /* 0x013a */ bool bEnableAccurateGeometry;
    /* 0x013a */ bool bUseMaterialBackfaceCulling;
    /* 0x013a */ bool bUseGeometryNormals;
    /* 0x013a */ bool bUseGPUInit;
    /* 0x013a */ bool bUseConstantFactor;
    /* 0x013a */ bool bScreenSpaceTessellation;
    /* 0x013a */ bool bLinkOrderUseUniqueID;
    /* 0x013a */ bool bCastShadows;
    /* 0x013c */ int32_t WidthSegmentationCount;
    /* 0x0140 */ int32_t MultiPlaneCount;
    /* 0x0144 */ int32_t TubeSubdivisions;
    /* 0x0148 */ TArray<FNiagaraRibbonShapeCustomVertex> CustomVertices;
    /* 0x0158 */ ENiagaraRibbonTessellationMode TessellationMode;
    /* 0x015c */ float CurveTension;
    /* 0x0160 */ int32_t TessellationFactor;
    /* 0x0164 */ float TessellationAngle;
    /* 0x0168 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x01a0 */ FNiagaraVariableAttributeBinding ColorBinding;
    /* 0x01d8 */ FNiagaraVariableAttributeBinding VelocityBinding;
    /* 0x0210 */ FNiagaraVariableAttributeBinding NormalizedAgeBinding;
    /* 0x0248 */ FNiagaraVariableAttributeBinding RibbonTwistBinding;
    /* 0x0280 */ FNiagaraVariableAttributeBinding RibbonWidthBinding;
    /* 0x02b8 */ FNiagaraVariableAttributeBinding RibbonFacingBinding;
    /* 0x02f0 */ FNiagaraVariableAttributeBinding RibbonIdBinding;
    /* 0x0328 */ FNiagaraVariableAttributeBinding RibbonLinkOrderBinding;
    /* 0x0360 */ FNiagaraVariableAttributeBinding MaterialRandomBinding;
    /* 0x0398 */ FNiagaraVariableAttributeBinding DynamicMaterialBinding;
    /* 0x03d0 */ FNiagaraVariableAttributeBinding DynamicMaterial1Binding;
    /* 0x0408 */ FNiagaraVariableAttributeBinding DynamicMaterial2Binding;
    /* 0x0440 */ FNiagaraVariableAttributeBinding DynamicMaterial3Binding;
    /* 0x0478 */ FNiagaraVariableAttributeBinding RibbonUVDistance;
    /* 0x04b0 */ FNiagaraVariableAttributeBinding U0OverrideBinding;
    /* 0x04e8 */ FNiagaraVariableAttributeBinding V0RangeOverrideBinding;
    /* 0x0520 */ FNiagaraVariableAttributeBinding U1OverrideBinding;
    /* 0x0558 */ FNiagaraVariableAttributeBinding V1RangeOverrideBinding;
    /* 0x0590 */ FNiagaraRendererMaterialParameters MaterialParameters;
    /* 0x05e0 */ FNiagaraVariableAttributeBinding PrevPositionBinding;
    /* 0x0618 */ FNiagaraVariableAttributeBinding PrevRibbonWidthBinding;
    /* 0x0650 */ FNiagaraVariableAttributeBinding PrevRibbonFacingBinding;
    /* 0x0688 */ FNiagaraVariableAttributeBinding PrevRibbonTwistBinding;
    /* 0x06c0 */ uint32_t MaterialParamValidMask;
};

// Size: 0x14
struct FNiagaraRibbonShapeCustomVertex {
    /* 0x0000 */ FVector2f position;
    /* 0x0008 */ FVector2f Normal;
    /* 0x0010 */ float TextureV;
};

// Size: 0x28
struct FNiagaraRibbonUVSettings {
    /* 0x0000 */ ENiagaraRibbonUVDistributionMode DistributionMode;
    /* 0x0001 */ ENiagaraRibbonUVEdgeMode LeadingEdgeMode;
    /* 0x0002 */ ENiagaraRibbonUVEdgeMode TrailingEdgeMode;
    /* 0x0003 */ bool bEnablePerParticleUOverride;
    /* 0x0003 */ bool bEnablePerParticleVRangeOverride;
    /* 0x0004 */ float TilingLength;
    /* 0x0008 */ FVector2D Offset;
    /* 0x0018 */ FVector2D Scale;
};

// Size: 0xe0
struct FNiagaraScalabilityManager {
    /* 0x0000 */ UNiagaraEffectType* EffectType;
    /* 0x0008 */ TArray<UNiagaraComponent*> ManagedComponents;
};

// Size: 0xc
struct FNiagaraScalabilityState {
    /* 0x0000 */ float Significance;
    /* 0x0004 */ float LastVisibleTime;
    /* 0x000a */ bool bNewlyRegistered;
    /* 0x000a */ bool bNewlyRegisteredDirty;
    /* 0x000a */ bool bCulled;
    /* 0x000a */ bool bPreviousCulled;
    /* 0x000a */ bool bCulledByDistance;
    /* 0x000a */ bool bCulledByInstanceCount;
    /* 0x000a */ bool bCulledByVisibility;
    /* 0x000a */ bool bCulledByGlobalBudget;
};

// Size: 0x28
class UNiagaraScratchPadContainer : public UObject {
};

// Size: 0x390
class UNiagaraScript : public UNiagaraScriptBase {
    /* 0x0030 */ ENiagaraScriptUsage Usage;
    /* 0x0034 */ FGuid UsageId;
    /* 0x0048 */ FNiagaraParameterStore RapidIterationParameters;
    /* 0x00d0 */ FNiagaraScriptExecutionParameterStore ScriptExecutionParamStore;
    /* 0x0160 */ TArray<FNiagaraBoundParameter> ScriptExecutionBoundParameters;
    /* 0x0170 */ FNiagaraVMExecutableDataId CachedScriptVMId;
    /* 0x01a8 */ FNiagaraVMExecutableData CachedScriptVM;
    /* 0x0348 */ TArray<UNiagaraParameterCollection*> CachedParameterCollectionReferences;
    /* 0x0358 */ TArray<FNiagaraScriptResolvedDataInterfaceInfo> ResolvedDataInterfaces;
    /* 0x0368 */ TArray<FNiagaraResolvedUserDataInterfaceBinding> ResolvedUserDataInterfaceBindings;
    /* 0x0378 */ TArray<FNiagaraResolvedUObjectInfo> ResolvedUObjectInfos;

    void RaiseOnGPUCompilationComplete();
};

// Size: 0xe0
struct FNiagaraScriptAsyncCompileData {
    /* 0x0080 */ TArray<FNiagaraVariable> RapidIterationParameters;
    /* 0x0090 */ TMap<FName, UNiagaraDataInterface*> NamedDataInterfaces;
};

// Size: 0x50
struct FNiagaraScriptDataInterfaceCompileInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t UserPtrIdx;
    /* 0x0010 */ FNiagaraTypeDefinition Type;
    /* 0x0028 */ FName RegisteredParameterMapRead;
    /* 0x0030 */ FName RegisteredParameterMapWrite;
    /* 0x0038 */ bool bIsPlaceholder;
    /* 0x0040 */ FString SourceEmitterName;
};

// Size: 0x58
struct FNiagaraScriptDataInterfaceInfo {
    /* 0x0000 */ UNiagaraDataInterface* DataInterface;
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName CompileName;
    /* 0x0018 */ int32_t UserPtrIdx;
    /* 0x0020 */ FNiagaraTypeDefinition Type;
    /* 0x0038 */ FName RegisteredParameterMapRead;
    /* 0x0040 */ FName RegisteredParameterMapWrite;
    /* 0x0048 */ FString SourceEmitterName;
};

// Size: 0x1
struct FNiagaraScriptDataUsageInfo {
    /* 0x0000 */ bool bReadsAttributeData;
};

// Size: 0x8
struct FNiagaraScriptExecutionPaddingInfo {
    /* 0x0000 */ uint16_t SrcOffset;
    /* 0x0002 */ uint16_t DestOffset;
    /* 0x0004 */ uint16_t SrcSize;
    /* 0x0006 */ uint16_t DestSize;
};

// Size: 0x90
struct FNiagaraScriptExecutionParameterStore : public FNiagaraParameterStore {
    /* 0x0088 */ int32_t ParameterSize;
    /* 0x008c */ bool bInitialized;
};

// Size: 0x20
struct FNiagaraScriptHighlight {
    /* 0x0000 */ FLinearColor Color;
    /* 0x0010 */ FText DisplayName;
};

// Size: 0x98
struct FNiagaraScriptInstanceParameterStore : public FNiagaraParameterStore {
};

// Size: 0x50
struct FNiagaraScriptResolvedDataInterfaceInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName CompileName;
    /* 0x0010 */ FString ResolvedSourceEmitterName;
    /* 0x0020 */ FNiagaraVariableBase ResolvedVariable;
    /* 0x002c */ FNiagaraVariableBase ParameterStoreVariable;
    /* 0x0038 */ bool bIsInternal;
    /* 0x0040 */ UNiagaraDataInterface* ResolvedDataInterface;
    /* 0x0048 */ int32_t UserPtrIdx;
};

// Size: 0x48
class UNiagaraScriptSourceBase : public UObject {
};

// Size: 0x50
struct FNiagaraScriptUObjectCompileInfo {
    /* 0x0000 */ FNiagaraVariableBase Variable;
    /* 0x0010 */ UObject* Object;
    /* 0x0018 */ FSoftObjectPath ObjectPath;
    /* 0x0038 */ FName RegisteredParameterMapRead;
    /* 0x0040 */ TArray<FName> RegisteredParameterMapWrites;
};

// Size: 0x8
struct FNiagaraScriptVariableBinding {
    /* 0x0000 */ FName Name;
};

// Size: 0x130
class UNiagaraSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bSystemsSupportLargeWorldCoordinates;
    /* 0x0039 */ ENiagaraLwcTileUpdateMode LargeWorldCoordinateTileUpdateMode;
    /* 0x003c */ uint32_t LargeWorldCoordinateMaxTilesBeforeReset;
    /* 0x0040 */ bool bEnforceStrictStackTypes;
    /* 0x0041 */ bool bAccurateQuatInterpolation;
    /* 0x0042 */ ENiagaraCompileErrorSeverity InvalidNamespaceWriteSeverity;
    /* 0x0043 */ bool bLimitDeltaTime;
    /* 0x0044 */ float MaxDeltaTimePerTick;
    /* 0x0048 */ FSoftObjectPath DefaultEffectType;
    /* 0x0068 */ bool bAllowCreateActorFromSystemWithNoEffectType;
    /* 0x006c */ FLinearColor PositionPinTypeColor;
    /* 0x007c */ ENiagaraStripScriptByteCodeOption ByteCodeStripOption;
    /* 0x0080 */ TArray<FText> QualityLevels;
    /* 0x0090 */ TMap<FString, FText> ComponentRendererWarningsPerClass;
    /* 0x00e0 */ uint8_t DefaultRenderTargetFormat;
    /* 0x00e1 */ ENiagaraGpuBufferFormat DefaultGridFormat;
    /* 0x00e2 */ ENiagaraDefaultRendererMotionVectorSetting DefaultRendererMotionVectorSetting;
    /* 0x00e3 */ ENiagaraDefaultRendererPixelCoverageMode DefaultPixelCoverageMode;
    /* 0x00e4 */ ENiagaraDefaultSortPrecision DefaultSortPrecision;
    /* 0x00e5 */ ENiagaraDefaultGpuTranslucentLatency DefaultGpuTranslucentLatency;
    /* 0x00e8 */ float DefaultLightInverseExposureBlend;
    /* 0x00ec */ bool NDISkelMesh_SupportReadingDeformedGeometry;
    /* 0x00ed */ bool NDISkelMesh_Support16BitIndexWeight;
    /* 0x00ee */ uint8_t NDISkelMesh_GpuMaxInfluences;
    /* 0x00ef */ uint8_t NDISkelMesh_GpuUniformSamplingFormat;
    /* 0x00f0 */ uint8_t NDISkelMesh_AdjacencyTriangleIndexFormat;
    /* 0x00f1 */ bool NDIStaticMesh_AllowDistanceFields;
    /* 0x00f8 */ TArray<uint8_t> NDICollisionQuery_AsyncGpuTraceProviderOrder;
    /* 0x0108 */ FString SimCacheAuxiliaryFileBasePath;
    /* 0x0118 */ int64_t SimCacheMaxCPUMemoryVolumetrics;
    /* 0x0120 */ TArray<FNiagaraPlatformSetRedirect> PlatformSetRedirects;
};

// Size: 0x28
class UNiagaraSignificanceHandler : public UObject {
};

// Size: 0x28
class UNiagaraSignificanceHandlerAge : public UNiagaraSignificanceHandler {
};

// Size: 0x28
class UNiagaraSignificanceHandlerDistance : public UNiagaraSignificanceHandler {
};

// Size: 0x210
class UNiagaraSimCache : public UObject {
    /* 0x0028 */ FGuid CacheGuid;
    /* 0x0038 */ TSoftObjectPtr<UNiagaraSystem> SoftNiagaraSystem;
    /* 0x0060 */ float StartSeconds;
    /* 0x0064 */ float DurationSeconds;
    /* 0x0068 */ FNiagaraSimCacheCreateParameters CreateParameters;
    /* 0x00c0 */ bool bNeedsReadComponentMappingRecache;
    /* 0x00c8 */ FNiagaraSimCacheLayout CacheLayout;
    /* 0x0190 */ TArray<FNiagaraSimCacheFrame> CacheFrames;
    /* 0x01a0 */ TMap<FNiagaraVariableBase, UObject*> DataInterfaceStorage;
    /* 0x01f0 */ UNiagaraSimCacheDebugData* DebugData;

    ENiagaraSimCacheAttributeCaptureMode GetAttributeCaptureMode() const;
    FName GetEmitterName(int32_t EmitterIndex) const;
    TArray<FName> GetEmitterNames() const;
    int32_t GetNumEmitters() const;
    int32_t GetNumFrames() const;
    float GetStartSeconds() const;
    bool IsCacheValid() const;
    bool IsEmpty() const;
    void ReadColorAttribute(TArray<FLinearColor>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    UObject* ReadDataInterfaceAs(UClass* RequestedType, FName AttributeName, int32_t FrameIndex) const;
    void ReadFloatAttribute(TArray<float>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadIDAttribute(TArray<FNiagaraID>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadIntAttribute(TArray<int32_t>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadPositionAttribute(TArray<FVector>& OutValues, FName AttributeName, FName EmitterName, bool bLocalSpaceToWorld, int32_t FrameIndex) const;
    void ReadPositionAttributeWithRebase(TArray<FVector>& OutValues, FTransform Transform, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadQuatAttribute(TArray<FQuat>& OutValues, FName AttributeName, FName EmitterName, bool bLocalSpaceToWorld, int32_t FrameIndex) const;
    void ReadQuatAttributeWithRebase(TArray<FQuat>& OutValues, FQuat Quat, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadVector2Attribute(TArray<FVector2D>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadVector4Attribute(TArray<FVector4>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
    void ReadVectorAttribute(TArray<FVector>& OutValues, FName AttributeName, FName EmitterName, int32_t FrameIndex) const;
};

// Size: 0x1c
struct FNiagaraSimCacheCaptureParameters {
    /* 0x0000 */ bool bAppendToSimCache;
    /* 0x0000 */ bool bCaptureFixedNumberOfFrames;
    /* 0x0004 */ int32_t NumFrames;
    /* 0x0008 */ int32_t CaptureRate;
    /* 0x000c */ bool bUseTimeout;
    /* 0x0010 */ int32_t TimeoutFrameCount;
    /* 0x0014 */ bool bCaptureAllFramesImmediatly;
    /* 0x0018 */ float ImmediateCaptureDeltaTime;
};

// Size: 0x58
struct FNiagaraSimCacheCreateParameters {
    /* 0x0000 */ ENiagaraSimCacheAttributeCaptureMode AttributeCaptureMode;
    /* 0x0004 */ bool bAllowRebasing;
    /* 0x0004 */ bool bAllowDataInterfaceCaching;
    /* 0x0004 */ bool bAllowInterpolation;
    /* 0x0004 */ bool bAllowVelocityExtrapolation;
    /* 0x0004 */ bool bAllowSerializeLargeCache;
    /* 0x0004 */ bool bIncludeDebugData;
    /* 0x0008 */ TArray<FName> RebaseIncludeAttributes;
    /* 0x0018 */ TArray<FName> RebaseExcludeAttributes;
    /* 0x0028 */ TArray<FName> InterpolationIncludeAttributes;
    /* 0x0038 */ TArray<FName> InterpolationExcludeAttributes;
    /* 0x0048 */ TArray<FName> ExplicitCaptureAttributes;
};

// Size: 0x28
class INiagaraSimCacheCustomStorageInterface : public UInterface {
};

// Size: 0x98
struct FNiagaraSimCacheDataBuffers {
    /* 0x0000 */ uint32_t NumInstances;
    /* 0x0004 */ uint32_t IDAcquireTag;
    /* 0x0008 */ uint32_t IDToIndexTableElements;
};

// Size: 0xb8
struct FNiagaraSimCacheDataBuffersLayout {
    /* 0x0000 */ FName LayoutName;
    /* 0x0008 */ ENiagaraSimTarget SimTarget;
    /* 0x0010 */ TArray<FNiagaraSimCacheVariable> Variables;
    /* 0x0020 */ uint16_t FloatCount;
    /* 0x0022 */ uint16_t HalfCount;
    /* 0x0024 */ uint16_t Int32Count;
    /* 0x0026 */ bool bLocalSpace;
    /* 0x0027 */ bool bAllowInterpolation;
    /* 0x0028 */ bool bAllowVelocityExtrapolation;
    /* 0x0030 */ TArray<FName> RebaseVariableNames;
    /* 0x0040 */ TArray<FName> InterpVariableNames;
    /* 0x0050 */ uint16_t ComponentVelocity;
};

// Size: 0x38
class UNiagaraSimCacheDebugData : public UObject {
    /* 0x0028 */ TArray<FNiagaraSimCacheDebugDataFrame> Frames;
};

// Size: 0x50
struct FNiagaraSimCacheDebugDataFrame {
    /* 0x0000 */ TMap<FString, FNiagaraParameterStore> DebugParameterStores;
};

// Size: 0xd8
struct FNiagaraSimCacheEmitterFrame {
    /* 0x0000 */ FBox LocalBounds;
    /* 0x0038 */ int32_t TotalSpawnedParticles;
    /* 0x0040 */ FNiagaraSimCacheDataBuffers ParticleDataBuffers;
};

// Size: 0x160
struct FNiagaraSimCacheFrame {
    /* 0x0000 */ FTransform LocalToWorld;
    /* 0x0060 */ FVector3f LWCTile;
    /* 0x006c */ float SimulationAge;
    /* 0x0070 */ int32_t SimulationTickCount;
    /* 0x0078 */ FNiagaraSimCacheSystemFrame SystemData;
    /* 0x0148 */ TArray<FNiagaraSimCacheEmitterFrame> EmitterData;
};

// Size: 0x28
class UNiagaraSimCacheFunctionLibrary : public UBlueprintFunctionLibrary {

    static bool CaptureNiagaraSimCacheImmediate(UNiagaraSimCache* SimCache, FNiagaraSimCacheCreateParameters CreateParameters, UNiagaraComponent* NiagaraComponent, UNiagaraSimCache*& OutSimCache, bool bAdvanceSimulation, float AdvanceDeltaTime);
    static UNiagaraSimCache* CreateNiagaraSimCache(UObject* WorldContextObject);
};

// Size: 0xc8
struct FNiagaraSimCacheLayout {
    /* 0x0000 */ FNiagaraSimCacheDataBuffersLayout SystemLayout;
    /* 0x00b8 */ TArray<FNiagaraSimCacheDataBuffersLayout> EmitterLayouts;
};

// Size: 0xd0
struct FNiagaraSimCacheSystemFrame {
    /* 0x0000 */ FBox LocalBounds;
    /* 0x0038 */ FNiagaraSimCacheDataBuffers SystemDataBuffers;
};

// Size: 0x18
struct FNiagaraSimCacheVariable {
    /* 0x0000 */ FNiagaraVariableBase Variable;
    /* 0x000c */ uint16_t FloatOffset;
    /* 0x000e */ uint16_t FloatCount;
    /* 0x0010 */ uint16_t HalfOffset;
    /* 0x0012 */ uint16_t HalfCount;
    /* 0x0014 */ uint16_t Int32Offset;
    /* 0x0016 */ uint16_t Int32Count;
};

// Size: 0x14
struct FNiagaraSimStageExecutionLoopData {
    /* 0x0000 */ FName NumLoopsBinding;
    /* 0x0008 */ int32_t NumLoops;
    /* 0x000c */ int32_t StartStageIndex;
    /* 0x0010 */ int32_t EndStageIndex;
};

// Size: 0x1
struct FNiagaraSimStageExecutionLoopEditorData {
};

// Size: 0x40
struct FNiagaraSimpleClientInfo {
    /* 0x0000 */ TArray<FString> Systems;
    /* 0x0010 */ TArray<FString> Actors;
    /* 0x0020 */ TArray<FString> Components;
    /* 0x0030 */ TArray<FString> Emitters;
};

// Size: 0x40
class UNiagaraSimulationStageBase : public UNiagaraMergeable {
    /* 0x0028 */ UNiagaraScript* Script;
    /* 0x0030 */ FName SimulationStageName;
    /* 0x0038 */ bool bEnabled;
};

// Size: 0x1e0
class UNiagaraSimulationStageGeneric : public UNiagaraSimulationStageBase {
    /* 0x0040 */ FNiagaraVariableAttributeBinding EnabledBinding;
    /* 0x0078 */ ENiagaraIterationSource IterationSource;
    /* 0x0080 */ FNiagaraParameterBindingWithValue NumIterations;
    /* 0x00a0 */ ENiagaraSimStageExecuteBehavior ExecuteBehavior;
    /* 0x00a4 */ bool bDisablePartialParticleUpdate;
    /* 0x00a8 */ FNiagaraVariableDataInterfaceBinding DataInterface;
    /* 0x00c8 */ bool bParticleIterationStateEnabled;
    /* 0x00d0 */ FNiagaraVariableAttributeBinding ParticleIterationStateBinding;
    /* 0x0108 */ FIntPoint ParticleIterationStateRange;
    /* 0x0110 */ bool bGpuDispatchForceLinear;
    /* 0x0110 */ bool bOverrideGpuDispatchNumThreads;
    /* 0x0118 */ FNiagaraParameterBindingWithValue OverrideGpuDispatchNumThreadsX;
    /* 0x0138 */ FNiagaraParameterBindingWithValue OverrideGpuDispatchNumThreadsY;
    /* 0x0158 */ FNiagaraParameterBindingWithValue OverrideGpuDispatchNumThreadsZ;
    /* 0x0178 */ ENiagaraGpuDispatchType DirectDispatchType;
    /* 0x0179 */ ENiagaraDirectDispatchElementType DirectDispatchElementType;
    /* 0x0180 */ FNiagaraParameterBindingWithValue ElementCountX;
    /* 0x01a0 */ FNiagaraParameterBindingWithValue ElementCountY;
    /* 0x01c0 */ FNiagaraParameterBindingWithValue ElementCountZ;
};

// Size: 0x10
struct FNiagaraSpawnInfo {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ float InterpStartDt;
    /* 0x0008 */ float IntervalDt;
    /* 0x000c */ int32_t SpawnGroup;
};

// Size: 0x7c8
class UNiagaraSpriteRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ UMaterialInterface* Material;
    /* 0x00c0 */ FNiagaraUserParameterBinding MaterialUserParamBinding;
    /* 0x00e0 */ ENiagaraRendererSourceDataMode SourceMode;
    /* 0x00e1 */ ENiagaraSpriteAlignment Alignment;
    /* 0x00e2 */ ENiagaraSpriteFacingMode FacingMode;
    /* 0x00e3 */ ENiagaraSortMode SortMode;
    /* 0x00e4 */ float MacroUVRadius;
    /* 0x00e8 */ FVector2D PivotInUVSpace;
    /* 0x00f8 */ FVector2D SubImageSize;
    /* 0x0108 */ bool bSubImageBlend;
    /* 0x0108 */ bool bRemoveHMDRollInVR;
    /* 0x0108 */ bool bSortOnlyWhenTranslucent;
    /* 0x0108 */ bool bEnableCameraDistanceCulling;
    /* 0x0108 */ bool bCastShadows;
    /* 0x0109 */ ENiagaraRendererSortPrecision SortPrecision;
    /* 0x010a */ ENiagaraRendererGpuTranslucentLatency GpuTranslucentLatency;
    /* 0x010b */ ENiagaraRendererPixelCoverageMode PixelCoverageMode;
    /* 0x010c */ float PixelCoverageBlend;
    /* 0x0110 */ float MinFacingCameraBlendDistance;
    /* 0x0114 */ float MaxFacingCameraBlendDistance;
    /* 0x0118 */ float MinCameraDistance;
    /* 0x011c */ float MaxCameraDistance;
    /* 0x0120 */ uint32_t RendererVisibility;
    /* 0x0128 */ FNiagaraVariableAttributeBinding PositionBinding;
    /* 0x0160 */ FNiagaraVariableAttributeBinding ColorBinding;
    /* 0x0198 */ FNiagaraVariableAttributeBinding VelocityBinding;
    /* 0x01d0 */ FNiagaraVariableAttributeBinding SpriteRotationBinding;
    /* 0x0208 */ FNiagaraVariableAttributeBinding SpriteSizeBinding;
    /* 0x0240 */ FNiagaraVariableAttributeBinding SpriteFacingBinding;
    /* 0x0278 */ FNiagaraVariableAttributeBinding SpriteAlignmentBinding;
    /* 0x02b0 */ FNiagaraVariableAttributeBinding SubImageIndexBinding;
    /* 0x02e8 */ FNiagaraVariableAttributeBinding DynamicMaterialBinding;
    /* 0x0320 */ FNiagaraVariableAttributeBinding DynamicMaterial1Binding;
    /* 0x0358 */ FNiagaraVariableAttributeBinding DynamicMaterial2Binding;
    /* 0x0390 */ FNiagaraVariableAttributeBinding DynamicMaterial3Binding;
    /* 0x03c8 */ FNiagaraVariableAttributeBinding CameraOffsetBinding;
    /* 0x0400 */ FNiagaraVariableAttributeBinding UVScaleBinding;
    /* 0x0438 */ FNiagaraVariableAttributeBinding PivotOffsetBinding;
    /* 0x0470 */ FNiagaraVariableAttributeBinding MaterialRandomBinding;
    /* 0x04a8 */ FNiagaraVariableAttributeBinding CustomSortingBinding;
    /* 0x04e0 */ FNiagaraVariableAttributeBinding NormalizedAgeBinding;
    /* 0x0518 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x0550 */ FNiagaraRendererMaterialParameters MaterialParameters;
    /* 0x05a0 */ FNiagaraVariableAttributeBinding PrevPositionBinding;
    /* 0x05d8 */ FNiagaraVariableAttributeBinding PrevVelocityBinding;
    /* 0x0610 */ FNiagaraVariableAttributeBinding PrevSpriteRotationBinding;
    /* 0x0648 */ FNiagaraVariableAttributeBinding PrevSpriteSizeBinding;
    /* 0x0680 */ FNiagaraVariableAttributeBinding PrevSpriteFacingBinding;
    /* 0x06b8 */ FNiagaraVariableAttributeBinding PrevSpriteAlignmentBinding;
    /* 0x06f0 */ FNiagaraVariableAttributeBinding PrevCameraOffsetBinding;
    /* 0x0728 */ FNiagaraVariableAttributeBinding PrevPivotOffsetBinding;
    /* 0x0760 */ uint32_t MaterialParamValidMask;
};

// Size: 0x40
struct FNiagaraStackSection {
    /* 0x0000 */ FName SectionIdentifier;
    /* 0x0008 */ FText SectionDisplayName;
    /* 0x0018 */ TArray<FText> Categories;
    /* 0x0028 */ FText Tooltip;
    /* 0x0038 */ bool bEnabled;
};

// Size: 0x10
struct FNiagaraStatScope {
    /* 0x0000 */ FName FullName;
    /* 0x0008 */ FName FriendlyName;
};

// Size: 0x108
struct FNiagaraStatelessDynamicParameterSet {
    /* 0x0000 */ bool bXChannelEnabled;
    /* 0x0000 */ bool bYChannelEnabled;
    /* 0x0000 */ bool bZChannelEnabled;
    /* 0x0000 */ bool bWChannelEnabled;
    /* 0x0008 */ FNiagaraDistributionFloat XChannelDistribution;
    /* 0x0048 */ FNiagaraDistributionFloat YChannelDistribution;
    /* 0x0088 */ FNiagaraDistributionFloat ZChannelDistribution;
    /* 0x00c8 */ FNiagaraDistributionFloat WChannelDistribution;
};

// Size: 0x200
class UNiagaraStatelessEmitter : public UObject {
    /* 0x0038 */ FString UniqueEmitterName;
    /* 0x0048 */ UClass* EmitterTemplateClass;
    /* 0x0050 */ bool bDeterministic;
    /* 0x0054 */ uint32_t AllowedFeatureMask;
    /* 0x0058 */ int32_t RandomSeed;
    /* 0x0060 */ FBox FixedBounds;
    /* 0x0098 */ FNiagaraEmitterStateData EmitterState;
    /* 0x0128 */ TArray<FNiagaraStatelessSpawnInfo> SpawnInfos;
    /* 0x0138 */ TArray<UNiagaraStatelessModule*> Modules;
    /* 0x0148 */ TArray<UNiagaraRendererProperties*> RendererProperties;
    /* 0x0158 */ FNiagaraPlatformSet Platforms;
    /* 0x0188 */ FNiagaraEmitterScalabilityOverrides ScalabilityOverrides;
    /* 0x0198 */ FNiagaraDataSetCompiledData ParticleDataSetCompiledData;
    /* 0x01e0 */ TArray<int32_t> ComponentOffsets;
    /* 0x01f0 */ TArray<UNiagaraParameterCollection*> CachedParameterCollectionReferences;
};

// Size: 0x38
class UNiagaraStatelessEmitterDefault : public UNiagaraStatelessEmitterTemplate {
};

// Size: 0x38
class UNiagaraStatelessEmitterTemplate : public UObject {
};

// Size: 0x8
struct FNiagaraStatelessExpression {
};

// Size: 0x8
struct FNiagaraStatelessExpressionColor : public FNiagaraStatelessExpression {
};

// Size: 0x28
struct FNiagaraStatelessExpressionColorAdd : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x18
struct FNiagaraStatelessExpressionColorBinding : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FName A;
};

// Size: 0x18
struct FNiagaraStatelessExpressionColorConstant : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FLinearColor A;
};

// Size: 0x28
struct FNiagaraStatelessExpressionColorDivide : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionColorMultiply : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionColorSubtract : public FNiagaraStatelessExpressionColor {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x8
struct FNiagaraStatelessExpressionFloat : public FNiagaraStatelessExpression {
};

// Size: 0x28
struct FNiagaraStatelessExpressionFloatAdd : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x18
struct FNiagaraStatelessExpressionFloatBinding : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ FName A;
};

// Size: 0x10
struct FNiagaraStatelessExpressionFloatConstant : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ float A;
};

// Size: 0x28
struct FNiagaraStatelessExpressionFloatDivide : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionFloatMultiply : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionFloatSubtract : public FNiagaraStatelessExpressionFloat {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x8
struct FNiagaraStatelessExpressionVec2 : public FNiagaraStatelessExpression {
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec2Add : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x18
struct FNiagaraStatelessExpressionVec2Binding : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FName A;
};

// Size: 0x10
struct FNiagaraStatelessExpressionVec2Constant : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FVector2f A;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec2Divide : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec2Multiply : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec2Subtract : public FNiagaraStatelessExpressionVec2 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x8
struct FNiagaraStatelessExpressionVec3 : public FNiagaraStatelessExpression {
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec3Add : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x18
struct FNiagaraStatelessExpressionVec3Binding : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FName A;
};

// Size: 0x18
struct FNiagaraStatelessExpressionVec3Constant : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FVector3f A;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec3Divide : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec3Multiply : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec3Subtract : public FNiagaraStatelessExpressionVec3 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x8
struct FNiagaraStatelessExpressionVec4 : public FNiagaraStatelessExpression {
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec4Add : public FNiagaraStatelessExpressionVec4 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x18
struct FNiagaraStatelessExpressionVec4Binding : public FNiagaraStatelessExpressionVec4 {
    /* 0x0008 */ FName A;
};

// Size: 0x20
struct FNiagaraStatelessExpressionVec4Constant : public FNiagaraStatelessExpressionVec4 {
    /* 0x0010 */ FVector4f A;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec4Divide : public FNiagaraStatelessExpressionVec4 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec4Multiply : public FNiagaraStatelessExpressionVec4 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x28
struct FNiagaraStatelessExpressionVec4Subtract : public FNiagaraStatelessExpressionVec4 {
    /* 0x0008 */ FInstancedStruct A;
    /* 0x0018 */ FInstancedStruct B;
};

// Size: 0x30
class UNiagaraStatelessModule : public UNiagaraMergeable {
    /* 0x0028 */ bool bModuleEnabled;
};

// Size: 0x78
class UNiagaraStatelessModule_AccelerationForce : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeVector3 AccelerationDistribution;
    /* 0x0070 */ ENiagaraCoordinateSpace CoordinateSpace;
};

// Size: 0x140
class UNiagaraStatelessModule_AddVelocity : public UNiagaraStatelessModule {
    /* 0x0030 */ ENSM_VelocityType VelocityType;
    /* 0x0038 */ FNiagaraDistributionRangeVector3 LinearVelocityDistribution;
    /* 0x0078 */ FNiagaraDistributionRangeFloat LinearVelocityScale;
    /* 0x00a8 */ FNiagaraDistributionRangeFloat ConeVelocityDistribution;
    /* 0x00d8 */ FRotator ConeRotation;
    /* 0x00f0 */ float ConeAngle;
    /* 0x00f4 */ float InnerCone;
    /* 0x00f8 */ FNiagaraDistributionRangeFloat PointVelocityDistribution;
    /* 0x0128 */ FVector3f PointOrigin;
    /* 0x0134 */ bool bSpeedFalloffFromConeAxisEnabled;
    /* 0x0138 */ float SpeedFalloffFromConeAxis;
    /* 0x013c */ ENiagaraCoordinateSpace CoordinateSpace;
};

// Size: 0x30
class UNiagaraStatelessModule_CalculateAccurateVelocity : public UNiagaraStatelessModule {
};

// Size: 0x70
class UNiagaraStatelessModule_CameraOffset : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionFloat CameraOffsetDistribution;
};

// Size: 0x38
class UNiagaraStatelessModule_CurlNoiseForce : public UNiagaraStatelessModule {
    /* 0x0030 */ float NoiseStrength;
    /* 0x0034 */ float NoiseFrequency;
};

// Size: 0x100
class UNiagaraStatelessModule_DecalAttributes : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bApplyOrientation;
    /* 0x0031 */ bool bApplySize;
    /* 0x0032 */ bool bApplyFade;
    /* 0x0038 */ FNiagaraDistributionVector3 Orientation;
    /* 0x0078 */ ENiagaraCoordinateSpace OrientationCoordinateSpace;
    /* 0x0080 */ FNiagaraDistributionVector3 Size;
    /* 0x00c0 */ FNiagaraDistributionFloat Fade;

    bool IsOrientationEnabled() const;
};

// Size: 0x60
class UNiagaraStatelessModule_Drag : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeFloat DragDistribution;
};

// Size: 0x458
class UNiagaraStatelessModule_DynamicMaterialParameters : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bParameter0Enabled;
    /* 0x0030 */ bool bParameter1Enabled;
    /* 0x0030 */ bool bParameter2Enabled;
    /* 0x0030 */ bool bParameter3Enabled;
    /* 0x0038 */ FNiagaraStatelessDynamicParameterSet Parameter0;
    /* 0x0140 */ FNiagaraStatelessDynamicParameterSet Parameter1;
    /* 0x0248 */ FNiagaraStatelessDynamicParameterSet Parameter2;
    /* 0x0350 */ FNiagaraStatelessDynamicParameterSet Parameter3;
};

// Size: 0x70
class UNiagaraStatelessModule_GravityForce : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeVector3 GravityDistribution;
};

// Size: 0xf8
class UNiagaraStatelessModule_InitialMeshOrientation : public UNiagaraStatelessModule {
    /* 0x0030 */ ENSMInitialMeshOrientationMode MeshOrientationMode;
    /* 0x0038 */ FNiagaraDistributionRangeVector3 OrientationVector;
    /* 0x0078 */ FNiagaraDistributionRangeVector3 MeshAxisToOrient;
    /* 0x00b8 */ FNiagaraDistributionRangeVector3 Rotation;
};

// Size: 0x1f8
class UNiagaraStatelessModule_InitializeParticle : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeFloat LifetimeDistribution;
    /* 0x0060 */ FNiagaraDistributionRangeColor ColorDistribution;
    /* 0x00a8 */ FNiagaraDistributionRangeFloat MassDistribution;
    /* 0x00d8 */ FNiagaraDistributionRangeVector2 SpriteSizeDistribution;
    /* 0x0110 */ FNiagaraDistributionRangeFloat SpriteRotationDistribution;
    /* 0x0140 */ FNiagaraDistributionRangeVector3 MeshScaleDistribution;
    /* 0x0180 */ bool bWriteRibbonWidth;
    /* 0x0188 */ FNiagaraDistributionRangeFloat RibbonWidthDistribution;
    /* 0x01b8 */ FNiagaraDistributionPosition InitialPositionDistribution;
};

// Size: 0x178
class UNiagaraStatelessModule_LightAttributes : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bApplyRadius;
    /* 0x0030 */ bool bApplyFalloffExponent;
    /* 0x0030 */ bool bApplyDiffuseScale;
    /* 0x0030 */ bool bApplySpecularScale;
    /* 0x0030 */ bool bApplyVolumetricScattering;
    /* 0x0038 */ FNiagaraDistributionFloat Radius;
    /* 0x0078 */ FNiagaraDistributionFloat FalloffExponent;
    /* 0x00b8 */ FNiagaraDistributionFloat DiffuseScale;
    /* 0x00f8 */ FNiagaraDistributionFloat SpecularScale;
    /* 0x0138 */ FNiagaraDistributionFloat VolumetricScattering;
};

// Size: 0x68
class UNiagaraStatelessModule_MeshIndex : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeInt MeshIndex;
    /* 0x0058 */ TArray<float> MeshIndexWeight;

    bool NeedsMeshIndexWeights() const;
};

// Size: 0xb8
class UNiagaraStatelessModule_MeshRotationRate : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bUseRateScale;
    /* 0x0038 */ FNiagaraDistributionRangeVector3 RotationRateDistribution;
    /* 0x0078 */ FNiagaraDistributionCurveVector3 RateScaleDistribution;
};

// Size: 0xc0
class UNiagaraStatelessModule_RotateAroundPoint : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeFloat Rate;
    /* 0x0060 */ FNiagaraDistributionRangeFloat Radius;
    /* 0x0090 */ FNiagaraDistributionRangeFloat InitialPhase;
};

// Size: 0x70
class UNiagaraStatelessModule_ScaleColor : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionColor ScaleDistribution;
};

// Size: 0x90
class UNiagaraStatelessModule_ScaleMeshSize : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionVector3 ScaleDistribution;
    /* 0x0070 */ FNiagaraParameterBindingWithValue ScaleCurveRange;

    bool UseScaleCurveRange() const;
};

// Size: 0x128
class UNiagaraStatelessModule_ScaleMeshSizeBySpeed : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeFloat VelocityThreshold;
    /* 0x0060 */ FNiagaraDistributionRangeVector3 MinScaleFactor;
    /* 0x00a0 */ FNiagaraDistributionRangeVector3 MaxScaleFactor;
    /* 0x00e0 */ bool bSampleScaleFactorByCurve;
    /* 0x00e8 */ FNiagaraDistributionFloat SampleFactorCurve;
};

// Size: 0x90
class UNiagaraStatelessModule_ScaleRibbonWidth : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionFloat ScaleDistribution;
    /* 0x0070 */ FNiagaraParameterBindingWithValue ScaleCurveRange;

    bool UseScaleCurveRange() const;
};

// Size: 0x90
class UNiagaraStatelessModule_ScaleSpriteSize : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionVector2 ScaleDistribution;
    /* 0x0070 */ FNiagaraParameterBindingWithValue ScaleCurveRange;

    bool UseScaleCurveRange() const;
};

// Size: 0x118
class UNiagaraStatelessModule_ScaleSpriteSizeBySpeed : public UNiagaraStatelessModule {
    /* 0x0030 */ FNiagaraDistributionRangeFloat VelocityThreshold;
    /* 0x0060 */ FNiagaraDistributionRangeVector2 MinScaleFactor;
    /* 0x0098 */ FNiagaraDistributionRangeVector2 MaxScaleFactor;
    /* 0x00d0 */ bool bSampleScaleFactorByCurve;
    /* 0x00d8 */ FNiagaraDistributionFloat SampleFactorCurve;
};

// Size: 0x270
class UNiagaraStatelessModule_ShapeLocation : public UNiagaraStatelessModule {
    /* 0x0030 */ ENSM_ShapePrimitive ShapePrimitive;
    /* 0x0038 */ FNiagaraDistributionRangeVector3 BoxSize;
    /* 0x0078 */ bool bBoxSurfaceOnly;
    /* 0x0079 */ ENSM_SurfaceExpansionMode BoxSurfaceExpansion;
    /* 0x0080 */ FNiagaraDistributionRangeFloat BoxSurfaceThickness;
    /* 0x00b0 */ FNiagaraDistributionRangeVector2 PlaneSize;
    /* 0x00e8 */ bool bPlaneEdgesOnly;
    /* 0x00e9 */ ENSM_SurfaceExpansionMode PlaneEdgeExpansion;
    /* 0x00f0 */ FNiagaraDistributionRangeFloat PlaneEdgeThickness;
    /* 0x0120 */ FNiagaraDistributionRangeFloat CylinderHeight;
    /* 0x0150 */ FNiagaraDistributionRangeFloat CylinderRadius;
    /* 0x0180 */ FNiagaraDistributionRangeFloat CylinderHeightMidpoint;
    /* 0x01b0 */ FNiagaraDistributionRangeFloat RingRadius;
    /* 0x01e0 */ FNiagaraDistributionRangeFloat DiscCoverage;
    /* 0x0210 */ FNiagaraDistributionRangeFloat RingUDistribution;
    /* 0x0240 */ FNiagaraDistributionRangeFloat SphereRadius;
};

// Size: 0x30
class UNiagaraStatelessModule_SolveVelocitiesAndForces : public UNiagaraStatelessModule {
};

// Size: 0xb8
class UNiagaraStatelessModule_SpriteFacingAndAlignment : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bSpriteFacingEnabled;
    /* 0x0031 */ bool bSpriteAlignmentEnabled;
    /* 0x0038 */ FNiagaraDistributionRangeVector3 SpriteFacing;
    /* 0x0078 */ FNiagaraDistributionRangeVector3 SpriteAlignment;
};

// Size: 0xa8
class UNiagaraStatelessModule_SpriteRotationRate : public UNiagaraStatelessModule {
    /* 0x0030 */ bool bUseRateScale;
    /* 0x0038 */ FNiagaraDistributionRangeFloat RotationRateDistribution;
    /* 0x0068 */ FNiagaraDistributionCurveFloat RateScaleDistribution;
};

// Size: 0x78
class UNiagaraStatelessModule_SubUVAnimation : public UNiagaraStatelessModule {
    /* 0x0030 */ int32_t NumFrames;
    /* 0x0038 */ FNiagaraDistributionRangeInt FrameIndex;
    /* 0x0060 */ bool bStartFrameRangeOverride_Enabled;
    /* 0x0061 */ bool bEndFrameRangeOverride_Enabled;
    /* 0x0064 */ int32_t StartFrameRangeOverride;
    /* 0x0068 */ int32_t EndFrameRangeOverride;
    /* 0x006c */ ENSMSubUVAnimation_Mode AnimationMode;
    /* 0x0070 */ float LoopsPerSecond;
    /* 0x0074 */ float RandomChangeInterval;
};

// Size: 0xc0
struct FNiagaraStatelessSpawnInfo {
    /* 0x0000 */ ENiagaraStatelessSpawnInfoType Type;
    /* 0x0004 */ float SpawnTime;
    /* 0x0008 */ FNiagaraDistributionRangeInt amount;
    /* 0x0030 */ FNiagaraDistributionRangeFloat Rate;
    /* 0x0060 */ bool bEnabled;
    /* 0x0060 */ bool bSpawnProbabilityEnabled;
    /* 0x0060 */ bool bLoopCountLimitEnabled;
    /* 0x0068 */ FNiagaraDistributionRangeFloat SpawnProbability;
    /* 0x0098 */ FNiagaraDistributionRangeInt LoopCountLimit;
};

// Size: 0x14
struct FNiagaraStructConversionStep {
    /* 0x0000 */ int32_t LWCBytes;
    /* 0x0004 */ int32_t LWCOffset;
    /* 0x0008 */ int32_t SimulationBytes;
    /* 0x000c */ int32_t SimulationOffset;
    /* 0x0010 */ ENiagaraStructConversionType ConversionType;
};

// Size: 0x568
class UNiagaraSystem : public UFXSystemAsset {
    /* 0x0050 */ bool bSupportLargeWorldCoordinates;
    /* 0x0050 */ bool bOverrideCastShadow;
    /* 0x0050 */ bool bOverrideReceivesDecals;
    /* 0x0050 */ bool bOverrideRenderCustomDepth;
    /* 0x0050 */ bool bOverrideCustomDepthStencilValue;
    /* 0x0050 */ bool bOverrideCustomDepthStencilWriteMask;
    /* 0x0050 */ bool bOverrideTranslucencySortPriority;
    /* 0x0050 */ bool bOverrideTranslucencySortDistanceOffset;
    /* 0x0051 */ bool bCastShadow;
    /* 0x0051 */ bool bReceivesDecals;
    /* 0x0051 */ bool bRenderCustomDepth;
    /* 0x0051 */ bool bInitialOwnerVelocityFromActor;
    /* 0x0052 */ TOptional<ENiagaraLwcTileUpdateMode> LargeWorldCoordinateTileUpdateMode;
    /* 0x0054 */ ERendererStencilMask CustomDepthStencilWriteMask;
    /* 0x0058 */ int32_t CustomDepthStencilValue;
    /* 0x005c */ int32_t TranslucencySortPriority;
    /* 0x0060 */ float TranslucencySortDistanceOffset;
    /* 0x0064 */ bool bDumpDebugSystemInfo;
    /* 0x0064 */ bool bDumpDebugEmitterInfo;
    /* 0x0064 */ bool bRequireCurrentFrameData;
    /* 0x0064 */ bool bOverrideScalabilitySettings;
    /* 0x0068 */ bool bFixedBounds;
    /* 0x0070 */ UNiagaraEffectType* EffectType;
    /* 0x0078 */ bool bOverrideAllowCullingForLocalPlayers;
    /* 0x0078 */ bool bAllowCullingForLocalPlayersOverride;
    /* 0x0080 */ FNiagaraSystemScalabilityOverrides SystemScalabilityOverrides;
    /* 0x0090 */ FNiagaraPlatformSet Platforms;
    /* 0x00c0 */ TArray<FNiagaraEmitterHandle> EmitterHandles;
    /* 0x00d0 */ TArray<UNiagaraParameterCollectionInstance*> ParameterCollectionOverrides;
    /* 0x00e0 */ UNiagaraScript* SystemSpawnScript;
    /* 0x00e8 */ UNiagaraScript* SystemUpdateScript;
    /* 0x0100 */ FNiagaraSystemCompiledData SystemCompiledData;
    /* 0x0340 */ FNiagaraUserRedirectionParameterStore ExposedParameters;
    /* 0x0418 */ FBox FixedBounds;
    /* 0x0450 */ bool bUseInitialStreamingBounds;
    /* 0x0458 */ FBox InitialStreamingBounds;
    /* 0x0490 */ bool bNeedsGPUContextInitForDataInterfaces;
    /* 0x0491 */ bool bDeterminism;
    /* 0x0492 */ bool bFixedTickDelta;
    /* 0x0494 */ int32_t RandomSeed;
    /* 0x0498 */ float WarmupTime;
    /* 0x049c */ int32_t WarmupTickCount;
    /* 0x04a0 */ float WarmupTickDelta;
    /* 0x04a4 */ float FixedTickDeltaTime;
    /* 0x0540 */ bool bAllowSystemStateFastPath;
    /* 0x0540 */ bool bSystemStateFastPathEnabled;
    /* 0x0550 */ FInstancedStruct SystemStateDataStruct;
};

// Size: 0x88
struct FNiagaraSystemAsyncCompileResults {
    /* 0x0000 */ TArray<UObject*> RootObjects;
    /* 0x0068 */ TArray<FNiagaraVariable> ExposedVariables;
};

// Size: 0x240
struct FNiagaraSystemCompiledData {
    /* 0x0000 */ FNiagaraParameterStore InstanceParamStore;
    /* 0x0088 */ FNiagaraDataSetCompiledData DataSetCompiledData;
    /* 0x00d0 */ FNiagaraDataSetCompiledData SpawnInstanceParamsDataSetCompiledData;
    /* 0x0118 */ FNiagaraDataSetCompiledData UpdateInstanceParamsDataSetCompiledData;
    /* 0x0160 */ FNiagaraParameterDataSetBindingCollection SpawnInstanceGlobalBinding;
    /* 0x0180 */ FNiagaraParameterDataSetBindingCollection SpawnInstanceSystemBinding;
    /* 0x01a0 */ FNiagaraParameterDataSetBindingCollection SpawnInstanceOwnerBinding;
    /* 0x01c0 */ TArray<FNiagaraParameterDataSetBindingCollection> SpawnInstanceEmitterBindings;
    /* 0x01d0 */ FNiagaraParameterDataSetBindingCollection UpdateInstanceGlobalBinding;
    /* 0x01f0 */ FNiagaraParameterDataSetBindingCollection UpdateInstanceSystemBinding;
    /* 0x0210 */ FNiagaraParameterDataSetBindingCollection UpdateInstanceOwnerBinding;
    /* 0x0230 */ TArray<FNiagaraParameterDataSetBindingCollection> UpdateInstanceEmitterBindings;
};

// Size: 0xa0
struct FNiagaraSystemScalabilityOverride : public FNiagaraSystemScalabilitySettings {
    /* 0x0098 */ bool bOverrideDistanceSettings;
    /* 0x0098 */ bool bOverrideInstanceCountSettings;
    /* 0x0098 */ bool bOverridePerSystemInstanceCountSettings;
    /* 0x0098 */ bool bOverrideVisibilitySettings;
    /* 0x0098 */ bool bOverrideGlobalBudgetScalingSettings;
    /* 0x0098 */ bool bOverrideCullProxySettings;
};

// Size: 0x10
struct FNiagaraSystemScalabilityOverrides {
    /* 0x0000 */ TArray<FNiagaraSystemScalabilityOverride> Overrides;
};

// Size: 0x98
struct FNiagaraSystemScalabilitySettings {
    /* 0x0000 */ FNiagaraPlatformSet Platforms;
    /* 0x0030 */ bool bCullByDistance;
    /* 0x0030 */ bool bCullMaxInstanceCount;
    /* 0x0030 */ bool bCullPerSystemMaxInstanceCount;
    /* 0x0034 */ float MaxDistance;
    /* 0x0038 */ bool bCullByMaxTimeWithoutRender;
    /* 0x003c */ int32_t MaxInstances;
    /* 0x0040 */ int32_t MaxSystemInstances;
    /* 0x0044 */ float MaxTimeWithoutRender;
    /* 0x0048 */ ENiagaraCullProxyMode CullProxyMode;
    /* 0x004c */ int32_t MaxSystemProxies;
    /* 0x0050 */ FNiagaraSystemVisibilityCullingSettings VisibilityCulling;
    /* 0x005c */ FNiagaraGlobalBudgetScaling BudgetScaling;
};

// Size: 0x10
struct FNiagaraSystemScalabilitySettingsArray {
    /* 0x0000 */ TArray<FNiagaraSystemScalabilitySettings> Settings;
};

// Size: 0x18
struct FNiagaraSystemSimCacheCaptureReply {
    /* 0x0000 */ FName ComponentName;
    /* 0x0008 */ TArray<uint8_t> SimCacheData;
};

// Size: 0x10
struct FNiagaraSystemSimCacheCaptureRequest {
    /* 0x0000 */ FName ComponentName;
    /* 0x0008 */ uint32_t CaptureDelayFrames;
    /* 0x000c */ uint32_t CaptureFrames;
};

// Size: 0x70
struct FNiagaraSystemStateData {
    /* 0x0000 */ bool bRunSpawnScript;
    /* 0x0000 */ bool bRunUpdateScript;
    /* 0x0000 */ bool bIgnoreSystemState;
    /* 0x0000 */ bool bRecalculateDurationEachLoop;
    /* 0x0000 */ bool bLoopDelayEnabled;
    /* 0x0000 */ bool bDelayFirstLoopOnly;
    /* 0x0000 */ bool bRecalculateDelayEachLoop;
    /* 0x0004 */ ENiagaraSystemInactiveResponse InactiveResponse;
    /* 0x0005 */ ENiagaraLoopBehavior LoopBehavior;
    /* 0x0008 */ FNiagaraDistributionRangeFloat LoopDuration;
    /* 0x0038 */ int32_t LoopCount;
    /* 0x0040 */ FNiagaraDistributionRangeFloat LoopDelay;
};

// Size: 0x88
struct FNiagaraSystemUpdateContext {
    /* 0x0000 */ TArray<UNiagaraComponent*> ComponentsToReset;
    /* 0x0010 */ TArray<UNiagaraComponent*> ComponentsToReInit;
    /* 0x0020 */ TArray<UNiagaraComponent*> ComponentsToNotifySimDestroy;
    /* 0x0030 */ TArray<UNiagaraComponent*> ComponentsToDestroyInstance;
    /* 0x0040 */ TArray<UNiagaraSystem*> SystemSimsToDestroy;
    /* 0x0050 */ TArray<UNiagaraSystem*> SystemSimsToRecache;
};

// Size: 0xc
struct FNiagaraSystemVisibilityCullingSettings {
    /* 0x0000 */ bool bCullWhenNotRendered;
    /* 0x0000 */ bool bCullByViewFrustum;
    /* 0x0000 */ bool bAllowPreCullingByViewFrustum;
    /* 0x0004 */ float MaxTimeOutsideViewFrustum;
    /* 0x0008 */ float MaxTimeWithoutRender;
};

// Size: 0x18
struct FNiagaraTypeDefinition {
    /* 0x0000 */ UObject* ClassStructOrEnum;
    /* 0x0008 */ uint16_t UnderlyingType;
    /* 0x000a */ uint8_t Flags;
};

// Size: 0x4
struct FNiagaraTypeDefinitionHandle {
    /* 0x0000 */ int32_t RegisteredTypeIndex;
};

// Size: 0x18
struct FNiagaraTypeLayoutInfo {
    /* 0x0000 */ uint16_t NumFloatComponents;
    /* 0x0002 */ uint16_t NumInt32Components;
    /* 0x0004 */ uint16_t NumHalfComponents;
    /* 0x0008 */ TArray<uint32_t> ComponentsOffsets;
};

// Size: 0x10
struct FNiagaraUObjectPropertyReaderRemap {
    /* 0x0000 */ FName GraphName;
    /* 0x0008 */ FName RemapName;
};

// Size: 0x20
struct FNiagaraUserParameterBinding {
    /* 0x0000 */ FNiagaraVariable Parameter;
};

// Size: 0xd8
struct FNiagaraUserRedirectionParameterStore : public FNiagaraParameterStore {
    /* 0x0088 */ TMap<FNiagaraVariable, FNiagaraVariable> UserParameterRedirects;
};

// Size: 0x18
struct FNiagaraVMExecutableByteCode {
    /* 0x0000 */ TArray<uint8_t> Data;
    /* 0x0010 */ int32_t UncompressedSize;
};

// Size: 0x1a0
struct FNiagaraVMExecutableData {
    /* 0x0000 */ FNiagaraVMExecutableByteCode ByteCode;
    /* 0x0018 */ FNiagaraVMExecutableByteCode OptimizedByteCode;
    /* 0x0068 */ int32_t NumTempRegisters;
    /* 0x006c */ int32_t NumUserPtrs;
    /* 0x0070 */ TArray<FNiagaraCompilerTag> CompileTags;
    /* 0x0080 */ TArray<uint8_t> ScriptLiterals;
    /* 0x0090 */ TArray<FNiagaraVariableBase> Attributes;
    /* 0x00a0 */ FNiagaraScriptDataUsageInfo DataUsage;
    /* 0x00a8 */ TArray<FNiagaraScriptUObjectCompileInfo> UObjectInfos;
    /* 0x00b8 */ TArray<FNiagaraScriptDataInterfaceCompileInfo> DataInterfaceInfo;
    /* 0x00c8 */ TArray<FVMExternalFunctionBindingInfo> CalledVMExternalFunctions;
    /* 0x00e8 */ TArray<FNiagaraDataSetID> ReadDataSets;
    /* 0x00f8 */ TArray<FNiagaraDataSetProperties> WriteDataSets;
    /* 0x0108 */ TArray<FNiagaraStatScope> StatScopes;
    /* 0x0118 */ FNiagaraShaderScriptParametersMetadata ShaderScriptParametersMetadata;
    /* 0x0170 */ ENiagaraScriptCompileStatus LastCompileStatus;
    /* 0x0178 */ TArray<FSimulationStageMetaData> SimulationStageMetaData;
    /* 0x0188 */ TArray<uint8_t> ExperimentalContextData;
    /* 0x0198 */ bool bReadsSignificanceIndex;
    /* 0x0198 */ bool bNeedsGPUContextInit;
};

// Size: 0x28
struct FNiagaraVMExecutableDataId {
    /* 0x0000 */ FGuid CompilerVersionID;
    /* 0x0010 */ ENiagaraInterpolatedSpawnMode InterpolatedSpawnMode;
    /* 0x0018 */ FNiagaraCompileHash BaseScriptCompileHash;
};

// Size: 0x30
class UNiagaraValidationRule : public UObject {
    /* 0x0028 */ bool bIsConfigDisabled;
};

// Size: 0x38
class UNiagaraValidationRuleSet : public UObject {
    /* 0x0028 */ TArray<UNiagaraValidationRule*> ValidationRules;
};

// Size: 0x20
struct FNiagaraVariable : public FNiagaraVariableBase {
    /* 0x0010 */ TArray<uint8_t> VarData;
};

// Size: 0x38
struct FNiagaraVariableAttributeBinding {
    /* 0x0000 */ FNiagaraVariable RootVariable;
    /* 0x0020 */ FNiagaraVariableBase ParamMapVariable;
    /* 0x002c */ FName DataSetName;
    /* 0x0034 */ uint8_t BindingSourceMode;
    /* 0x0035 */ bool bBindingExistsOnSource;
    /* 0x0035 */ bool bIsCachedParticleValue;
};

// Size: 0xc
struct FNiagaraVariableBase {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FNiagaraTypeDefinitionHandle TypeDefHandle;
};

// Size: 0x20
struct FNiagaraVariableDataInterfaceBinding {
    /* 0x0000 */ FNiagaraVariable BoundVariable;
};

// Size: 0x38
struct FNiagaraVariableInfo {
    /* 0x0000 */ FNiagaraVariable Variable;
    /* 0x0020 */ FText Definition;
    /* 0x0030 */ UNiagaraDataInterface* DataInterface;
};

// Size: 0x20
struct FNiagaraVariableLayoutInfo {
    /* 0x0000 */ uint16_t FloatComponentStart;
    /* 0x0002 */ uint16_t Int32ComponentStart;
    /* 0x0004 */ uint16_t HalfComponentStart;
    /* 0x0008 */ FNiagaraTypeLayoutInfo LayoutInfo;
};

// Size: 0x198
struct FNiagaraVariableMetaData {
    /* 0x0000 */ FText Description;
    /* 0x0010 */ EUnit DisplayUnit;
    /* 0x0011 */ bool bAdvancedDisplay;
    /* 0x0012 */ bool bDisplayInOverviewStack;
    /* 0x0014 */ int32_t InlineParameterSortPriority;
    /* 0x0018 */ bool bOverrideColor;
    /* 0x001c */ FLinearColor InlineParameterColorOverride;
    /* 0x0030 */ TArray<FNiagaraEnumParameterMetaData> InlineParameterEnumOverrides;
    /* 0x0040 */ bool bEnableBoolOverride;
    /* 0x0048 */ FNiagaraBoolParameterMetaData InlineParameterBoolOverride;
    /* 0x0070 */ bool bInlineEditConditionToggle;
    /* 0x0078 */ FNiagaraInputConditionMetadata EditCondition;
    /* 0x0090 */ FNiagaraInputConditionMetadata VisibleCondition;
    /* 0x00a8 */ TMap<FName, FString> PropertyMetaData;
    /* 0x00f8 */ TArray<FName> AlternateAliases;
    /* 0x0108 */ FNiagaraInputParameterCustomization WidgetCustomization;
    /* 0x0160 */ FGuid VariableGuid;
    /* 0x0170 */ bool bIsStaticSwitch;
    /* 0x0174 */ int32_t StaticSwitchDefaultValue;
    /* 0x0178 */ FText CategoryName;
    /* 0x0188 */ FName ParentAttribute;
    /* 0x0190 */ int32_t EditorSortPriority;
};

// Size: 0x28
struct FNiagaraVariableWithOffset : public FNiagaraVariableBase {
    /* 0x000c */ int32_t Offset;
    /* 0x0010 */ FNiagaraLwcStructConverter StructConverter;
};

// Size: 0x28
struct FNiagaraVariant {
    /* 0x0000 */ UObject* Object;
    /* 0x0008 */ UNiagaraDataInterface* DataInterface;
    /* 0x0010 */ TArray<uint8_t> Bytes;
    /* 0x0020 */ ENiagaraVariantMode CurrentMode;
};

// Size: 0x2b0
class UNiagaraVolumeRendererProperties : public UNiagaraRendererProperties {
    /* 0x00b8 */ UMaterialInterface* Material;
    /* 0x00c0 */ FNiagaraParameterBinding MaterialParameterBinding;
    /* 0x00d0 */ int32_t RendererVisibility;
    /* 0x00d4 */ float StepFactor;
    /* 0x00d8 */ float LightingDownsampleFactor;
    /* 0x00dc */ float ShadowStepFactor;
    /* 0x00e0 */ float ShadowBiasFactor;
    /* 0x0190 */ FNiagaraVariableAttributeBinding RendererVisibilityTagBinding;
    /* 0x01c8 */ FNiagaraVariableAttributeBinding VolumeResolutionMaxAxisBinding;
    /* 0x0200 */ FNiagaraVariableAttributeBinding VolumeWorldSpaceSizeBinding;
    /* 0x0238 */ FNiagaraRendererMaterialParameters MaterialParameters;
};

// Size: 0x20
struct FNiagaraWidgetNamedIntegerInputValue {
    /* 0x0000 */ FText DisplayName;
    /* 0x0010 */ FText Tooltip;
};

// Size: 0x1
struct FNiagaraWildcard {
};

// Size: 0x38
struct FNiagaraWorldManagerTickFunction : public FTickFunction {
};

// Size: 0x1
struct FParameterDefinitionsSubscription {
};

// Size: 0x58
struct FVMExternalFunctionBindingInfo {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName OwnerName;
    /* 0x0010 */ TArray<bool> InputParamLocations;
    /* 0x0020 */ int32_t NumOutputs;
    /* 0x0028 */ TArray<FVMFunctionSpecifier> FunctionSpecifiers;
    /* 0x0038 */ TArray<FNiagaraVariableBase> VariadicInputs;
    /* 0x0048 */ TArray<FNiagaraVariableBase> VariadicOutputs;
};

// Size: 0x10
struct FVMFunctionSpecifier {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FName Value;
};

// Size: 0x18
struct FVersionedNiagaraEmitter {
    /* 0x0000 */ UNiagaraEmitter* Emitter;
    /* 0x0008 */ FGuid Version;
};

// Size: 0x368
struct FVersionedNiagaraEmitterData {
    /* 0x0000 */ FNiagaraAssetVersion Version;
    /* 0x001c */ bool bDeprecated;
    /* 0x0020 */ FText DeprecationMessage;
    /* 0x0030 */ bool bLocalSpace;
    /* 0x0031 */ bool bDeterminism;
    /* 0x0034 */ int32_t RandomSeed;
    /* 0x0038 */ ENiagaraInterpolatedSpawnMode InterpolatedSpawnMode;
    /* 0x0039 */ ENiagaraSimTarget SimTarget;
    /* 0x003a */ ENiagaraEmitterCalculateBoundMode CalculateBoundsMode;
    /* 0x0040 */ FBox FixedBounds;
    /* 0x0078 */ bool bRequiresPersistentIDs;
    /* 0x0080 */ TArray<FNiagaraEventScriptProperties> EventHandlerScriptProps;
    /* 0x0090 */ FNiagaraPlatformSet Platforms;
    /* 0x00c0 */ FNiagaraEmitterScalabilityOverrides ScalabilityOverrides;
    /* 0x00d0 */ int32_t MaxGPUParticlesSpawnPerFrame;
    /* 0x00d4 */ EParticleAllocationMode AllocationMode;
    /* 0x00d8 */ int32_t PreAllocationCount;
    /* 0x00e0 */ TArray<FNiagaraDataInterfaceEmitterBinding> EmitterDependencies;
    /* 0x00f0 */ FNiagaraEmitterScriptProperties UpdateScriptProps;
    /* 0x0118 */ FNiagaraEmitterScriptProperties SpawnScriptProps;
    /* 0x0140 */ FNiagaraParameterStore RendererBindings;
    /* 0x01c8 */ TArray<FNiagaraExternalUObjectInfo> RendererBindingsExternalObjects;
    /* 0x01d8 */ TMap<FNiagaraVariableBase, FNiagaraVariableBase> ResolvedDIBindings;
    /* 0x0228 */ TArray<UNiagaraRendererProperties*> RendererProperties;
    /* 0x0238 */ TArray<UNiagaraSimulationStageBase*> SimulationStages;
    /* 0x0248 */ TArray<FNiagaraSimStageExecutionLoopData> SimStageExecutionLoops;
    /* 0x0268 */ UNiagaraScript* GPUComputeScript;
    /* 0x0270 */ TArray<FName> SharedEventGeneratorIds;
    /* 0x0280 */ FNiagaraEmitterScalabilitySettings CurrentScalabilitySettings;
};

// Size: 0x1
struct FVersionedNiagaraScriptData {
};

// Size: 0x60
class UVolumeCache : public UObject {
    /* 0x0028 */ FString FilePath;
    /* 0x0038 */ EVolumeCacheType CacheType;
    /* 0x003c */ FIntVector Resolution;
    /* 0x0048 */ int32_t FrameRangeStart;
    /* 0x004c */ int32_t FrameRangeEnd;
};

// Size: 0x28
struct FWidgetNamedInputValue {
    /* 0x0000 */ float Value;
    /* 0x0008 */ FText DisplayName;
    /* 0x0018 */ FText Tooltip;
};

// Size: 0x20
struct FWidgetSegmentValueOverride {
    /* 0x0000 */ int32_t EnumIndexToOverride;
    /* 0x0004 */ bool bOverrideDisplayName;
    /* 0x0008 */ FText DisplayNameOverride;
    /* 0x0018 */ UTexture2D* DisplayIcon;
};

// Size: 0x90
class UAnimNotifyState_TimedNiagaraEffect : public UAnimNotifyState {
    /* 0x0030 */ UNiagaraSystem* Template;
    /* 0x0038 */ FName SocketName;
    /* 0x0040 */ FVector LocationOffset;
    /* 0x0058 */ FRotator RotationOffset;
    /* 0x0070 */ FVector Scale;
    /* 0x0088 */ bool bApplyRateScaleAsTimeDilation;
    /* 0x0089 */ bool bDestroyAtEnd;

    UFXSystemComponent* GetSpawnedEffect(UMeshComponent* MeshComp) const;
};

// Size: 0x100
class UAnimNotifyState_TimedNiagaraEffectAdvanced : public UAnimNotifyState_TimedNiagaraEffect {
    /* 0x0090 */ bool bEnableNormalizedNotifyProgress;
    /* 0x0091 */ bool bApplyRateScaleToProgress;
    /* 0x0094 */ FName NotifyProgressUserParameter;
    /* 0x00a0 */ TArray<FCurveParameterPair> AnimCurves;

    float GetNotifyProgress(UMeshComponent* MeshComp) const;
};

// Size: 0xd0
class UAnimNotify_PlayNiagaraEffect : public UAnimNotify {
    /* 0x0038 */ UNiagaraSystem* Template;
    /* 0x0040 */ FVector LocationOffset;
    /* 0x0058 */ FRotator RotationOffset;
    /* 0x0070 */ FVector Scale;
    /* 0x0088 */ bool bAbsoluteScale;
    /* 0x00c0 */ bool Attached;
    /* 0x00c4 */ FName SocketName;

    UFXSystemComponent* GetSpawnedEffect() const;
};

// Size: 0x10
struct FCurveParameterPair {
    /* 0x0000 */ FName AnimCurveName;
    /* 0x0008 */ FName UserVariableName;
};

enum class ENiagaraIterationSource {
    Particles = 0,
    DataInterface = 1,
    DirectSet = 2,
    ENiagaraIterationSource_MAX = 3,
};

enum class ENiagaraParameterAccessLevel {
    Private = 0,
    Public = 1,
    ENiagaraParameterAccessLevel_MAX = 2,
};

// Size: 0x10
struct FNiagaraCompileHash {
    /* 0x0000 */ TArray<uint8_t> DataHash;
};

// Size: 0x28
class UNiagaraDataInterfaceBase : public UNiagaraMergeable {
};

// Size: 0x28
class UNiagaraMergeable : public UObject {
};

// Size: 0x10
struct FNiagaraVariableCommonReference {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UObject* UnderlyingType;
};

enum class ENiagaraDirectDispatchElementType {
    NumThreads = 0,
    NumThreadsNoClipping = 1,
    NumGroups = 2,
    ENiagaraDirectDispatchElementType_MAX = 3,
};

enum class ENiagaraGpuDispatchType {
    OneD = 0,
    TwoD = 1,
    ThreeD = 2,
    Custom = 3,
    ENiagaraGpuDispatchType_MAX = 4,
};

enum class ENiagaraMipMapGenerationType {
    Unfiltered = 0,
    Linear = 1,
    Blur1 = 2,
    Blur2 = 3,
    Blur3 = 4,
    Blur4 = 5,
    ENiagaraMipMapGenerationType_MAX = 6,
};

enum class ENiagaraSimStageExecuteBehavior {
    Always = 0,
    OnSimulationReset = 1,
    NotOnSimulationReset = 2,
    ENiagaraSimStageExecuteBehavior_MAX = 3,
};

enum class FNiagaraCompileEventSeverity {
    Log = 0,
    Display = 1,
    Warning = 2,
    Error = 3,
    FNiagaraCompileEventSeverity_MAX = 4,
};

enum class FNiagaraCompileEventSource {
    Unset = 0,
    ScriptDependency = 1,
    FNiagaraCompileEventSource_MAX = 2,
};

// Size: 0x60
struct FNiagaraCompileEvent {
    /* 0x0000 */ FNiagaraCompileEventSeverity Severity;
    /* 0x0008 */ FString Message;
    /* 0x0018 */ FString ShortDescription;
    /* 0x0028 */ FGuid NodeGuid;
    /* 0x0038 */ FGuid PinGuid;
    /* 0x0048 */ TArray<FGuid> StackGuids;
    /* 0x0058 */ FNiagaraCompileEventSource Source;
};

// Size: 0x38
struct FNiagaraDataInterfaceGPUParamInfo {
    /* 0x0000 */ FString DataInterfaceHLSLSymbol;
    /* 0x0010 */ FString DIClassName;
    /* 0x0020 */ uint32_t ShaderParametersOffset;
    /* 0x0028 */ TArray<FNiagaraDataInterfaceGeneratedFunction> GeneratedFunctions;
};

// Size: 0x50
struct FNiagaraDataInterfaceGeneratedFunction {
    /* 0x0030 */ TArray<FNiagaraVariableCommonReference> VariadicInputs;
    /* 0x0040 */ TArray<FNiagaraVariableCommonReference> VariadicOutputs;
};

// Size: 0x28
class UNiagaraScriptBase : public UObject {
};

// Size: 0x18
struct FNiagaraShaderScriptExternalConstant {
    /* 0x0000 */ FName Type;
    /* 0x0008 */ FString Name;
};

// Size: 0x58
struct FNiagaraShaderScriptParametersMetadata {
    /* 0x0000 */ TArray<FNiagaraDataInterfaceGPUParamInfo> DataInterfaceParamInfo;
    /* 0x0010 */ TArray<FString> LooseMetadataNames;
    /* 0x0020 */ bool bExternalConstantsInterpolated;
    /* 0x0028 */ TArray<FNiagaraShaderScriptExternalConstant> ExternalConstants;
};

// Size: 0xa8
struct FSimulationStageMetaData {
    /* 0x0000 */ FName SimulationStageName;
    /* 0x0008 */ FName EnabledBinding;
    /* 0x0010 */ FIntVector ElementCount;
    /* 0x001c */ FName ElementCountXBinding;
    /* 0x0024 */ FName ElementCountYBinding;
    /* 0x002c */ FName ElementCountZBinding;
    /* 0x0034 */ ENiagaraIterationSource IterationSourceType;
    /* 0x0038 */ FName IterationDataInterface;
    /* 0x0040 */ FName IterationDirectBinding;
    /* 0x0048 */ ENiagaraSimStageExecuteBehavior ExecuteBehavior;
    /* 0x004c */ bool bWritesParticles;
    /* 0x004c */ bool bPartialParticleUpdate;
    /* 0x004c */ bool bParticleIterationStateEnabled;
    /* 0x004c */ bool bGpuIndirectDispatch;
    /* 0x0050 */ FName ParticleIterationStateBinding;
    /* 0x005c */ FIntPoint ParticleIterationStateRange;
    /* 0x0068 */ TArray<FName> OutputDestinations;
    /* 0x0078 */ TArray<FName> InputDataInterfaces;
    /* 0x0088 */ int32_t NumIterations;
    /* 0x008c */ FName NumIterationsBinding;
    /* 0x0094 */ ENiagaraGpuDispatchType GpuDispatchType;
    /* 0x0095 */ ENiagaraDirectDispatchElementType GpuDirectDispatchElementType;
    /* 0x0098 */ FIntVector GpuDispatchNumThreads;
};

enum class ENiagaraSimCacheSectionPlayMode {
    SimWithoutCache = 0,
    DisplayCacheOnly = 1,
    ENiagaraSimCacheSectionPlayMode_MAX = 2,
};

enum class ENiagaraSimCacheSectionStretchMode {
    Repeat = 0,
    TimeDilate = 1,
    ENiagaraSimCacheSectionStretchMode_MAX = 2,
};

// Size: 0x88
struct FMovieSceneNiagaraCacheParams : public FMovieSceneBaseCacheParams {
    /* 0x0020 */ FNiagaraSimCacheCreateParameters CacheParameters;
    /* 0x0078 */ UNiagaraSimCache* SimCache;
    /* 0x0080 */ bool bLockCacheToReadOnly;
    /* 0x0081 */ bool bOverrideQualityLevel;
    /* 0x0082 */ EPerQualityLevels RecordQualityLevel;
    /* 0x0083 */ ENiagaraSimCacheSectionPlayMode CacheReplayPlayMode;
    /* 0x0084 */ ENiagaraSimCacheSectionStretchMode SectionStretchMode;
};

// Size: 0x1a0
class UMovieSceneNiagaraCacheSection : public UMovieSceneBaseCacheSection {
    /* 0x0110 */ FMovieSceneNiagaraCacheParams Params;
    /* 0x0198 */ bool bCacheOutOfDate;
};

// Size: 0x20
struct FMovieSceneNiagaraCacheSectionTemplate : public FMovieSceneTrackImplementation {
    /* 0x0010 */ TArray<FMovieSceneNiagaraSectionTemplateParameter> CacheSections;
};

// Size: 0x140
class UMovieSceneNiagaraCacheTrack : public UMovieSceneNameableTrack {
    /* 0x0120 */ bool bIsRecording;
    /* 0x0128 */ TArray<UMovieSceneSection*> AnimationSections;
    /* 0x0138 */ bool bCacheRecordingEnabled;
};

// Size: 0x98
struct FMovieSceneNiagaraSectionTemplateParameter {
    /* 0x0000 */ FMovieSceneFrameRange SectionRange;
    /* 0x0010 */ FMovieSceneNiagaraCacheParams Params;
};

enum class EInAppPurchaseState {
    Unknown = 0,
    Success = 1,
    Failed = 2,
    Cancelled = 3,
    Invalid = 4,
    NotAllowed = 5,
    Restored = 6,
    AlreadyOwned = 7,
    EInAppPurchaseState_MAX = 8,
};

enum class EMPMatchOutcome {
    None = 0,
    Quit = 1,
    Won = 2,
    Lost = 3,
    Tied = 4,
    TimeExpired = 5,
    First = 6,
    Second = 7,
    Third = 8,
    Fourth = 9,
    EMPMatchOutcome_MAX = 10,
};

// Size: 0x10
struct FNamedInterface {
    /* 0x0000 */ FName InterfaceName;
    /* 0x0008 */ UObject* InterfaceObject;
};

// Size: 0x18
struct FNamedInterfaceDef {
    /* 0x0000 */ FName InterfaceName;
    /* 0x0008 */ FString InterfaceClassName;
};

// Size: 0x60
class UNamedInterfaces : public UObject {
    /* 0x0028 */ TArray<FNamedInterface> NamedInterfaces;
    /* 0x0038 */ TArray<FNamedInterfaceDef> NamedInterfaceDefs;
};

// Size: 0x28
class ITurnBasedMatchInterface : public UInterface {

    void OnMatchEnded(FString Match);
    void OnMatchReceivedTurn(FString Match, bool bDidBecomeActive);
};

// Size: 0x70
struct FArtifactSettings {
    /* 0x0000 */ FString ArtifactName;
    /* 0x0010 */ FString ClientId;
    /* 0x0020 */ FString ClientSecret;
    /* 0x0030 */ FString ProductId;
    /* 0x0040 */ FString SandboxId;
    /* 0x0050 */ FString DeploymentId;
    /* 0x0060 */ FString ClientEncryptionKey;
};

// Size: 0x30
class UEOSArtifactSettings : public UDataAsset {
};

// Size: 0xd0
class UEOSSettings : public URuntimeOptionsBase {
    /* 0x0038 */ FString CacheDir;
    /* 0x0048 */ FString DefaultArtifactName;
    /* 0x0058 */ FString RTCBackgroundMode;
    /* 0x0068 */ int32_t TickBudgetInMilliseconds;
    /* 0x006c */ bool bEnableOverlay;
    /* 0x006d */ bool bEnableSocialOverlay;
    /* 0x006e */ bool bEnableEditorOverlay;
    /* 0x006f */ bool bPreferPersistentAuth;
    /* 0x0070 */ TArray<FString> TitleStorageTags;
    /* 0x0080 */ int32_t TitleStorageReadChunkLength;
    /* 0x0088 */ TArray<FArtifactSettings> Artifacts;
    /* 0x0098 */ TArray<FString> AuthScopeFlags;
    /* 0x00a8 */ bool bUseEAS;
    /* 0x00a9 */ bool bUseEOSConnect;
    /* 0x00aa */ bool bUseEOSRTC;
    /* 0x00ab */ bool bMirrorStatsToEOS;
    /* 0x00ac */ bool bMirrorAchievementsToEOS;
    /* 0x00ad */ bool bUseEOSSessions;
    /* 0x00ae */ bool bMirrorPresenceToEAS;
    /* 0x00af */ bool bUseNewLoginFlow;
    /* 0x00b0 */ FString SteamTokenType;
    /* 0x00c0 */ FString NintendoTokenType;
};

// Size: 0xa8
class UGOGLoginCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UGOGLoginCallbackProxy* Login(UObject* WorldContextObject, APlayerController* PlayerController, FString AuthType, FString UserId, FString UserToken);
};

// Size: 0x1e50
class UNetConnectionGOG : public UNetConnection {
};

// Size: 0x1908
class UNetDriverGOG : public UNetDriver {
};

// Size: 0x28
class USteamAuthComponentModuleInterface : public UHandlerComponentFactory {
};

// Size: 0x28
class UAchievementBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void GetCachedAchievementDescription(UObject* WorldContextObject, APlayerController* PlayerController, FName AchievementId, bool& bFoundID, FText& Title, FText& LockedDescription, FText& UnlockedDescription, bool& bHidden);
    static void GetCachedAchievementProgress(UObject* WorldContextObject, APlayerController* PlayerController, FName AchievementId, bool& bFoundID, float& progress);
};

// Size: 0x68
class UAchievementQueryCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UAchievementQueryCallbackProxy* CacheAchievementDescriptions(UObject* WorldContextObject, APlayerController* PlayerController);
    static UAchievementQueryCallbackProxy* CacheAchievements(UObject* WorldContextObject, APlayerController* PlayerController);
};

// Size: 0xa8
class UAchievementWriteCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnWriteSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnWriteFailure;
    /* 0x0050 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0060 */ FMulticastInlineDelegate OnFailure;

    static UAchievementWriteCallbackProxy* WriteAchievementProgress(UObject* WorldContextObject, APlayerController* PlayerController, FName AchievementName, float progress, int32_t UserTag);
    static UAchievementWriteCallbackProxy* WriteProgress(UObject* WorldContextObject, APlayerController* PlayerController, FString AchievementName, float progress, int32_t UserTag);
};

// Size: 0x120
struct FBlueprintSessionResult {
};

// Size: 0x78
class UConnectionCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UConnectionCallbackProxy* ConnectToService(UObject* WorldContextObject, APlayerController* PlayerController);
};

// Size: 0x98
class UCreateSessionCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UCreateSessionCallbackProxy* CreateSession(UObject* WorldContextObject, APlayerController* PlayerController, int32_t PublicConnections, bool bUseLAN, bool bUseLobbiesIfAvailable);
};

// Size: 0x78
class UDestroySessionCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UDestroySessionCallbackProxy* DestroySession(UObject* WorldContextObject, APlayerController* PlayerController);
};

enum class EBeaconConnectionState {
    Invalid = 0,
    Closed = 1,
    Pending = 2,
    Open = 3,
    EBeaconConnectionState_MAX = 4,
};

enum class EClientRequestType {
    NonePending = 0,
    ExistingSessionReservation = 1,
    ReservationUpdate = 2,
    EmptyServerReservation = 3,
    Reconnect = 4,
    Abandon = 5,
    ReservationRemoveMembers = 6,
    AddOrUpdateReservation = 7,
    EClientRequestType_MAX = 8,
};

enum class EInAppPurchaseStatus {
    Invalid = 0,
    Failed = 1,
    Deferred = 2,
    Canceled = 3,
    Purchased = 4,
    Restored = 5,
    EInAppPurchaseStatus_MAX = 6,
};

enum class EOnlineProxyStoreOfferDiscountType {
    NotOnSale = 0,
    Percentage = 1,
    DiscountAmount = 2,
    PayAmount = 3,
    EOnlineProxyStoreOfferDiscountType_MAX = 4,
};

enum class EPartyReservationResult {
    NoResult = 0,
    RequestPending = 1,
    GeneralError = 2,
    PartyLimitReached = 3,
    IncorrectPlayerCount = 4,
    RequestTimedOut = 5,
    ReservationDuplicate = 6,
    ReservationNotFound = 7,
    ReservationAccepted = 8,
    ReservationDenied = 9,
    ReservationDenied_CrossPlayRestriction = 10,
    ReservationDenied_Banned = 11,
    ReservationRequestCanceled = 12,
    ReservationInvalid = 13,
    BadSessionId = 14,
    ReservationDenied_ContainsExistingPlayers = 15,
    ReservationDenied_ValidationFailed = 16,
    EPartyReservationResult_MAX = 17,
};

enum class ESpectatorClientRequestType {
    NonePending = 0,
    ExistingSessionReservation = 1,
    ReservationUpdate = 2,
    EmptyServerReservation = 3,
    Reconnect = 4,
    Abandon = 5,
    ESpectatorClientRequestType_MAX = 6,
};

enum class ESpectatorReservationResult {
    NoResult = 0,
    RequestPending = 1,
    GeneralError = 2,
    SpectatorLimitReached = 3,
    IncorrectPlayerCount = 4,
    RequestTimedOut = 5,
    ReservationDuplicate = 6,
    ReservationNotFound = 7,
    ReservationAccepted = 8,
    ReservationDenied = 9,
    ReservationDenied_CrossPlayRestriction = 10,
    ReservationDenied_Banned = 11,
    ReservationRequestCanceled = 12,
    ReservationInvalid = 13,
    BadSessionId = 14,
    ReservationDenied_ContainsExistingPlayers = 15,
    ESpectatorReservationResult_MAX = 16,
};

// Size: 0x80
class UEndMatchCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UEndMatchCallbackProxy* EndMatch(UObject* WorldContextObject, APlayerController* PlayerController, TScriptInterface<ITurnBasedMatchInterface> MatchActor, FString MatchID, uint8_t LocalPlayerOutcome, uint8_t OtherPlayersOutcome);
};

// Size: 0x78
class UEndTurnCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UEndTurnCallbackProxy* EndTurn(UObject* WorldContextObject, APlayerController* PlayerController, FString MatchID, TScriptInterface<ITurnBasedMatchInterface> TurnBasedMatchInterface);
};

// Size: 0x90
class UFindSessionsCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UFindSessionsCallbackProxy* FindSessions(UObject* WorldContextObject, APlayerController* PlayerController, int32_t MaxResults, bool bUseLAN, bool bUseLobbies);
    static int32_t GetCurrentPlayers(const FBlueprintSessionResult& Result);
    static int32_t GetMaxPlayers(const FBlueprintSessionResult& Result);
    static int32_t GetPingInMs(const FBlueprintSessionResult& Result);
    static FString GetServerName(const FBlueprintSessionResult& Result);
};

// Size: 0x88
class UFindTurnBasedMatchCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UFindTurnBasedMatchCallbackProxy* FindTurnBasedMatch(UObject* WorldContextObject, APlayerController* PlayerController, TScriptInterface<ITurnBasedMatchInterface> MatchActor, int32_t MinPlayers, int32_t MaxPlayers, int32_t PlayerGroup, bool ShowExistingMatches);
};

// Size: 0xa8
class UInAppPurchaseCallbackProxy2 : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static UInAppPurchaseCallbackProxy2* CreateProxyObjectForInAppPurchase(APlayerController* PlayerController, const FInAppPurchaseProductRequest2& ProductRequest);
    static UInAppPurchaseCallbackProxy2* CreateProxyObjectForInAppPurchaseQueryOwned(APlayerController* PlayerController);
    static UInAppPurchaseCallbackProxy2* CreateProxyObjectForInAppPurchaseUnprocessedPurchases(APlayerController* PlayerController);
};

// Size: 0xa0
class UInAppPurchaseCheckoutCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static UInAppPurchaseCheckoutCallbackProxy* CreateProxyObjectForInAppPurchaseCheckout(APlayerController* PlayerController, const FInAppPurchaseProductRequest2& ProductRequest);
};

// Size: 0x28
class UInAppPurchaseFinalizeProxy : public UObject {

    static UInAppPurchaseFinalizeProxy* CreateProxyObjectForInAppPurchaseFinalize(const FInAppPurchaseReceiptInfo2& InAppPurchaseReceipt, APlayerController* PlayerController);
};

// Size: 0xf8
struct FInAppPurchaseProductInfo2 {
    /* 0x0000 */ FString Identifier;
    /* 0x0010 */ FString TransactionIdentifier;
    /* 0x0020 */ FString DisplayName;
    /* 0x0030 */ FString DisplayDescription;
    /* 0x0040 */ FString DisplayPrice;
    /* 0x0050 */ float RawPrice;
    /* 0x0058 */ FString CurrencyCode;
    /* 0x0068 */ FString CurrencySymbol;
    /* 0x0078 */ FString DecimalSeparator;
    /* 0x0088 */ FString GroupingSeparator;
    /* 0x0098 */ FString ReceiptData;
    /* 0x00a8 */ TMap<FString, FString> DynamicFields;
};

// Size: 0x18
struct FInAppPurchaseProductRequest2 {
    /* 0x0000 */ FString ProductIdentifier;
    /* 0x0010 */ bool bIsConsumable;
};

// Size: 0x68
class UInAppPurchaseQueryCallbackProxy2 : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static UInAppPurchaseQueryCallbackProxy2* CreateProxyObjectForInAppPurchaseQuery(APlayerController* PlayerController, const TArray<FString>& ProductIdentifiers);
};

// Size: 0x40
struct FInAppPurchaseReceiptInfo2 {
    /* 0x0000 */ FString ItemName;
    /* 0x0010 */ FString ItemId;
    /* 0x0020 */ FString ValidationInfo;
    /* 0x0030 */ FString TransactionIdentifier;
};

// Size: 0x88
class UInAppPurchaseReceiptsCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static UInAppPurchaseReceiptsCallbackProxy* CreateProxyObjectForInAppPurchaseGetKnownReceipts(APlayerController* PlayerController);
    static UInAppPurchaseReceiptsCallbackProxy* CreateProxyObjectForInAppPurchaseQueryOwnedProducts(APlayerController* PlayerController);
    static UInAppPurchaseReceiptsCallbackProxy* CreateProxyObjectForInAppPurchaseRestoreOwnedProducts(APlayerController* PlayerController);
};

// Size: 0xb0
class UInAppPurchaseRestoreCallbackProxy2 : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static UInAppPurchaseRestoreCallbackProxy2* CreateProxyObjectForInAppPurchaseRestore(const TArray<FInAppPurchaseProductRequest2>& ConsumableProductFlags, APlayerController* PlayerController);
};

// Size: 0x30
struct FInAppPurchaseRestoreInfo2 {
    /* 0x0000 */ FString ItemName;
    /* 0x0010 */ FString ItemId;
    /* 0x0020 */ FString ValidationInfo;
};

// Size: 0x1eb0
class UIpConnection : public UNetConnection {
    /* 0x1e94 */ float SocketErrorDisconnectDelay;
};

// Size: 0x9a0
class UIpNetDriver : public UNetDriver {
    /* 0x08f0 */ bool LogPortUnreach;
    /* 0x08f0 */ bool AllowPlayerPortUnreach;
    /* 0x08f0 */ bool bExitOnBindFailure;
    /* 0x08f4 */ uint32_t MaxPortCountToTry;
    /* 0x08fc */ uint32_t ServerDesiredSocketReceiveBufferBytes;
    /* 0x0900 */ uint32_t ServerDesiredSocketSendBufferBytes;
    /* 0x0904 */ uint32_t ClientDesiredSocketReceiveBufferBytes;
    /* 0x0908 */ uint32_t ClientDesiredSocketSendBufferBytes;
    /* 0x0910 */ double MaxSecondsInReceive;
    /* 0x0918 */ int32_t NbPacketsBetweenReceiveTimeTest;
    /* 0x091c */ float ResolutionConnectionTimeout;
};

// Size: 0x198
class UJoinSessionCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UJoinSessionCallbackProxy* JoinSession(UObject* WorldContextObject, APlayerController* PlayerController, const FBlueprintSessionResult& SearchResult);
};

// Size: 0x28
class ULeaderboardBlueprintLibrary : public UBlueprintFunctionLibrary {

    static bool WriteLeaderboardInteger(APlayerController* PlayerController, FName StatName, int32_t StatValue);
};

// Size: 0x68
class ULeaderboardFlushCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static ULeaderboardFlushCallbackProxy* CreateProxyObjectForFlush(APlayerController* PlayerController, FName SessionName);
};

// Size: 0xa0
class ULeaderboardQueryCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0038 */ FMulticastInlineDelegate OnFailure;

    static ULeaderboardQueryCallbackProxy* CreateProxyObjectForIntQuery(APlayerController* PlayerController, FString StatName);
};

// Size: 0x68
class ULogoutCallbackProxy : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static ULogoutCallbackProxy* Logout(UObject* WorldContextObject, APlayerController* PlayerController);
};

// Size: 0x40
struct FOnlineAccountStoredCredentials {
    /* 0x0000 */ FString ID;
    /* 0x0010 */ FString Token;
    /* 0x0020 */ FString Type;
    /* 0x0030 */ TArray<uint8_t> TokenBytes;
};

// Size: 0x2d8
class AOnlineBeacon : public AActor {
    /* 0x02b0 */ float BeaconConnectionInitialTimeout;
    /* 0x02b4 */ float BeaconConnectionTimeout;
    /* 0x02b8 */ UNetDriver* NetDriver;
};

// Size: 0x338
class AOnlineBeaconClient : public AOnlineBeacon {
    /* 0x02d8 */ AOnlineBeaconHostObject* BeaconOwner;
    /* 0x02e0 */ UNetConnection* BeaconConnection;
    /* 0x02e8 */ EBeaconConnectionState ConnectionState;

    void ClientOnConnected();
};

// Size: 0x3e8
class AOnlineBeaconHost : public AOnlineBeacon {
    /* 0x02d8 */ int32_t ListenPort;
    /* 0x02dc */ bool bReuseAddressAndPort;
    /* 0x02dd */ bool bAuthRequired;
    /* 0x02e0 */ uint32_t MaxAuthTokenSize;
    /* 0x0338 */ TArray<AOnlineBeaconClient*> ClientActors;
};

// Size: 0x2d0
class AOnlineBeaconHostObject : public AActor {
    /* 0x02a8 */ FString BeaconTypeName;
    /* 0x02b8 */ UClass* ClientBeaconActorClass;
    /* 0x02c0 */ TArray<AOnlineBeaconClient*> ClientActors;
};

// Size: 0x338
class AOnlineBeaconUnitTestClient : public AOnlineBeaconClient {
};

// Size: 0x3e8
class AOnlineBeaconUnitTestHost : public AOnlineBeaconHost {
};

// Size: 0x2d0
class AOnlineBeaconUnitTestHostObject : public AOnlineBeaconHostObject {
};

// Size: 0x1eb0
class UOnlineBeaconUnitTestNetConnection : public UIpConnection {
};

// Size: 0x9a0
class UOnlineBeaconUnitTestNetDriver : public UIpNetDriver {
};

// Size: 0x198
class UOnlineEngineInterfaceImpl : public UOnlineEngineInterface {
    /* 0x0028 */ TMap<FName, FName> MappedUniqueNetIdTypes;
    /* 0x0078 */ TArray<FName> CompatibleUniqueNetIdTypes;
    /* 0x0088 */ FName VoiceSubsystemNameOverride;
    /* 0x0188 */ bool bOnlineServicesCompatibilityEnabled;
    /* 0x0190 */ UOnlineEngineInterface* OnlineServicesCompatibilityInterface;
};

// Size: 0x38
class UOnlinePIEConfig : public UObject {
    /* 0x0028 */ TArray<FString> LoginTypesAllowingDuplicates;
};

// Size: 0x50
class UOnlinePIESettings : public UDeveloperSettings {
    /* 0x0038 */ bool bOnlinePIEEnabled;
    /* 0x0040 */ TArray<FOnlineAccountStoredCredentials> Logins;
};

// Size: 0xe8
struct FOnlineProxyStoreOffer {
    /* 0x0000 */ FString OfferId;
    /* 0x0010 */ FText Title;
    /* 0x0020 */ FText Description;
    /* 0x0030 */ FText LongDescription;
    /* 0x0040 */ FText RegularPriceText;
    /* 0x0050 */ int32_t RegularPrice;
    /* 0x0058 */ FText PriceText;
    /* 0x0068 */ int32_t NumericPrice;
    /* 0x0070 */ FString CurrencyCode;
    /* 0x0080 */ FDateTime ReleaseDate;
    /* 0x0088 */ FDateTime ExpirationDate;
    /* 0x0090 */ EOnlineProxyStoreOfferDiscountType DiscountType;
    /* 0x0098 */ TMap<FString, FString> DynamicFields;
};

// Size: 0x28
class UOnlineServicesEngineInterfaceImpl : public UOnlineEngineInterface {
};

// Size: 0x1e0
class UOnlineSessionClient : public UOnlineSession {
    /* 0x01d8 */ bool bIsFromInvite;
    /* 0x01d9 */ bool bHandlingDisconnect;
};

// Size: 0x400
class APartyBeaconClient : public AOnlineBeaconClient {
    /* 0x0368 */ FString DestSessionId;
    /* 0x0378 */ FPartyReservation PendingReservation;
    /* 0x03d0 */ EClientRequestType requestType;
    /* 0x03d1 */ bool bPendingReservationSent;
    /* 0x03d2 */ bool bCancelReservation;

    void ClientCancelReservationResponse(uint8_t ReservationResponse);
    void ClientReservationResponse(uint8_t ReservationResponse);
    void ClientSendReservationFull();
    void ClientSendReservationUpdates(int32_t NumRemainingReservations);
    void ServerAddOrUpdateReservationRequest(FString SessionId, const FPartyReservation Reservation);
    void ServerCancelReservationRequest(const FUniqueNetIdRepl PartyLeader);
    void ServerRemoveMemberFromReservationRequest(FString SessionId, const FPartyReservation ReservationUpdate);
    void ServerReservationRequest(FString SessionId, const FPartyReservation Reservation);
    void ServerUpdateReservationRequest(FString SessionId, const FPartyReservation ReservationUpdate);
};

// Size: 0x20
struct FPartyBeaconCrossplayPlatformMapping {
    /* 0x0000 */ FString PlatformName;
    /* 0x0010 */ FString PlatformType;
};

// Size: 0x348
class APartyBeaconHost : public AOnlineBeaconHostObject {
    /* 0x02d0 */ UPartyBeaconState* State;
    /* 0x0338 */ bool bLogoutOnSessionTimeout;
    /* 0x0339 */ bool bIsValidationStrRequired;
    /* 0x033c */ float SessionTimeoutSecs;
    /* 0x0340 */ float TravelSessionTimeoutSecs;
};

// Size: 0xa0
class UPartyBeaconState : public UObject {
    /* 0x0028 */ FName SessionName;
    /* 0x0030 */ int32_t NumConsumedReservations;
    /* 0x0034 */ int32_t MaxReservations;
    /* 0x0038 */ int32_t NumTeams;
    /* 0x003c */ int32_t NumPlayersPerTeam;
    /* 0x0040 */ FName TeamAssignmentMethod;
    /* 0x0048 */ int32_t ReservedHostTeamNum;
    /* 0x004c */ int32_t ForceTeamNum;
    /* 0x0050 */ bool bRestrictCrossConsole;
    /* 0x0058 */ TArray<FString> PlatformCrossplayRestrictions;
    /* 0x0068 */ TArray<FPartyBeaconCrossplayPlatformMapping> PlatformTypeMapping;
    /* 0x0078 */ bool bEnableRemovalRequests;
    /* 0x0079 */ bool bRespectCompetitiveIntegrity;
    /* 0x0080 */ TArray<FPartyReservation> Reservations;
};

// Size: 0x58
struct FPartyReservation {
    /* 0x0000 */ int32_t TeamNum;
    /* 0x0008 */ FUniqueNetIdRepl PartyLeader;
    /* 0x0038 */ TArray<FPlayerReservation> PartyMembers;
    /* 0x0048 */ TArray<FPlayerReservation> RemovedPartyMembers;
};

// Size: 0x58
struct FPlayerReservation {
    /* 0x0000 */ FUniqueNetIdRepl UniqueID;
    /* 0x0030 */ FString ValidationStr;
    /* 0x0040 */ FString Platform;
    /* 0x0050 */ bool bAllowCrossplay;
    /* 0x0054 */ float ElapsedTime;
};

// Size: 0x78
class UQuitMatchCallbackProxy : public UOnlineBlueprintCallProxyBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UQuitMatchCallbackProxy* QuitMatch(UObject* WorldContextObject, APlayerController* PlayerController, FString MatchID, uint8_t Outcome, int32_t TurnTimeoutInSeconds);
};

// Size: 0x60
class UShowLoginUICallbackProxy : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFailure;

    static UShowLoginUICallbackProxy* ShowExternalLoginUI(UObject* WorldContextObject, APlayerController* InPlayerController);
};

// Size: 0x430
class ASpectatorBeaconClient : public AOnlineBeaconClient {
    /* 0x0368 */ FString DestSessionId;
    /* 0x0378 */ FSpectatorReservation PendingReservation;
    /* 0x0400 */ ESpectatorClientRequestType requestType;
    /* 0x0401 */ bool bPendingReservationSent;
    /* 0x0402 */ bool bCancelReservation;

    void ClientCancelReservationResponse(uint8_t ReservationResponse);
    void ClientReservationResponse(uint8_t ReservationResponse);
    void ClientSendReservationFull();
    void ClientSendReservationUpdates(int32_t NumRemainingReservations);
    void ServerCancelReservationRequest(const FUniqueNetIdRepl Spectator);
    void ServerReservationRequest(FString SessionId, const FSpectatorReservation Reservation);
};

// Size: 0x348
class ASpectatorBeaconHost : public AOnlineBeaconHostObject {
    /* 0x02d0 */ USpectatorBeaconState* State;
    /* 0x0338 */ bool bLogoutOnSessionTimeout;
    /* 0x0339 */ bool bIsValidationStrRequired;
    /* 0x033c */ float SessionTimeoutSecs;
    /* 0x0340 */ float TravelSessionTimeoutSecs;
};

// Size: 0x60
class USpectatorBeaconState : public UObject {
    /* 0x0028 */ FName SessionName;
    /* 0x0030 */ int32_t NumConsumedReservations;
    /* 0x0034 */ int32_t MaxReservations;
    /* 0x0038 */ bool bRestrictCrossConsole;
    /* 0x0040 */ TArray<FSpectatorReservation> Reservations;
};

// Size: 0x88
struct FSpectatorReservation {
    /* 0x0000 */ FUniqueNetIdRepl SpectatorId;
    /* 0x0030 */ FPlayerReservation Spectator;
};

// Size: 0x338
class ATestBeaconClient : public AOnlineBeaconClient {

    void ClientPing();
    void ServerPong();
};

// Size: 0x2d0
class ATestBeaconHost : public AOnlineBeaconHostObject {
};

// Size: 0x28
class UTurnBasedBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void GetIsMyTurn(UObject* WorldContextObject, APlayerController* PlayerController, FString MatchID, bool& bIsMyTurn);
    static void GetMyPlayerIndex(UObject* WorldContextObject, APlayerController* PlayerController, FString MatchID, int32_t& PlayerIndex);
    static void GetPlayerDisplayName(UObject* WorldContextObject, APlayerController* PlayerController, FString MatchID, int32_t PlayerIndex, FString& PlayerDisplayName);
    static void RegisterTurnBasedMatchInterfaceObject(UObject* WorldContextObject, APlayerController* PlayerController, UObject* Object);
};

// Size: 0x900
class UVoipListenerSynthComponent : public USynthComponent {

    bool IsIdling();
};

enum class EOodleNetResult {
    Unknown = 0,
    Success = 1,
    OodleDecodeFailed = 2,
    OodleSerializePayloadFail = 3,
    OodleBadDecompressedLength = 4,
    OodleNoDictionary = 5,
    EOodleNetResult_MAX = 6,
};

enum class EOodleNetworkEnableMode {
    AlwaysEnabled = 0,
    WhenCompressedPacketReceived = 1,
    EOodleNetworkEnableMode_MAX = 2,
};

// Size: 0xa0
class UOodleNetworkTrainerCommandlet : public UCommandlet {
    /* 0x0080 */ bool bCompressionTest;
    /* 0x0081 */ bool bWriteV5Dictionaries;
    /* 0x0084 */ int32_t HashTableSize;
    /* 0x0088 */ int32_t DictionarySize;
    /* 0x008c */ int32_t DictionaryTrials;
    /* 0x0090 */ int32_t TrialRandomness;
    /* 0x0094 */ int32_t TrialGenerations;
    /* 0x0098 */ bool bNoTrials;
};

enum class EOptimusBufferWriteType {
    Write = 0,
    WriteAtomicAdd = 1,
    WriteAtomicMin = 2,
    WriteAtomicMax = 3,
    Count = 4,
    EOptimusBufferWriteType_MAX = 5,
};

enum class EOptimusConstantType {
    Input = 0,
    Output = 1,
    EOptimusConstantType_MAX = 2,
};

enum class EOptimusDataDomainType {
    Dimensional = 0,
    Expression = 1,
    EOptimusDataDomainType_MAX = 2,
};

enum class EOptimusDataTypeFlags {
    None = 0,
    IsStructType = 1,
    ShowElements = 2,
    EOptimusDataTypeFlags_MAX = 3,
};

enum class EOptimusDataTypeUsageFlags {
    None = 0,
    Resource = 1,
    Variable = 2,
    AnimAttributes = 4,
    DataInterfaceOutput = 8,
    PinType = 16,
    PerBoneAnimAttribute = 32,
    Property = 64,
    EOptimusDataTypeUsageFlags_MAX = 65,
};

enum class EOptimusDeformerExecutionPhase {
    AfterDefaultDeformer = 0,
    OverrideDefaultDeformer = 1,
    BeforeDefaultDeformer = 2,
    EOptimusDeformerExecutionPhase_MAX = 3,
};

enum class EOptimusDeformerStatus {
    Compiled = 0,
    CompiledWithWarnings = 1,
    Modified = 2,
    HasErrors = 3,
    EOptimusDeformerStatus_MAX = 4,
};

enum class EOptimusDiagnosticLevel {
    None = 0,
    Info = 1,
    Warning = 2,
    Error = 3,
    EOptimusDiagnosticLevel_MAX = 4,
};

enum class EOptimusExecutionDomainType {
    DomainName = 0,
    Expression = 1,
    EOptimusExecutionDomainType_MAX = 2,
};

enum class EOptimusNodeGraphType {
    Setup = 0,
    Update = 1,
    ExternalTrigger = 2,
    Function = 3,
    SubGraph = 4,
    Transient = 5,
    EOptimusNodeGraphType_MAX = 6,
};

enum class EOptimusNodePinDirection {
    Unknown = 0,
    Input = 1,
    Output = 2,
    EOptimusNodePinDirection_MAX = 3,
};

enum class EOptimusNodePinStorageType {
    Value = 0,
    Resource = 1,
    EOptimusNodePinStorageType_MAX = 2,
};

enum class EOptimusPinMutability {
    Undefined = 0,
    Immutable = 1,
    Mutable = 2,
    EOptimusPinMutability_MAX = 3,
};

enum class EOptimusSkinnedMeshExecDomain {
    None = 0,
    Vertex = 1,
    Triangle = 2,
    EOptimusSkinnedMeshExecDomain_MAX = 3,
};

enum class EOptimusTerminalType {
    Unknown = 0,
    Entry = 1,
    Return = 2,
    EOptimusTerminalType_MAX = 3,
};

enum class EOptimusValueType {
    Invalid = 0,
    Constant = 1,
    Variable = 2,
    EOptimusValueType_MAX = 3,
};

enum class EOptimusValueUsage {
    None = 0,
    CPU = 1,
    GPU = 2,
    EOptimusValueUsage_MAX = 3,
};

// Size: 0x18
struct FOptimusAction {
};

// Size: 0xc0
class UOptimusActionStack : public UObject {
    /* 0x0028 */ int32_t TransactedActionIndex;
};

// Size: 0x78
class UOptimusAdvancedSkeletonDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FName SkinWeightProfile;
    /* 0x0030 */ bool bEnableLayeredSkinning;
    /* 0x0038 */ FOptimusAnimAttributeBufferArray AttributeBufferArray;
};

// Size: 0xd8
class UOptimusAdvancedSkeletonDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkeletalMeshComponent* SkeletalMesh;
    /* 0x00c8 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x28
class IOptimusAlternativeSelectedObjectProvider : public UInterface {
};

// Size: 0x10
struct FOptimusAnimAttributeArray {
    /* 0x0000 */ TArray<FOptimusAnimAttributeDescription> InnerArray;
};

// Size: 0x10
struct FOptimusAnimAttributeBufferArray {
    /* 0x0000 */ TArray<FOptimusAnimAttributeBufferDescription> InnerArray;
};

// Size: 0x68
struct FOptimusAnimAttributeBufferDescription {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FOptimusDataTypeRef DataType;
    /* 0x0040 */ FOptimusValueContainerStruct DefaultValueStruct;
    /* 0x0050 */ FString HlslId;
    /* 0x0060 */ FName PinName;
};

// Size: 0x58
class UOptimusAnimAttributeDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FOptimusAnimAttributeArray AttributeArray;
};

// Size: 0x48
class UOptimusAnimAttributeDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkeletalMeshComponent* SkeletalMesh;
};

// Size: 0x78
struct FOptimusAnimAttributeDescription {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FName BoneName;
    /* 0x0018 */ FOptimusDataTypeRef DataType;
    /* 0x0048 */ FOptimusValueContainerStruct DefaultValueStruct;
    /* 0x0058 */ FString HlslId;
    /* 0x0068 */ FName PinName;
    /* 0x0070 */ UOptimusValueContainer* DefaultValue;
};

// Size: 0x28
class UOptimusClothDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusClothDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x38
struct FOptimusCommentNodeAction_ResizeNode : public FOptimusAction {
};

// Size: 0x30
struct FOptimusComponentBindingAction_AddBinding : public FOptimusAction {
};

// Size: 0x48
struct FOptimusComponentBindingAction_RemoveBinding : public FOptimusAction {
};

// Size: 0x28
struct FOptimusComponentBindingAction_RenameBinding : public FOptimusAction {
};

// Size: 0x40
struct FOptimusComponentBindingAction_SetComponentSource : public FOptimusAction {
};

// Size: 0x28
class IOptimusComponentBindingProvider : public UInterface {
};

// Size: 0x28
class IOptimusComponentBindingReceiver : public UInterface {
};

// Size: 0x28
class UOptimusComponentSource : public UObject {
};

// Size: 0x50
class UOptimusComponentSourceBinding : public UObject {
    /* 0x0028 */ FName BindingName;
    /* 0x0030 */ UClass* ComponentType;
    /* 0x0038 */ TArray<FName> ComponentTags;
    /* 0x0048 */ bool bIsPrimaryBinding;
};

// Size: 0x38
class UOptimusComponentSourceBindingContainer : public UObject {
    /* 0x0028 */ TArray<UOptimusComponentSourceBinding*> Bindings;
};

// Size: 0x28
struct FOptimusCompoundAction : public FOptimusAction {
};

// Size: 0x28
class UOptimusComputeDataInterface : public UComputeDataInterface {
};

// Size: 0xf0
class UOptimusComputeGraph : public UComputeGraph {
    /* 0x00e0 */ TArray<TSoftObjectPtr<UOptimusNode>> KernelToNode;
};

// Size: 0x18
struct FOptimusComputeGraphInfo {
    /* 0x0000 */ EOptimusNodeGraphType GraphType;
    /* 0x0004 */ FName GraphName;
    /* 0x0010 */ UOptimusComputeGraph* ComputeGraph;
};

// Size: 0x28
class IOptimusComputeKernelDataInterface : public UInterface {
};

// Size: 0x28
class IOptimusComputeKernelProvider : public UInterface {
};

// Size: 0x28
class UOptimusConnectivityDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x40
class UOptimusConnectivityDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x48
struct FOptimusConstant {
    /* 0x0000 */ FOptimusConstantIdentifier Identifier;
    /* 0x0018 */ FOptimusConstantDefinition Definition;
    /* 0x0040 */ int32_t ComponentBindingIndex;
    /* 0x0044 */ EOptimusConstantType Type;
};

// Size: 0x10
struct FOptimusConstantContainer {
    /* 0x0000 */ TArray<FOptimusKernelConstantContainer> KernelContainers;
};

// Size: 0x28
struct FOptimusConstantDefinition {
    /* 0x0000 */ FOptimusConstantIdentifier ReferencedConstant;
    /* 0x0018 */ FString Expression;
};

// Size: 0x18
struct FOptimusConstantIdentifier {
    /* 0x0000 */ FName NodePath;
    /* 0x0008 */ FName GroupName;
    /* 0x0010 */ FName ConstantName;
};

// Size: 0xc
struct FOptimusConstantIndex {
    /* 0x0000 */ int32_t KernelIndex;
    /* 0x0004 */ EOptimusConstantType Type;
    /* 0x0008 */ int32_t ConstantIndex;
};

// Size: 0x48
class UOptimusCopyKernelDataInterface : public UComputeDataInterface {
    /* 0x0030 */ TWeakObjectPtr<UOptimusComponentSourceBinding> ComponentSourceBinding;
    /* 0x0038 */ FString NumThreadsExpression;
};

// Size: 0xb0
class UOptimusCopyKernelDataProvider : public UComputeDataProvider {
};

// Size: 0x60
class UOptimusCustomComputeKernelDataInterface : public UComputeDataInterface {
    /* 0x0030 */ TWeakObjectPtr<UOptimusComponentSourceBinding> ComponentSourceBinding;
    /* 0x0038 */ FString NumThreadsExpression;
    /* 0x0048 */ FOptimusConstantIdentifier ExecutionDomainConstantIdentifier;
};

// Size: 0xb0
class UOptimusCustomComputeKernelDataProvider : public UComputeDataProvider {
};

// Size: 0x40
struct FOptimusDataDomain {
    /* 0x0000 */ EOptimusDataDomainType Type;
    /* 0x0008 */ TArray<FName> DimensionNames;
    /* 0x0018 */ int32_t Multiplier;
    /* 0x0020 */ FString Expression;
    /* 0x0030 */ TArray<FName> LevelNames;
};

// Size: 0x50
struct FOptimusDataInterfacePropertyOverrideInfo {
    /* 0x0000 */ TMap<FName, FOptimusValueIdentifier> PinNameToValueIdMap;
};

// Size: 0x28
class IOptimusDataInterfaceProvider : public UInterface {
};

// Size: 0x50
struct FOptimusDataType {
    /* 0x0000 */ FName TypeName;
    /* 0x0008 */ FText DisplayName;
    /* 0x0018 */ FShaderValueTypeHandle ShaderValueType;
    /* 0x0020 */ int32_t ShaderValueSize;
    /* 0x0024 */ FName TypeCategory;
    /* 0x002c */ TWeakObjectPtr<UObject> TypeObject;
    /* 0x0034 */ bool bHasCustomPinColor;
    /* 0x0038 */ FLinearColor CustomPinColor;
    /* 0x0048 */ EOptimusDataTypeUsageFlags UsageFlags;
    /* 0x0049 */ EOptimusDataTypeFlags TypeFlags;
};

// Size: 0x30
struct FOptimusDataTypeRef {
    /* 0x0000 */ FName TypeName;
    /* 0x0008 */ TSoftObjectPtr<UObject> TypeObject;
};

// Size: 0x40
class UOptimusDebugDrawDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ bool bIsSupported;
    /* 0x002c */ FOptimusDebugDrawParameters DebugDrawParameters;
};

// Size: 0x48
class UOptimusDebugDrawDataProvider : public UComputeDataProvider {
    /* 0x0028 */ UPrimitiveComponent* PrimitiveComponent;
    /* 0x0030 */ FOptimusDebugDrawParameters DebugDrawParameters;
};

// Size: 0x14
struct FOptimusDebugDrawParameters {
    /* 0x0000 */ bool bForceEnable;
    /* 0x0004 */ int32_t MaxLineCount;
    /* 0x0008 */ int32_t MaxTriangleCount;
    /* 0x000c */ int32_t MaxCharacterCount;
    /* 0x0010 */ int32_t FontSize;
};

// Size: 0x1d0
class UOptimusDeformer : public UMeshDeformer {
    /* 0x0050 */ USkeletalMesh* Mesh;
    /* 0x0058 */ TArray<FOptimusComputeGraphInfo> ComputeGraphs;
    /* 0x0068 */ TMap<TWeakObjectPtr<UComputeDataInterface>, FOptimusDataInterfacePropertyOverrideInfo> DataInterfacePropertyOverrideMap;
    /* 0x00b8 */ TMap<FOptimusValueIdentifier, FOptimusValueDescription> ValueMap;
    /* 0x0108 */ UOptimusActionStack* ActionStack;
    /* 0x0110 */ EOptimusDeformerStatus Status;
    /* 0x0118 */ TArray<UOptimusNodeGraph*> Graphs;
    /* 0x0128 */ UOptimusComponentSourceBindingContainer* Bindings;
    /* 0x0130 */ UOptimusVariableContainer* Variables;
    /* 0x0138 */ UOptimusResourceContainer* Resources;

    TArray<UOptimusComponentSourceBinding*> GetComponentBindings() const;
    UOptimusComponentSourceBinding* GetPrimaryComponentBinding() const;
    TArray<UOptimusResourceDescription*> GetResources() const;
    TArray<UOptimusVariableDescription*> GetVariables() const;
};

// Size: 0x28
class IOptimusDeformerAssetPathAccessor : public UInterface {
};

// Size: 0x1a8
class UOptimusDeformerDynamicInstanceManager : public UMeshDeformerInstance {
    /* 0x0028 */ UOptimusDeformerInstance* DefaultInstance;
    /* 0x0030 */ TMap<FGuid, UOptimusDeformerInstance*> GuidToRigDeformerInstanceMap;
    /* 0x0080 */ TMap<FGuid, UOptimusDeformerInstance*> GuidToInstanceMap;
};

// Size: 0x28
class IOptimusDeformerGeometryReadbackProvider : public UInterface {
};

// Size: 0x1b8
class UOptimusDeformerInstance : public UMeshDeformerInstance {
    /* 0x0030 */ TWeakObjectPtr<UMeshComponent> MeshComponent;
    /* 0x0038 */ TWeakObjectPtr<UOptimusDeformerInstanceSettings> InstanceSettings;
    /* 0x0040 */ TArray<FOptimusDeformerInstanceExecInfo> ComputeGraphExecInfos;

    bool EnqueueTriggerGraph(FName InTriggerGraphName);
    bool SetBoolArrayVariable(FName InVariableName, const TArray<bool>& InValue);
    bool SetBoolVariable(FName InVariableName, bool InValue);
    bool SetFloatArrayVariable(FName InVariableName, const TArray<double>& InValue);
    bool SetFloatVariable(FName InVariableName, double InValue);
    bool SetInt2ArrayVariable(FName InVariableName, const TArray<FIntPoint>& InValue);
    bool SetInt2Variable(FName InVariableName, const FIntPoint& InValue);
    bool SetInt3ArrayVariable(FName InVariableName, const TArray<FIntVector>& InValue);
    bool SetInt3Variable(FName InVariableName, const FIntVector& InValue);
    bool SetInt4ArrayVariable(FName InVariableName, const TArray<FIntVector4>& InValue);
    bool SetInt4Variable(FName InVariableName, const FIntVector4& InValue);
    bool SetIntArrayVariable(FName InVariableName, const TArray<int32_t>& InValue);
    bool SetIntVariable(FName InVariableName, int32_t InValue);
    bool SetLinearColorArrayVariable(FName InVariableName, const TArray<FLinearColor>& InValue);
    bool SetLinearColorVariable(FName InVariableName, const FLinearColor& InValue);
    bool SetNameArrayVariable(FName InVariableName, const TArray<FName>& InValue);
    bool SetNameVariable(FName InVariableName, const FName& InValue);
    bool SetQuatArrayVariable(FName InVariableName, const TArray<FQuat>& InValue);
    bool SetQuatVariable(FName InVariableName, const FQuat& InValue);
    bool SetRotatorArrayVariable(FName InVariableName, const TArray<FRotator>& InValue);
    bool SetRotatorVariable(FName InVariableName, const FRotator& InValue);
    bool SetTransformArrayVariable(FName InVariableName, const TArray<FTransform>& InValue);
    bool SetTransformVariable(FName InVariableName, const FTransform& InValue);
    bool SetVector2ArrayVariable(FName InVariableName, const TArray<FVector2D>& InValue);
    bool SetVector2Variable(FName InVariableName, const FVector2D& InValue);
    bool SetVector4ArrayVariable(FName InVariableName, const TArray<FVector4>& InValue);
    bool SetVector4Variable(FName InVariableName, const FVector4& InValue);
    bool SetVectorArrayVariable(FName InVariableName, const TArray<FVector>& InValue);
    bool SetVectorVariable(FName InVariableName, const FVector& InValue);
};

// Size: 0x28
class IOptimusDeformerInstanceAccessor : public UInterface {
};

// Size: 0x10
struct FOptimusDeformerInstanceComponentBinding {
    /* 0x0000 */ FName ProviderName;
    /* 0x0008 */ FName ComponentName;
};

// Size: 0x30
struct FOptimusDeformerInstanceExecInfo {
    /* 0x0000 */ FName GraphName;
    /* 0x0008 */ EOptimusNodeGraphType GraphType;
    /* 0x0010 */ UComputeGraph* ComputeGraph;
    /* 0x0018 */ FComputeGraphInstance ComputeGraphInstance;
};

// Size: 0x40
class UOptimusDeformerInstanceSettings : public UMeshDeformerInstanceSettings {
    /* 0x0028 */ TWeakObjectPtr<UOptimusDeformer> Deformer;
    /* 0x0030 */ TArray<FOptimusDeformerInstanceComponentBinding> Bindings;
};

// Size: 0x28
class IOptimusDeprecatedExecutionDataInterface : public UInterface {
};

// Size: 0x28
class UOptimusDuplicateVerticesDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusDuplicateVerticesDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x20
struct FOptimusExecutionDomain {
    /* 0x0000 */ EOptimusExecutionDomainType Type;
    /* 0x0004 */ FName Name;
    /* 0x0010 */ FString Expression;
};

// Size: 0x28
class IOptimusExecutionDomainProvider : public UInterface {
};

// Size: 0x18
struct FOptimusFunctionGraphIdentifier {
    /* 0x0000 */ UOptimusDeformer* Asset;
    /* 0x0008 */ FGuid Guid;
};

// Size: 0x168
class UOptimusFunctionNodeGraph : public UOptimusNodeSubGraph {
    /* 0x0148 */ FName Category;
    /* 0x0150 */ FName AccessSpecifier;
    /* 0x0158 */ FGuid Guid;

    TArray<FName> GetAccessSpecifierOptions() const;
};

// Size: 0x38
struct FOptimusFunctionNodeGraphHeader {
    /* 0x0000 */ TSoftObjectPtr<UOptimusFunctionNodeGraph> GraphPath;
    /* 0x0028 */ FName FunctionName;
    /* 0x0030 */ FName Category;
};

// Size: 0x10
struct FOptimusFunctionNodeGraphHeaderArray {
    /* 0x0000 */ TArray<FOptimusFunctionNodeGraphHeader> Headers;
};

// Size: 0x20
struct FOptimusFunctionNodeGraphHeaderWithGuid {
    /* 0x0000 */ FGuid FunctionGraphGuid;
    /* 0x0010 */ FName FunctionName;
    /* 0x0018 */ FName Category;
};

// Size: 0x10
struct FOptimusFunctionNodeGraphHeaderWithGuidArray {
    /* 0x0000 */ TArray<FOptimusFunctionNodeGraphHeaderWithGuid> Headers;
};

// Size: 0x50
struct FOptimusFunctionReferenceData {
    /* 0x0000 */ TMap<FSoftObjectPath, FOptimusFunctionReferenceNodeSet> FunctionReferences;
};

// Size: 0x50
struct FOptimusFunctionReferenceNodeSet {
    /* 0x0000 */ TSet<TSoftObjectPtr<UOptimusNode_FunctionReference>> Nodes;
};

// Size: 0x28
class IOptimusGeneratedClassDefiner : public UInterface {
};

// Size: 0x40
class UOptimusGraphDataInterface : public UComputeDataInterface {
    /* 0x0028 */ TArray<FOptimusGraphVariableDescription> Variables;
    /* 0x0038 */ int32_t ParameterBufferSize;
};

// Size: 0x68
class UOptimusGraphDataProvider : public UComputeDataProvider {
    /* 0x0030 */ UMeshComponent* MeshComponent;
    /* 0x0038 */ TArray<FOptimusGraphVariableDescription> Variables;
    /* 0x0060 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x88
struct FOptimusGraphVariableDescription {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FShaderValueTypeHandle ValueType;
    /* 0x0018 */ FOptimusValueIdentifier ValueId;
    /* 0x0024 */ int32_t Offset;
    /* 0x0030 */ TArray<uint8_t> Value;
    /* 0x0040 */ FShaderValueContainer ShaderValue;
    /* 0x0060 */ TSoftObjectPtr<UObject> SourceObject;
};

// Size: 0x28
class UOptimusHalfEdgeDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x50
class UOptimusHalfEdgeDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x98
class UOptimusImplicitPersistentBufferDataInterface : public UOptimusRawBufferDataInterface {
    /* 0x0090 */ bool bZeroInitForAtomicWrites;
};

// Size: 0xe0
class UOptimusImplicitPersistentBufferDataProvider : public UOptimusRawBufferDataProvider {
};

// Size: 0x70
struct FOptimusKernelConstantContainer {
    /* 0x0000 */ TArray<FOptimusConstant> InputConstants;
    /* 0x0010 */ TArray<FOptimusConstant> OutputConstants;
    /* 0x0020 */ TMap<FName, int32_t> GroupNameToBindingIndex;
};

// Size: 0xa8
class UOptimusKernelSource : public UComputeKernelSource {
    /* 0x0098 */ FString Source;
};

// Size: 0x30
class UOptimusLoopTerminalDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ uint32_t Index;
    /* 0x002c */ uint32_t Count;
};

// Size: 0x30
class UOptimusLoopTerminalDataProvider : public UComputeDataProvider {
};

// Size: 0x18
struct FOptimusLoopTerminalInfo {
    /* 0x0000 */ int32_t Count;
    /* 0x0008 */ FOptimusParameterBindingArray Bindings;
};

// Size: 0x28
class UOptimusMorphTargetDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusMorphTargetDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x108
class UOptimusNode : public UObject {
    /* 0x0030 */ FText DisplayName;
    /* 0x0040 */ FVector2D GraphPosition;
    /* 0x0050 */ TArray<UOptimusNodePin*> Pins;
    /* 0x0060 */ TSet<FName> ExpandedPins;
    /* 0x00b0 */ EOptimusDiagnosticLevel DiagnosticLevel;

    FText GetDisplayName() const;
    FVector2D GetGraphPosition() const;
    FName GetNodeCategory() const;
    FName GetNodeName() const;
    bool SetGraphPosition(const FVector2D& InPosition);
};

// Size: 0xb8
struct FOptimusNodeAction_AddGroupingPin : public FOptimusNodeAction_AddRemovePin {
};

// Size: 0xb8
struct FOptimusNodeAction_AddPin : public FOptimusNodeAction_AddRemovePin {
};

// Size: 0xb8
struct FOptimusNodeAction_AddRemovePin : public FOptimusAction {
};

// Size: 0x38
struct FOptimusNodeAction_MoveNode : public FOptimusAction {
};

// Size: 0x48
struct FOptimusNodeAction_MovePin : public FOptimusAction {
};

// Size: 0xb8
struct FOptimusNodeAction_RemovePin : public FOptimusNodeAction_AddRemovePin {
};

// Size: 0x48
struct FOptimusNodeAction_RenameNode : public FOptimusAction {
};

// Size: 0xa8
struct FOptimusNodeAction_SetPinDataDomain : public FOptimusAction {
};

// Size: 0x38
struct FOptimusNodeAction_SetPinName : public FOptimusAction {
};

// Size: 0x38
struct FOptimusNodeAction_SetPinType : public FOptimusAction {
};

// Size: 0x48
struct FOptimusNodeAction_SetPinValue : public FOptimusAction {
};

// Size: 0x28
class IOptimusNodeAdderPinProvider : public UInterface {
};

// Size: 0x28
class IOptimusNodeFunctionLibraryOwner : public UInterface {
};

// Size: 0x90
class UOptimusNodeGraph : public UObject {
    /* 0x0030 */ EOptimusNodeGraphType GraphType;
    /* 0x0038 */ TArray<UOptimusNode*> Nodes;
    /* 0x0048 */ TArray<UOptimusNodeLink*> links;
    /* 0x0058 */ TArray<UOptimusNodePair*> NodePairs;
    /* 0x0068 */ TArray<UOptimusNodeGraph*> Subgraphs;

    UOptimusNode* AddCommentNode(const FVector2D& InPosition, const FVector2D& InSize, const FLinearColor& InColor);
    UOptimusNode* AddComponentBindingGetNode(UOptimusComponentSourceBinding* InComponentBinding, const FVector2D& InPosition);
    UOptimusNode* AddDataInterfaceNode(const UClass* InDataInterfaceClass, const FVector2D& InPosition);
    UOptimusNode* AddFunctionReferenceNode(UOptimusFunctionNodeGraph* InFunctionGraph, const FVector2D& InPosition);
    bool AddLink(UOptimusNodePin* InNodeOutputPin, UOptimusNodePin* InNodeInputPin);
    TArray<UOptimusNode*> AddLoopTerminalNodes(const FVector2D& InPosition);
    UOptimusNode* AddNode(const UClass* InNodeClass, const FVector2D& InPosition);
    UOptimusNode* AddResourceGetNode(UOptimusResourceDescription* InResourceDesc, const FVector2D& InPosition);
    UOptimusNode* AddResourceNode(UOptimusResourceDescription* InResourceDesc, const FVector2D& InPosition);
    UOptimusNode* AddResourceSetNode(UOptimusResourceDescription* InResourceDesc, const FVector2D& InPosition);
    UOptimusNode* AddValueNode(FOptimusDataTypeRef InDataTypeRef, const FVector2D& InPosition);
    UOptimusNode* AddVariableGetNode(UOptimusVariableDescription* InVariableDesc, const FVector2D& InPosition);
    UOptimusNode* CollapseNodesToFunction(const TArray<UOptimusNode*>& InNodes);
    UOptimusNode* CollapseNodesToSubGraph(const TArray<UOptimusNode*>& InNodes);
    UOptimusNode* ConvertCustomKernelToFunction(UOptimusNode* InCustomKernel);
    UOptimusNode* ConvertFunctionToCustomKernel(UOptimusNode* InKernelFunction);
    bool ConvertToFunction(UOptimusNode* InSubGraphNode);
    bool ConvertToSubGraph(UOptimusNode* InFunctionNode);
    UOptimusNode* DuplicateNode(UOptimusNode* InNode, const FVector2D& InPosition);
    bool DuplicateNodes(const TArray<UOptimusNode*>& InNodes, const FVector2D& InPosition);
    TArray<UOptimusNode*> ExpandCollapsedNodes(UOptimusNode* InGraphReferenceNode);
    int32_t GetGraphIndex() const;
    EOptimusNodeGraphType GetGraphType() const;
    TArray<UOptimusNodeGraph*> GetGraphs() const;
    bool IsCustomKernel(UOptimusNode* InNode) const;
    bool IsExecutionGraph() const;
    bool IsFunctionGraph() const;
    bool IsFunctionReference(UOptimusNode* InNode) const;
    bool IsKernelFunction(UOptimusNode* InNode) const;
    bool IsSubGraphReference(UOptimusNode* InNode) const;
    bool MoveGraphDirect(UOptimusNodeGraph* InGraph, int32_t InInsertBefore);
    bool RemoveAllLinks(UOptimusNodePin* InNodePin);
    bool RemoveLink(UOptimusNodePin* InNodeOutputPin, UOptimusNodePin* InNodeInputPin);
    bool RemoveNode(UOptimusNode* InNode);
    bool RemoveNodes(const TArray<UOptimusNode*>& InNodes);
    bool RenameGraph(UOptimusNodeGraph* InGraph, FString InNewName);
    bool RenameGraphDirect(UOptimusNodeGraph* InGraph, FString InNewName);
};

// Size: 0x80
struct FOptimusNodeGraphAction_AddGraph : public FOptimusAction {
};

// Size: 0x40
struct FOptimusNodeGraphAction_AddLink : public FOptimusNodeGraphAction_AddRemoveLink {
};

// Size: 0x90
struct FOptimusNodeGraphAction_AddNode : public FOptimusAction {
};

// Size: 0x58
struct FOptimusNodeGraphAction_AddNodePair : public FOptimusNodeGraphAction_AddRemoveNodePair {
};

// Size: 0x40
struct FOptimusNodeGraphAction_AddRemoveLink : public FOptimusAction {
};

// Size: 0x38
struct FOptimusNodeGraphAction_AddRemoveNodePair : public FOptimusAction {
};

// Size: 0xa0
struct FOptimusNodeGraphAction_ConnectAdderPin : public FOptimusNodeGraphAction_AddRemoveLink {
};

// Size: 0xa0
struct FOptimusNodeGraphAction_DuplicateNode : public FOptimusAction {
};

// Size: 0xb0
struct FOptimusNodeGraphAction_PackageKernelFunction : public FOptimusAction {
};

// Size: 0x58
struct FOptimusNodeGraphAction_RemoveGraph : public FOptimusAction {
};

// Size: 0x40
struct FOptimusNodeGraphAction_RemoveLink : public FOptimusNodeGraphAction_AddRemoveLink {
};

// Size: 0x60
struct FOptimusNodeGraphAction_RemoveNode : public FOptimusAction {
};

// Size: 0x38
struct FOptimusNodeGraphAction_RemoveNodePair : public FOptimusNodeGraphAction_AddRemoveNodePair {
};

// Size: 0x48
struct FOptimusNodeGraphAction_RenameGraph : public FOptimusAction {
};

// Size: 0x60
struct FOptimusNodeGraphAction_UnpackageKernelFunction : public FOptimusAction {
};

// Size: 0x28
class IOptimusNodeGraphCollectionOwner : public UInterface {
};

// Size: 0x28
class IOptimusNodeGraphProvider : public UInterface {
};

// Size: 0x38
class UOptimusNodeLink : public UObject {
    /* 0x0028 */ UOptimusNodePin* NodeOutputPin;
    /* 0x0030 */ UOptimusNodePin* NodeInputPin;
};

// Size: 0x38
class UOptimusNodePair : public UObject {
    /* 0x0028 */ UOptimusNode* First;
    /* 0x0030 */ UOptimusNode* Second;
};

// Size: 0x28
class IOptimusNodePairProvider : public UInterface {
};

// Size: 0xb8
class UOptimusNodePin : public UObject {
    /* 0x0028 */ bool bIsGroupingPin;
    /* 0x0029 */ EOptimusNodePinDirection Direction;
    /* 0x002a */ EOptimusNodePinStorageType StorageType;
    /* 0x0030 */ FOptimusDataDomain DataDomain;
    /* 0x0070 */ FOptimusDataTypeRef DataType;
    /* 0x00a0 */ TArray<UOptimusNodePin*> SubPins;
};

// Size: 0x28
class IOptimusNodePinRouter : public UInterface {
};

// Size: 0x148
class UOptimusNodeSubGraph : public UOptimusNodeGraph {
    /* 0x0098 */ FOptimusParameterBindingArray InputBindings;
    /* 0x00a8 */ FOptimusParameterBindingArray OutputBindings;
};

// Size: 0x28
class IOptimusNodeSubGraphReferencer : public UInterface {
};

// Size: 0x138
class UOptimusNode_AnimAttributeDataInterface : public UOptimusNode_DataInterface {
};

// Size: 0x150
class UOptimusNode_Comment : public UOptimusNode {
    /* 0x0108 */ FLinearColor CommentColor;
    /* 0x0118 */ int32_t FontSize;
    /* 0x0120 */ FString Comment;
    /* 0x0130 */ bool bBubbleVisible;
    /* 0x0131 */ bool bColorBubble;
    /* 0x0134 */ FDeprecateSlateVector2D Size;
};

// Size: 0x130
class UOptimusNode_ComponentSource : public UOptimusNode {
    /* 0x0118 */ UOptimusComponentSourceBinding* Binding;
    /* 0x0120 */ FOptimusNode_ComponentSource_DuplicationInfo DuplicationInfo;
};

// Size: 0x10
struct FOptimusNode_ComponentSource_DuplicationInfo {
    /* 0x0000 */ FName BindingName;
    /* 0x0008 */ UClass* ComponentType;
};

// Size: 0x110
class UOptimusNode_ComputeKernelBase : public UOptimusNode {
};

// Size: 0x110
class UOptimusNode_ComputeKernelFunction : public UOptimusNode_ComputeKernelBase {
};

// Size: 0x270
class UOptimusNode_ComputeKernelFunctionGeneratorClass : public UClass {
    /* 0x0200 */ FName Category;
    /* 0x0208 */ FName KernelName;
    /* 0x0210 */ FOptimusExecutionDomain ExecutionDomain;
    /* 0x0230 */ FIntVector GroupSize;
    /* 0x0240 */ TArray<FOptimusParameterBinding> InputBindings;
    /* 0x0250 */ TArray<FOptimusParameterBinding> OutputBindings;
    /* 0x0260 */ FString ShaderSource;
};

// Size: 0x120
class UOptimusNode_ConstantValue : public UOptimusNode {
};

// Size: 0x230
class UOptimusNode_ConstantValueGeneratorClass : public UClass {
    /* 0x0200 */ FOptimusDataTypeRef DataType;
};

// Size: 0x200
class UOptimusNode_CustomComputeKernel : public UOptimusNode_ComputeKernelBase {
    /* 0x0130 */ FName Category;
    /* 0x0138 */ FOptimusValidatedName KernelName;
    /* 0x0140 */ FOptimusExecutionDomain ExecutionDomain;
    /* 0x0160 */ FIntVector GroupSize;
    /* 0x0170 */ TArray<FOptimus_ShaderBinding> Parameters;
    /* 0x0180 */ TArray<FOptimusParameterBinding> InputBindings;
    /* 0x0190 */ TArray<FOptimusParameterBinding> OutputBindings;
    /* 0x01a0 */ FOptimusParameterBindingArray InputBindingArray;
    /* 0x01b0 */ FOptimusParameterBindingArray OutputBindingArray;
    /* 0x01c0 */ TArray<FOptimusSecondaryInputBindingsGroup> SecondaryInputBindingGroups;
    /* 0x01d0 */ TArray<UComputeSource*> AdditionalSources;
    /* 0x01e0 */ FOptimusShaderText ShaderSource;
};

// Size: 0x138
class UOptimusNode_DataInterface : public UOptimusNode {
    /* 0x0128 */ UClass* DataInterfaceClass;
    /* 0x0130 */ UOptimusComputeDataInterface* DataInterfaceData;
};

// Size: 0x178
class UOptimusNode_FunctionReference : public UOptimusNode {
    /* 0x0120 */ FOptimusFunctionGraphIdentifier FunctionGraphIdentifier;
    /* 0x0138 */ TWeakObjectPtr<UOptimusNodePin> DefaultComponentPin;
    /* 0x0140 */ TWeakObjectPtr<UOptimusFunctionNodeGraph> ResolvedFunctionGraph;
    /* 0x0148 */ TSoftObjectPtr<UOptimusFunctionNodeGraph> FunctionGraph;
};

// Size: 0x1b0
class UOptimusNode_GetResource : public UOptimusNode_ResourceAccessorBase {
};

// Size: 0x170
class UOptimusNode_GetVariable : public UOptimusNode {
    /* 0x0120 */ TWeakObjectPtr<UOptimusVariableDescription> VariableDesc;
    /* 0x0128 */ FOptimusNode_GetVariable_DuplicationInfo DuplicationInfo;
};

// Size: 0x48
struct FOptimusNode_GetVariable_DuplicationInfo {
    /* 0x0000 */ FName VariableName;
    /* 0x0008 */ FOptimusDataTypeRef DataType;
    /* 0x0038 */ FString DefaultValue;
};

// Size: 0x140
class UOptimusNode_GraphTerminal : public UOptimusNode {
    /* 0x0128 */ EOptimusTerminalType TerminalType;
    /* 0x012c */ TWeakObjectPtr<UOptimusNodePin> DefaultComponentPin;
};

// Size: 0x170
class UOptimusNode_LoopTerminal : public UOptimusNode {
    /* 0x0130 */ EOptimusTerminalType TerminalType;
    /* 0x0138 */ FOptimusLoopTerminalInfo LoopInfo;
    /* 0x0150 */ UOptimusNodePin* IndexPin;
    /* 0x0158 */ UOptimusNodePin* CountPin;
    /* 0x0160 */ TArray<FOptimusPinPairInfo> PinPairInfos;
};

// Size: 0x1b0
class UOptimusNode_Resource : public UOptimusNode_ResourceAccessorBase {
};

// Size: 0x1b0
class UOptimusNode_ResourceAccessorBase : public UOptimusNode {
    /* 0x0128 */ TWeakObjectPtr<UOptimusResourceDescription> ResourceDesc;
    /* 0x0130 */ EOptimusBufferWriteType WriteType;
    /* 0x0138 */ FOptimusNode_ResourceAccessorBase_DuplicationInfo DuplicationInfo;
};

// Size: 0x78
struct FOptimusNode_ResourceAccessorBase_DuplicationInfo {
    /* 0x0000 */ FName ResourceName;
    /* 0x0008 */ FOptimusDataTypeRef DataType;
    /* 0x0038 */ FOptimusDataDomain DataDomain;
};

// Size: 0x1b0
class UOptimusNode_SetResource : public UOptimusNode_ResourceAccessorBase {
};

// Size: 0x138
class UOptimusNode_SubGraphReference : public UOptimusNode {
    /* 0x0120 */ FName SubgraphName;
    /* 0x0128 */ TWeakObjectPtr<UOptimusNodePin> DefaultComponentPin;
};

// Size: 0x28
class IOptimusNonCollapsibleNode : public UInterface {
};

// Size: 0x28
class IOptimusNonCopyableNode : public UInterface {
};

// Size: 0x28
class IOptimusOutputBufferWriter : public UInterface {
};

// Size: 0x80
struct FOptimusParameterBinding {
    /* 0x0000 */ FOptimusValidatedName Name;
    /* 0x0008 */ FOptimusDataTypeRef DataType;
    /* 0x0038 */ FOptimusDataDomain DataDomain;
    /* 0x0078 */ bool bSupportAtomicIfCompatibleDataType;
    /* 0x0079 */ bool bSupportRead;
};

// Size: 0x10
struct FOptimusParameterBindingArray {
    /* 0x0000 */ TArray<FOptimusParameterBinding> InnerArray;
};

// Size: 0x28
class IOptimusParameterBindingProvider : public UInterface {
};

// Size: 0x28
class IOptimusPathResolver : public UInterface {
};

// Size: 0x98
class UOptimusPersistentBufferDataInterface : public UOptimusRawBufferDataInterface {
    /* 0x0090 */ FName ResourceName;
};

// Size: 0xd8
class UOptimusPersistentBufferDataProvider : public UOptimusRawBufferDataProvider {
};

// Size: 0x28
class IOptimusPersistentBufferProvider : public UInterface {
};

// Size: 0x28
class IOptimusPinMutabilityDefiner : public UInterface {
};

// Size: 0x20
struct FOptimusPinPairInfo {
    /* 0x0000 */ TArray<FName> InputPinPath;
    /* 0x0010 */ TArray<FName> OutputPinPath;
};

// Size: 0x28
class IOptimusPropertyPinProvider : public UInterface {
};

// Size: 0x90
class UOptimusRawBufferDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FShaderValueTypeHandle ValueType;
    /* 0x0030 */ FOptimusDataDomain DataDomain;
    /* 0x0070 */ TWeakObjectPtr<UOptimusComponentSourceBinding> ComponentSourceBinding;
    /* 0x0078 */ FOptimusConstantIdentifier DomainConstantIdentifier;
};

// Size: 0xb8
class UOptimusRawBufferDataProvider : public UComputeDataProvider {
};

// Size: 0x90
struct FOptimusResourceAction_AddResource : public FOptimusAction {
};

// Size: 0x68
struct FOptimusResourceAction_RemoveResource : public FOptimusAction {
};

// Size: 0x28
struct FOptimusResourceAction_RenameResource : public FOptimusAction {
};

// Size: 0xa0
struct FOptimusResourceAction_SetDataDomain : public FOptimusAction {
};

// Size: 0x80
struct FOptimusResourceAction_SetDataType : public FOptimusAction {
};

// Size: 0x38
class UOptimusResourceContainer : public UObject {
    /* 0x0028 */ TArray<UOptimusResourceDescription*> Descriptions;
};

// Size: 0xb0
class UOptimusResourceDescription : public UObject {
    /* 0x0028 */ FName ResourceName;
    /* 0x0030 */ FOptimusDataTypeRef DataType;
    /* 0x0060 */ TWeakObjectPtr<UOptimusComponentSourceBinding> ComponentBinding;
    /* 0x0068 */ FOptimusDataDomain DataDomain;
    /* 0x00a8 */ UOptimusPersistentBufferDataInterface* DataInterface;
};

// Size: 0x28
class UOptimusSceneComponentSource : public UOptimusComponentSource {
};

// Size: 0x28
class UOptimusSceneDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusSceneDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USceneComponent* SceneComponent;
};

// Size: 0x18
struct FOptimusSecondaryInputBindingsGroup {
    /* 0x0000 */ FOptimusValidatedName GroupName;
    /* 0x0008 */ FOptimusParameterBindingArray BindingArray;
};

// Size: 0x20
struct FOptimusShaderText {
    /* 0x0000 */ FString Declarations;
    /* 0x0010 */ FString ShaderText;
};

// Size: 0x28
class IOptimusShaderTextProvider : public UInterface {
};

// Size: 0x28
class UOptimusSkeletalMeshComponentSource : public UOptimusSkinnedMeshComponentSource {
};

// Size: 0x28
class UOptimusSkeletonDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusSkeletonDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x80
class UOptimusSkinWeightsAsVertexMaskDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FName SkinWeightProfile;
    /* 0x0030 */ TArray<FName> BoneNames;
    /* 0x0040 */ int32_t ExpandTowardsRoot;
    /* 0x0044 */ int32_t ExpandTowardsLeaf;
    /* 0x0048 */ bool bDebugDrawIncludedBones;
    /* 0x004c */ FColor DebugDrawColor;
};

// Size: 0xd8
class UOptimusSkinWeightsAsVertexMaskDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkeletalMeshComponent* SkeletalMesh;
    /* 0x00c8 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x28
class UOptimusSkinnedMeshComponentSource : public UOptimusComponentSource {
};

// Size: 0x28
class UOptimusSkinnedMeshDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x30
class UOptimusSkinnedMeshDataProvider : public UComputeDataProvider {
    /* 0x0028 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x38
class UOptimusSkinnedMeshExecDataInterface : public UOptimusComputeDataInterface {
    /* 0x0030 */ EOptimusSkinnedMeshExecDomain Domain;
};

// Size: 0x28
class UOptimusSkinnedMeshReadDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x50
class UOptimusSkinnedMeshReadDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkinnedMeshComponent* SkinnedMesh;
    /* 0x0048 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x38
class UOptimusSkinnedMeshVertexAttributeDataInterface : public UOptimusComputeDataInterface {
    /* 0x0028 */ FName AttributeName;
    /* 0x0030 */ float DefaultValue;
};

// Size: 0x58
class UOptimusSkinnedMeshVertexAttributeDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkinnedMeshComponent* SkinnedMeshComponent;
    /* 0x0038 */ FName AttributeName;
    /* 0x0040 */ float DefaultValue;
    /* 0x0050 */ UOptimusDeformerInstance* DeformerInstance;
};

// Size: 0x30
class UOptimusSkinnedMeshWriteDataInterface : public UOptimusComputeDataInterface {
};

// Size: 0x48
class UOptimusSkinnedMeshWriteDataProvider : public UComputeDataProvider {
    /* 0x0030 */ USkinnedMeshComponent* SkinnedMesh;
};

// Size: 0x50
class UOptimusSource : public UComputeSource {
    /* 0x0040 */ FString SourceText;
};

// Size: 0x98
class UOptimusTransientBufferDataInterface : public UOptimusRawBufferDataInterface {
    /* 0x0090 */ bool bZeroInitForAtomicWrites;
};

// Size: 0xc0
class UOptimusTransientBufferDataProvider : public UOptimusRawBufferDataProvider {
};

// Size: 0x28
class IOptimusUnnamedNodePinProvider : public UInterface {
};

// Size: 0x8
struct FOptimusValidatedName {
    /* 0x0000 */ FName Name;
};

// Size: 0x28
class UOptimusValueContainer : public UObject {
};

// Size: 0x230
class UOptimusValueContainerGeneratorClass : public UClass {
    /* 0x0200 */ FOptimusDataTypeRef DataType;
};

// Size: 0x10
struct FOptimusValueContainerStruct {
    /* 0x0000 */ FInstancedPropertyBag Value;
};

// Size: 0x68
struct FOptimusValueDescription {
    /* 0x0000 */ FOptimusDataTypeRef DataType;
    /* 0x0030 */ EOptimusValueUsage ValueUsage;
    /* 0x0038 */ FOptimusValueContainerStruct Value;
    /* 0x0048 */ FShaderValueContainer ShaderValue;
};

// Size: 0xc
struct FOptimusValueIdentifier {
    /* 0x0000 */ EOptimusValueType Type;
    /* 0x0004 */ FName Name;
};

// Size: 0x28
class IOptimusValueProvider : public UInterface {
};

// Size: 0x50
struct FOptimusVariableAction_AddVariable : public FOptimusAction {
};

// Size: 0x78
struct FOptimusVariableAction_RemoveVariable : public FOptimusAction {
};

// Size: 0x28
struct FOptimusVariableAction_RenameVariable : public FOptimusAction {
};

// Size: 0x80
struct FOptimusVariableAction_SetDataType : public FOptimusAction {
};

// Size: 0x38
class UOptimusVariableContainer : public UObject {
    /* 0x0028 */ TArray<UOptimusVariableDescription*> Descriptions;
};

// Size: 0xb8
class UOptimusVariableDescription : public UObject {
    /* 0x0028 */ FGuid Guid;
    /* 0x0038 */ FName VariableName;
    /* 0x0040 */ FOptimusDataTypeRef DataType;
    /* 0x0070 */ FOptimusValueContainerStruct DefaultValueStruct;
    /* 0x0080 */ FShaderValueContainer CachedShaderValue;
    /* 0x00a0 */ TArray<uint8_t> ValueData;
    /* 0x00b0 */ UOptimusValueContainer* DefaultValue;
};

// Size: 0x18
struct FOptimusVariableMetaDataEntry {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FString Value;
};

// Size: 0x38
struct FOptimus_ShaderBinding {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FOptimusDataTypeRef DataType;
};

// Size: 0x20
struct FRigUnit_AddOptimusDeformer : public FRigUnitMutable {
    /* 0x0010 */ FGuid DeformerInstanceGuid;
};

// Size: 0x40
struct FRigVMTrait_OptimusDeformer : public FRigVMTrait {
    /* 0x0018 */ TSoftObjectPtr<UOptimusDeformer> DeformerGraph;
};

// Size: 0x30
struct FRigVMTrait_OptimusDeformerSettings : public FRigVMTrait {
    /* 0x0018 */ EOptimusDeformerExecutionPhase ExecutionPhase;
    /* 0x001c */ int32_t ExecutionGroup;
    /* 0x0020 */ bool DeformChildComponents;
    /* 0x0024 */ FName ExcludeChildComponentsWithTag;
};

// Size: 0x18
struct FRigVMTrait_OptimusVariableBase : public FRigVMTrait {
};

// Size: 0x28
struct FRigVMTrait_SetDeformerBoolArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<bool> Value;
};

// Size: 0x20
struct FRigVMTrait_SetDeformerBoolVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ bool Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerFloatArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<double> Value;
};

// Size: 0x20
struct FRigVMTrait_SetDeformerFloatVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ double Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerInt2ArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FIntPoint> Value;
};

// Size: 0x20
struct FRigVMTrait_SetDeformerInt2Variable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FIntPoint Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerInt3ArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FIntVector> Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerInt3Variable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FIntVector Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerInt4ArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FIntVector4> Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerInt4Variable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FIntVector4 Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerIntArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<int32_t> Value;
};

// Size: 0x20
struct FRigVMTrait_SetDeformerIntVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ int32_t Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerLinearColorArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FLinearColor> Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerLinearColorVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FLinearColor Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerNameArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FName> Value;
};

// Size: 0x20
struct FRigVMTrait_SetDeformerNameVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FName Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerQuatArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FQuat> Value;
};

// Size: 0x40
struct FRigVMTrait_SetDeformerQuatVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0020 */ FQuat Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerRotatorArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FRotator> Value;
};

// Size: 0x30
struct FRigVMTrait_SetDeformerRotatorVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FRotator Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerTransformArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FTransform> Value;
};

// Size: 0x80
struct FRigVMTrait_SetDeformerTransformVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0020 */ FTransform Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerVector2ArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FVector2D> Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerVector2Variable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FVector2D Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerVector4ArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FVector4> Value;
};

// Size: 0x40
struct FRigVMTrait_SetDeformerVector4Variable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0020 */ FVector4 Value;
};

// Size: 0x28
struct FRigVMTrait_SetDeformerVectorArrayVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ TArray<FVector> Value;
};

// Size: 0x30
struct FRigVMTrait_SetDeformerVectorVariable : public FRigVMTrait_OptimusVariableBase {
    /* 0x0018 */ FVector Value;
};

enum class EOptimusDefaultDeformerMode {
    Never = 0,
    OptIn = 1,
    Always = 2,
    EOptimusDefaultDeformerMode_MAX = 3,
};

// Size: 0x90
class UOptimusSettings : public UDeveloperSettings {
    /* 0x0038 */ EOptimusDefaultDeformerMode DefaultMode;
    /* 0x0040 */ TSoftObjectPtr<UMeshDeformer> DefaultDeformer;
    /* 0x0068 */ TSoftObjectPtr<UMeshDeformer> DefaultRecomputeTangentDeformer;
};

// Size: 0x38
class UBasicOverlays : public UOverlays {
    /* 0x0028 */ TArray<FOverlayItem> Overlays;
};

// Size: 0x80
class ULocalizedOverlays : public UOverlays {
    /* 0x0028 */ UBasicOverlays* DefaultOverlays;
    /* 0x0030 */ TMap<FString, UBasicOverlays*> LocaleToOverlaysMap;
};

// Size: 0x30
struct FOverlayItem {
    /* 0x0000 */ FTimespan StartTime;
    /* 0x0008 */ FTimespan EndTime;
    /* 0x0010 */ FString Text;
    /* 0x0020 */ FVector2D position;
};

// Size: 0x28
class UOverlays : public UObject {
};

enum class EPBIKLimitType {
    Free = 0,
    Limited = 1,
    Locked = 2,
    EPBIKLimitType_MAX = 3,
};

enum class EPBIKRootBehavior {
    PrePull = 0,
    PinToInput = 1,
    Free = 2,
    EPBIKRootBehavior_MAX = 3,
};

// Size: 0x50
struct FPBIKBoneSetting {
    /* 0x0000 */ FName bone;
    /* 0x0008 */ float RotationStiffness;
    /* 0x000c */ float PositionStiffness;
    /* 0x0010 */ EPBIKLimitType X;
    /* 0x0014 */ float MinX;
    /* 0x0018 */ float MaxX;
    /* 0x001c */ EPBIKLimitType Y;
    /* 0x0020 */ float MinY;
    /* 0x0024 */ float MaxY;
    /* 0x0028 */ EPBIKLimitType Z;
    /* 0x002c */ float minZ;
    /* 0x0030 */ float MaxZ;
    /* 0x0034 */ bool bUsePreferredAngles;
    /* 0x0038 */ FVector PreferredAngles;
};

// Size: 0x8
struct FPBIKDebug {
    /* 0x0000 */ float DrawScale;
    /* 0x0004 */ bool bDrawDebug;
};

// Size: 0x90
struct FPBIKEffector {
    /* 0x0000 */ FName bone;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ float PositionAlpha;
    /* 0x0074 */ float RotationAlpha;
    /* 0x0078 */ float StrengthAlpha;
    /* 0x007c */ int32_t ChainDepth;
    /* 0x0080 */ float PullChainAlpha;
    /* 0x0084 */ float PinRotation;
};

// Size: 0x58
struct FPBIKSolver {
};

// Size: 0x40
struct FPBIKSolverSettings {
    /* 0x0000 */ int32_t Iterations;
    /* 0x0004 */ int32_t SubIterations;
    /* 0x0008 */ float MassMultiplier;
    /* 0x000c */ bool bAllowStretch;
    /* 0x000d */ EPBIKRootBehavior RootBehavior;
    /* 0x0010 */ FRootPrePullSettings PrePullRootSettings;
    /* 0x0030 */ float GlobalPullChainAlpha;
    /* 0x0034 */ float maxAngle;
    /* 0x0038 */ float OverRelaxation;
    /* 0x003c */ bool bStartSolveFromInputPose;
};

// Size: 0x80
struct FPBIKWorkData {
    /* 0x0000 */ bool bNeedsInit;
    /* 0x0004 */ uint32_t HashInitializedWith;
    /* 0x0008 */ TArray<int32_t> BoneSettingToSolverBoneIndex;
    /* 0x0018 */ TArray<int32_t> SolverBoneToElementIndex;
    /* 0x0028 */ FPBIKSolver Solver;
};

// Size: 0x120
struct FRigUnit_PBIK : public FRigUnit_HighlevelBaseMutable {
    /* 0x0010 */ FName Root;
    /* 0x0018 */ TArray<FPBIKEffector> Effectors;
    /* 0x0028 */ TArray<int32_t> EffectorSolverIndices;
    /* 0x0038 */ TArray<FPBIKBoneSetting> BoneSettings;
    /* 0x0048 */ TArray<FName> ExcludedBones;
    /* 0x0058 */ FPBIKSolverSettings Settings;
    /* 0x0098 */ FPBIKDebug Debug;
    /* 0x00a0 */ FPBIKWorkData WorkData;
};

// Size: 0x20
struct FRootPrePullSettings {
    /* 0x0000 */ float RotationAlpha;
    /* 0x0004 */ float RotationAlphaX;
    /* 0x0008 */ float RotationAlphaY;
    /* 0x000c */ float RotationAlphaZ;
    /* 0x0010 */ float PositionAlpha;
    /* 0x0014 */ float PositionAlphaX;
    /* 0x0018 */ float PositionAlphaY;
    /* 0x001c */ float PositionAlphaZ;
};

// Size: 0x28
class UHandlerComponentFactory : public UObject {
};

// Size: 0x38
class UPacketHandlerProfileConfig : public UObject {
    /* 0x0028 */ TArray<FString> Components;
};

// Size: 0x78
class UAsyncPakDownloader : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFail;
    /* 0x0050 */ FMulticastInlineDelegate OnProgress;

    static UAsyncPakDownloader* DownloadPak(FString URL, FString SavePath);
};

// Size: 0x28
class UPakLoaderLibrary : public UBlueprintFunctionLibrary {

    static bool DoesPakDirectoryExist(FString PakDirectory);
    static void EnableRuntimeLog(bool bEnable, FString NewLogPath);
    static TArray<FString> GetFilesInPak(FString PakFilename, bool bUAssetOnly);
    static TArray<FString> GetFilesInPakDirectory(FString PakDirectory, bool bRecursively);
    static TArray<FString> GetMountedPakFilenames();
    static UAnimSequence* GetPakFileAnimSequence(FString Filename);
    static UClass* GetPakFileClass(FString Filename);
    static UMaterial* GetPakFileMaterial(FString Filename);
    static UMaterialInstanceConstant* GetPakFileMaterialInstanceConstant(FString Filename);
    static UObject* GetPakFileObject(FString Filename);
    static USkeletalMesh* GetPakFileSkeletalMesh(FString Filename);
    static USoundBase* GetPakFileSound(FString Filename);
    static UStaticMesh* GetPakFileStaticMesh(FString Filename);
    static bool GetPakFileText(FString Filename, FString& String);
    static UTexture2D* GetPakFileTexture2D(FString Filename);
    static FString GetProjectName();
    static FString GetShortName(FString LongName);
    static bool IsPackagedBuild();
    static bool IsValidPakFile(FString PakFilename, int64_t& PakSize);
    static void LoadPakAssetRegistryFile(FString AssetRegistryFile);
    static bool MountPakFile(FString PakFilename, FString MountPath);
    static bool MountPakFileEasy(FString PakFilename);
    static FString ProjectPersistentDownloadDir();
    static bool RegisterEncryptionKey(FString Guid, FString AesKey);
    static void RegisterMountPoint(FString RootPath, FString ContentPath);
    static void RuntimeLog(FString Text);
    static FString SHA1SUM(FString Filename);
    static bool TryConvertFilenameToLongPackageName(FString Filename, FString& PackageName);
    static void UnRegisterMountPoint(FString RootPath, FString ContentPath);
    static bool UnmountPakFile(FString PakFilename);
};

// Size: 0x60
class UPakLoaderSubsystem : public UEngineSubsystem {
    /* 0x0030 */ FMulticastInlineDelegate OnContentPathMounted;
    /* 0x0040 */ FMulticastInlineDelegate OnContentPathDismounted;
    /* 0x0050 */ FMulticastInlineDelegate OnPakFileMounted2;
};

// Size: 0xc
struct FBodyInstanceCore {
    /* 0x0008 */ bool bSimulatePhysics;
    /* 0x0008 */ bool bOverrideMass;
    /* 0x0008 */ bool bEnableGravity;
    /* 0x0008 */ bool bUpdateKinematicFromSimulation;
    /* 0x0008 */ bool bGyroscopicTorqueEnabled;
    /* 0x0008 */ bool bAutoWeld;
    /* 0x0008 */ bool bStartAwake;
    /* 0x0008 */ bool bGenerateWakeEvents;
    /* 0x0009 */ bool bUpdateMassWhenScaleChanges;
};

// Size: 0x38
class UBodySetupCore : public UObject {
    /* 0x0028 */ FName BoneName;
    /* 0x0030 */ uint8_t PhysicsType;
    /* 0x0031 */ uint8_t CollisionTraceFlag;
    /* 0x0032 */ uint8_t CollisionReponse;
};

// Size: 0x48
class UChaosPhysicalMaterial : public UObject {
    /* 0x0028 */ float Friction;
    /* 0x002c */ float StaticFriction;
    /* 0x0030 */ float Restitution;
    /* 0x0034 */ float LinearEtherDrag;
    /* 0x0038 */ float AngularEtherDrag;
    /* 0x003c */ float SleepingLinearVelocityThreshold;
    /* 0x0040 */ float SleepingAngularVelocityThreshold;
};

enum class EAngularConstraintMotion {
    ACM_Free = 0,
    ACM_Limited = 1,
    ACM_Locked = 2,
    ACM_MAX = 3,
};

enum class EBodyCollisionResponse {
    BodyCollision_Enabled = 0,
    BodyCollision_Disabled = 1,
    BodyCollision_MAX = 2,
};

enum class ECollisionTraceFlag {
    CTF_UseDefault = 0,
    CTF_UseSimpleAndComplex = 1,
    CTF_UseSimpleAsComplex = 2,
    CTF_UseComplexAsSimple = 3,
    CTF_MAX = 4,
};

enum class EConstraintFrame {
    Frame1 = 0,
    Frame2 = 1,
    EConstraintFrame_MAX = 2,
};

enum class EConstraintPlasticityType {
    CCPT_Free = 0,
    CCPT_Shrink = 1,
    CCPT_Grow = 2,
    CCPT_MAX = 3,
};

enum class EFrictionCombineMode {
    Average = 0,
    Min = 1,
    Multiply = 2,
    Max = 3,
};

enum class ELinearConstraintMotion {
    LCM_Free = 0,
    LCM_Limited = 1,
    LCM_Locked = 2,
    LCM_MAX = 3,
};

enum class EPhysicalMaterialSoftCollisionMode {
    None = 0,
    RelativeThickness = 1,
    AbsoluteThickess = 2,
    EPhysicalMaterialSoftCollisionMode_MAX = 3,
};

enum class EPhysicalSurface {
    SurfaceType_Default = 0,
    SurfaceType1 = 1,
    SurfaceType2 = 2,
    SurfaceType3 = 3,
    SurfaceType4 = 4,
    SurfaceType5 = 5,
    SurfaceType6 = 6,
    SurfaceType7 = 7,
    SurfaceType8 = 8,
    SurfaceType9 = 9,
    SurfaceType10 = 10,
    SurfaceType11 = 11,
    SurfaceType12 = 12,
    SurfaceType13 = 13,
    SurfaceType14 = 14,
    SurfaceType15 = 15,
    SurfaceType16 = 16,
    SurfaceType17 = 17,
    SurfaceType18 = 18,
    SurfaceType19 = 19,
    SurfaceType20 = 20,
    SurfaceType21 = 21,
    SurfaceType22 = 22,
    SurfaceType23 = 23,
    SurfaceType24 = 24,
    SurfaceType25 = 25,
    SurfaceType26 = 26,
    SurfaceType27 = 27,
    SurfaceType28 = 28,
    SurfaceType29 = 29,
    SurfaceType30 = 30,
    SurfaceType31 = 31,
    SurfaceType32 = 32,
    SurfaceType33 = 33,
    SurfaceType34 = 34,
    SurfaceType35 = 35,
    SurfaceType36 = 36,
    SurfaceType37 = 37,
    SurfaceType38 = 38,
    SurfaceType39 = 39,
    SurfaceType40 = 40,
    SurfaceType41 = 41,
    SurfaceType42 = 42,
    SurfaceType43 = 43,
    SurfaceType44 = 44,
    SurfaceType45 = 45,
    SurfaceType46 = 46,
    SurfaceType47 = 47,
    SurfaceType48 = 48,
    SurfaceType49 = 49,
    SurfaceType50 = 50,
    SurfaceType51 = 51,
    SurfaceType52 = 52,
    SurfaceType53 = 53,
    SurfaceType54 = 54,
    SurfaceType55 = 55,
    SurfaceType56 = 56,
    SurfaceType57 = 57,
    SurfaceType58 = 58,
    SurfaceType59 = 59,
    SurfaceType60 = 60,
    SurfaceType61 = 61,
    SurfaceType62 = 62,
    SurfaceType_Max = 63,
    EPhysicalSurface_MAX = 64,
};

enum class EPhysicsType {
    PhysType_Default = 0,
    PhysType_Kinematic = 1,
    PhysType_Simulated = 2,
    PhysType_MAX = 3,
};

enum class ERadialImpulseFalloff {
    RIF_Constant = 0,
    RIF_Linear = 1,
    RIF_MAX = 2,
};

enum class ESleepFamily {
    Normal = 0,
    Sensitive = 1,
    Custom = 2,
    ESleepFamily_MAX = 3,
};

// Size: 0xa8
class UPhysicalMaterial : public UObject {
    /* 0x0028 */ float Friction;
    /* 0x002c */ float StaticFriction;
    /* 0x0030 */ uint8_t FrictionCombineMode;
    /* 0x0031 */ bool bOverrideFrictionCombineMode;
    /* 0x0034 */ float Restitution;
    /* 0x0038 */ uint8_t RestitutionCombineMode;
    /* 0x0039 */ bool bOverrideRestitutionCombineMode;
    /* 0x003c */ float Density;
    /* 0x0040 */ float SleepLinearVelocityThreshold;
    /* 0x0044 */ float SleepAngularVelocityThreshold;
    /* 0x0048 */ int32_t SleepCounterThreshold;
    /* 0x004c */ float RaiseMassToPower;
    /* 0x0050 */ float DestructibleDamageThresholdScale;
    /* 0x0058 */ UPhysicalMaterialPropertyBase* PhysicalMaterialProperty;
    /* 0x0060 */ uint8_t SurfaceType;
    /* 0x0064 */ FPhysicalMaterialStrength Strength;
    /* 0x0070 */ FPhysicalMaterialDamageModifier DamageModifier;
    /* 0x0074 */ FLinearColor DebugColor;
    /* 0x0084 */ bool bShowExperimentalProperties;
    /* 0x0085 */ EPhysicalMaterialSoftCollisionMode SoftCollisionMode;
    /* 0x0088 */ float SoftCollisionThickness;
    /* 0x008c */ float BaseFrictionImpulse;
};

// Size: 0x4
struct FPhysicalMaterialDamageModifier {
    /* 0x0000 */ float DamageThresholdMultiplier;
};

// Size: 0x28
class UPhysicalMaterialPropertyBase : public UObject {
};

// Size: 0xc
struct FPhysicalMaterialStrength {
    /* 0x0000 */ float TensileStrength;
    /* 0x0004 */ float CompressionStrength;
    /* 0x0008 */ float ShearStrength;
};

// Size: 0x100
class UPhysicsSettingsCore : public UDeveloperSettings {
    /* 0x0038 */ float DefaultGravityZ;
    /* 0x003c */ float DefaultTerminalVelocity;
    /* 0x0040 */ float DefaultFluidFriction;
    /* 0x0044 */ int32_t SimulateScratchMemorySize;
    /* 0x0048 */ int32_t RagdollAggregateThreshold;
    /* 0x004c */ float TriangleMeshTriangleMinAreaThreshold;
    /* 0x0050 */ bool bEnableEnhancedDeterminism;
    /* 0x0051 */ bool bEnableShapeSharing;
    /* 0x0052 */ bool bEnablePCM;
    /* 0x0053 */ bool bEnableStabilization;
    /* 0x0054 */ bool bWarnMissingLocks;
    /* 0x0055 */ bool bEnable2DPhysics;
    /* 0x0056 */ bool bDefaultHasComplexCollision;
    /* 0x0058 */ float BounceThresholdVelocity;
    /* 0x005c */ uint8_t FrictionCombineMode;
    /* 0x005d */ uint8_t RestitutionCombineMode;
    /* 0x0060 */ float MaxAngularVelocity;
    /* 0x0064 */ float MaxDepenetrationVelocity;
    /* 0x0068 */ float ContactOffsetMultiplier;
    /* 0x006c */ float MinContactOffset;
    /* 0x0070 */ float MaxContactOffset;
    /* 0x0074 */ bool bSimulateSkeletalMeshOnDedicatedServer;
    /* 0x0075 */ uint8_t DefaultShapeComplexity;
    /* 0x0078 */ FChaosSolverConfiguration SolverOptions;
};

enum class EProcMeshSliceCapOption {
    NoCap = 0,
    CreateNewSectionForCap = 1,
    UseLastSectionForCap = 2,
    EProcMeshSliceCapOption_MAX = 3,
};

// Size: 0x28
class UKismetProceduralMeshLibrary : public UBlueprintFunctionLibrary {

    static void CalculateTangentsForMesh(const TArray<FVector>& Vertices, const TArray<int32_t>& Triangles, const TArray<FVector2D>& UVs, TArray<FVector>& Normals, TArray<FProcMeshTangent>& Tangents);
    static void ConvertQuadToTriangles(TArray<int32_t>& Triangles, int32_t Vert0, int32_t Vert1, int32_t Vert2, int32_t Vert3);
    static void CopyProceduralMeshFromStaticMeshComponent(UStaticMeshComponent* StaticMeshComponent, int32_t LODIndex, UProceduralMeshComponent* ProcMeshComponent, bool bCreateCollision);
    static void CreateGridMeshSplit(int32_t NumX, int32_t NumY, TArray<int32_t>& Triangles, TArray<FVector>& Vertices, TArray<FVector2D>& UVs, TArray<FVector2D>& UV1s, float GridSpacing);
    static void CreateGridMeshTriangles(int32_t NumX, int32_t NumY, bool bWinding, TArray<int32_t>& Triangles);
    static void CreateGridMeshWelded(int32_t NumX, int32_t NumY, TArray<int32_t>& Triangles, TArray<FVector>& Vertices, TArray<FVector2D>& UVs, float GridSpacing);
    static void GenerateBoxMesh(FVector BoxRadius, TArray<FVector>& Vertices, TArray<int32_t>& Triangles, TArray<FVector>& Normals, TArray<FVector2D>& UVs, TArray<FProcMeshTangent>& Tangents);
    static void GetSectionFromProceduralMesh(UProceduralMeshComponent* InProcMesh, int32_t SectionIndex, TArray<FVector>& Vertices, TArray<int32_t>& Triangles, TArray<FVector>& Normals, TArray<FVector2D>& UVs, TArray<FProcMeshTangent>& Tangents);
    static void GetSectionFromStaticMesh(UStaticMesh* InMesh, int32_t LODIndex, int32_t SectionIndex, TArray<FVector>& Vertices, TArray<int32_t>& Triangles, TArray<FVector>& Normals, TArray<FVector2D>& UVs, TArray<FProcMeshTangent>& Tangents);
    static void SliceProceduralMesh(UProceduralMeshComponent* InProcMesh, FVector PlanePosition, FVector PlaneNormal, bool bCreateOtherHalf, UProceduralMeshComponent*& OutOtherHalfProcMesh, EProcMeshSliceCapOption CapOption, UMaterialInterface* CapMaterial);
};

// Size: 0x60
struct FProcMeshSection {
    /* 0x0000 */ TArray<FProcMeshVertex> ProcVertexBuffer;
    /* 0x0010 */ TArray<uint32_t> ProcIndexBuffer;
    /* 0x0020 */ FBox SectionLocalBox;
    /* 0x0058 */ bool bEnableCollision;
    /* 0x0059 */ bool bSectionVisible;
};

// Size: 0x20
struct FProcMeshTangent {
    /* 0x0000 */ FVector TangentX;
    /* 0x0018 */ bool bFlipTangentY;
};

// Size: 0x98
struct FProcMeshVertex {
    /* 0x0000 */ FVector position;
    /* 0x0018 */ FVector Normal;
    /* 0x0030 */ FProcMeshTangent Tangent;
    /* 0x0050 */ FColor Color;
    /* 0x0058 */ FVector2D UV0;
    /* 0x0068 */ FVector2D UV1;
    /* 0x0078 */ FVector2D UV2;
    /* 0x0088 */ FVector2D UV3;
};

// Size: 0x5f0
class UProceduralMeshComponent : public UMeshComponent {
    /* 0x0570 */ bool bUseComplexAsSimpleCollision;
    /* 0x0571 */ bool bUseAsyncCooking;
    /* 0x0578 */ UBodySetup* ProcMeshBodySetup;
    /* 0x0580 */ TArray<FProcMeshSection> ProcMeshSections;
    /* 0x0590 */ TArray<FKConvexElem> CollisionConvexElems;
    /* 0x05a0 */ FBoxSphereBounds LocalBounds;
    /* 0x05d8 */ TArray<UBodySetup*> AsyncBodySetupQueue;

    void AddCollisionConvexMesh(TArray<FVector> ConvexVerts);
    void ClearAllMeshSections();
    void ClearCollisionConvexMeshes();
    void ClearMeshSection(int32_t SectionIndex);
    void CreateMeshSection(int32_t SectionIndex, const TArray<FVector>& Vertices, const TArray<int32_t>& Triangles, const TArray<FVector>& Normals, const TArray<FVector2D>& UV0, const TArray<FColor>& VertexColors, const TArray<FProcMeshTangent>& Tangents, bool bCreateCollision);
    void CreateMeshSection_LinearColor(int32_t SectionIndex, const TArray<FVector>& Vertices, const TArray<int32_t>& Triangles, const TArray<FVector>& Normals, const TArray<FVector2D>& UV0, const TArray<FVector2D>& UV1, const TArray<FVector2D>& UV2, const TArray<FVector2D>& UV3, const TArray<FLinearColor>& VertexColors, const TArray<FProcMeshTangent>& Tangents, bool bCreateCollision, bool bSRGBConversion);
    int32_t GetNumSections() const;
    bool IsMeshSectionVisible(int32_t SectionIndex) const;
    void SetMeshSectionVisible(int32_t SectionIndex, bool bNewVisibility);
    void UpdateMeshSection(int32_t SectionIndex, const TArray<FVector>& Vertices, const TArray<FVector>& Normals, const TArray<FVector2D>& UV0, const TArray<FColor>& VertexColors, const TArray<FProcMeshTangent>& Tangents);
    void UpdateMeshSection_LinearColor(int32_t SectionIndex, const TArray<FVector>& Vertices, const TArray<FVector>& Normals, const TArray<FVector2D>& UV0, const TArray<FVector2D>& UV1, const TArray<FVector2D>& UV2, const TArray<FVector2D>& UV3, const TArray<FLinearColor>& VertexColors, const TArray<FProcMeshTangent>& Tangents, bool bSRGBConversion);
};

// Size: 0x28
class IAccessValidator : public UInterface {
};

// Size: 0x80
struct FActionResult {
    /* 0x0000 */ EActionResultType resultType;
    /* 0x0004 */ int32_t asCount;
    /* 0x0008 */ FName asEffectToSpawn;
    /* 0x0010 */ FName asUnlock;
    /* 0x0018 */ FResourceCollection asResourceCollection;
    /* 0x0068 */ bool mustHaveResourceToTrigger;
    /* 0x0070 */ TArray<FAgentCharacteristics> agentsToSpawn;
};

// Size: 0x50
struct FActionResult_MasterSyncFormat : public FTableRowBase {
    /* 0x0008 */ FName EffectType;
    /* 0x0010 */ int32_t asCount;
    /* 0x0014 */ FName asEffectToSpawn;
    /* 0x001c */ FName asUnlock;
    /* 0x0024 */ FName resource1;
    /* 0x002c */ int32_t resourceCt1;
    /* 0x0030 */ FName resource2;
    /* 0x0038 */ int32_t resourceCt2;
    /* 0x003c */ FName resource3;
    /* 0x0044 */ int32_t resourceCt3;
    /* 0x0048 */ bool mustHaveResourceToTrigger;
};

// Size: 0x28
struct FActiveClawsSelectionScreen {
    /* 0x0000 */ FName associatedPool;
    /* 0x0008 */ int32_t nInitialChoiceCount;
    /* 0x0010 */ TArray<FClawsGiftChoice> choices;
    /* 0x0020 */ int32_t nChoicesRemaining;
};

// Size: 0x20
struct FActiveEffect {
    /* 0x0000 */ FName effectKey;
    /* 0x0008 */ int32_t nDaysRemaining;
    /* 0x000c */ bool expires;
    /* 0x0010 */ FWorldEffectState_FoodDraining m_effectState_foodDraining;
};

// Size: 0x80
struct FActiveEffects_Hud {
    /* 0x0000 */ FName requestedNewEffectAnim;
    /* 0x0008 */ bool animateNewEffect;
    /* 0x0010 */ FWorldEffectDefinition newEffect;
    /* 0x0070 */ TArray<FActiveEffect> effects;
};

// Size: 0x8
struct FActivePolicySlot {
    /* 0x0000 */ FName assignedPolicy;
};

// Size: 0x28
class IAdjacentChangesListener : public UInterface {

    void AdjacentGridCellChanged();
};

// Size: 0x138
struct FAgentCharacteristics {
    /* 0x0000 */ float speedAt100Percent;
    /* 0x0004 */ float base_speed;
    /* 0x0008 */ float base_productivity;
    /* 0x000c */ float spawnDelay;
    /* 0x0010 */ TSet<FName> traits;
    /* 0x0060 */ FName guild;
    /* 0x0068 */ EAgentEducation education;
    /* 0x006c */ float turnSpeed;
    /* 0x0070 */ FVector agentScale;
    /* 0x0088 */ FString agentName;
    /* 0x0098 */ FVector travelVarianceOffset;
    /* 0x00b0 */ FColor skinColor;
    /* 0x00b4 */ int32_t baseCarryCapacity;
    /* 0x00b8 */ int32_t ID;
    /* 0x00bc */ FName Portrait;
    /* 0x00c4 */ int32_t arrivalCost;
    /* 0x00c8 */ bool ignoreTerrainDebuffs;
    /* 0x00c9 */ bool ignoreFarmFieldDebuffs;
    /* 0x00d0 */ TMap<EExpectationType, float> expectationExcess;
    /* 0x0120 */ float CraftsmanProgress;
    /* 0x0124 */ float ScholarProgress;
    /* 0x0128 */ float GuildProgress;
    /* 0x012c */ FName GuildTarget;
};

// Size: 0x14
struct FAgentDesire {
    /* 0x0000 */ float maxPathfinderCost;
    /* 0x0004 */ float retryDelay;
    /* 0x0008 */ float timeOfActivate;
    /* 0x000c */ int32_t priorityLevel;
    /* 0x0010 */ bool expireEndOfPhase;
};

// Size: 0x50
struct FAgentDesiresState {
    /* 0x0000 */ TMap<EAgentDesire, FAgentDesire> activeDesires;
};

// Size: 0x450
class UAgentDetails : public UArcoView {

    static TArray<FModifierPair> GetAgentModifiers(APrototype_Agent* Agent, bool hideMinorMods);
    static TArray<FModifierPair> GetCarryModifiers(APrototype_Agent* Agent);
    static TArray<FModifierPair> GetProductivityModifiers(APrototype_Agent* Agent);
    static TArray<FModifierPair> GetSpeedModifiers(APrototype_Agent* Agent);
    void ShiftUiForPickup(bool Hide);
};

// Size: 0x68
struct FAgentDisplaySummary {
    /* 0x0000 */ FString agentName;
    /* 0x0010 */ int32_t agentId;
    /* 0x0018 */ FString Job;
    /* 0x0028 */ FString currentTask;
    /* 0x0038 */ int32_t productivityPercent;
    /* 0x003c */ int32_t speedPercent;
    /* 0x0040 */ int32_t happiness;
    /* 0x0048 */ TArray<FAgentModifier> buffs;
    /* 0x0058 */ TArray<FAgentModifier> debuffs;
};

// Size: 0x28
class IAgentEnterable : public UInterface {

    bool AssignWorkerToSlot(int32_t Slot, APrototype_Agent* Agent);
    void ClearAgentInbound(APrototype_Agent* Agent);
    int32_t DeferBehaviorToWorkplace(APrototype_Agent* mAgent);
    bool DisableWorkplace(bool disable);
    bool EnterableDisabled();
    bool FireSpecificWorker(APrototype_Agent* Agent);
    bool ForceReleaseAgent(APrototype_Agent* Agent);
    void ForceReleaseAllAgents();
    int32_t GetGoalWeight(FName Context, int32_t contextIntParam);
    FIntVector GetPathfindingEntryCell() const;
    FVector GetPathfindingPassPoint(FDir entryDir, int32_t OffsetZ);
    bool GetWorkerAssignmentDetails(FWorkerAssignment& outData);
    bool PassControlToEnterable(APrototype_Agent* Agent, FEntryContext EntryContext);
    bool ReleaseControlToAgent(APrototype_Agent* Agent);
    bool RequestingOvertimeHours() const;
    void ReserveAgentInbound(APrototype_Agent* Agent, FEntryContext Context);
    void SimTick(float TimeDelta);
    bool WorkersDesireTools() const;
};

// Size: 0xc
struct FAgentEquipment {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ float durability;
};

// Size: 0x78
struct FAgentEvent {
    /* 0x0000 */ FName EventName;
    /* 0x0008 */ EDayPhase newPhase;
    /* 0x000c */ int32_t ContextID;
    /* 0x0010 */ FString contextStr;
    /* 0x0020 */ AActor* Context;
    /* 0x0028 */ FResourceCollection Resources;
};

// Size: 0x1
struct FAgentGenerationParams {
};

// Size: 0x78
struct FAgentGuild : public FTableRowBase {
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Description;
    /* 0x0028 */ UTexture2D* Icon;
    /* 0x0030 */ FVector agentScale;
    /* 0x0048 */ FName associatedModifier;
    /* 0x0050 */ FColor baseColorVariant;
    /* 0x0058 */ TArray<FName> TooltipTags;
    /* 0x0068 */ TArray<FName> favFoods;
};

// Size: 0x158
struct FAgentListFormat {
    /* 0x0000 */ int32_t associatedAgentId;
    /* 0x0008 */ APrototype_Agent* agentRef;
    /* 0x0010 */ FAgentCharacteristics characteristics;
    /* 0x0148 */ bool employed;
    /* 0x0149 */ bool housed;
    /* 0x014c */ FName guild;
    /* 0x0154 */ EAgentEducation education;
};

// Size: 0x48
struct FAgentModifier : public FTableRowBase {
    /* 0x0008 */ UTexture2D* Icon;
    /* 0x0010 */ FName DisplayName;
    /* 0x0018 */ FName Description;
    /* 0x0020 */ int32_t productivityMod;
    /* 0x0024 */ int32_t speedMod;
    /* 0x0028 */ int32_t carryMod;
    /* 0x002c */ int32_t additionalStacks;
    /* 0x0030 */ bool canStack;
    /* 0x0031 */ bool expires;
    /* 0x0034 */ FName Category;
    /* 0x003c */ FName severity_mastersync;
    /* 0x0044 */ bool useResourceData;
    /* 0x0045 */ bool hiddenMod;
};

// Size: 0x190
struct FAgentModifierState {
    /* 0x0000 */ TMap<FName, FAgentModifier> activeModifiers_all;
};

// Size: 0x50
struct FAgentModifiersDisplay {
    /* 0x0000 */ FName modifierName;
    /* 0x0008 */ FAgentModifier modifier;
};

// Size: 0x530
class UAgentOverviewPanel : public UArcoView {
    /* 0x0448 */ FName Selection;
    /* 0x0450 */ UClass* m_houseAssignmentOverlayClass;
    /* 0x0460 */ UClass* m_industryAssignmentOverlayClass;

    FPopulationOverviewState CalcHudState();
    void CancelBuildingHighlights();
    void CancelRecipeHighlights();
    void CycleTabs(bool tabRight);
    void FireWorker(const TArray<FTrackedWorkplace>& workplaces);
    void HighlightBuildings(const TArray<FTrackedWorkplace>& workplaces);
    void HighlightRecipes(const TArray<FTrackedWorkplace>& workplaces);
    void HireWorker(const TArray<FTrackedWorkplace>& workplaces);
    void ShiftUiForPickup(bool Hide);
};

// Size: 0x478
class UAgentSelector : public UArcoWidgetBase {
    /* 0x0438 */ EAgentFilter m_filter;
    /* 0x043c */ FName m_guildFilter;
    /* 0x0444 */ FName m_teacherGuild;
    /* 0x044c */ EAgentEducation m_educationFilter;
    /* 0x044d */ bool m_student;
    /* 0x044e */ EAgentSortOrder m_sortOrder;
    /* 0x0450 */ TArray<FName> m_workFilter;
    /* 0x0460 */ FName m_recipeFilter;
    /* 0x0468 */ bool m_includeUnassignChoice;
    /* 0x046c */ int32_t m_unassignChoice_agentId;

    FAgentSelectorState CalcState();
    void EducationFilterUpdated();
    int32_t GetDefaultAgentForSlot(FName preferredGuild);
    void GuildFilterUpdated();
    void SetEducationFilter(EAgentEducation education);
    void SetFilter(EAgentFilter Filter, EAgentSortOrder SortOrder);
    void SetGuildFilter(FName guild);
    void SetShowAgentUnassignerOption(bool Show, int32_t associatedAgentId);
    void SetStudentSlot(bool bStudent);
    void SetTeacherGuild(FName guild);
    void SetWorkFilter(const TArray<FName>& work, FName recipe);
};

// Size: 0x10
struct FAgentSelectorState {
    /* 0x0000 */ TArray<FAgentListFormat> listedAgents;
};

// Size: 0x460
struct FAgentState {
    /* 0x0000 */ FVector position;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ FVector animationPositionOffset;
    /* 0x0048 */ FAgentDesiresState desires;
    /* 0x0098 */ FAgentModifierState modifierState;
    /* 0x0228 */ FAgentThoughtsState thoughtsState;
    /* 0x02c8 */ float derived_speedPercent;
    /* 0x02cc */ float derived_happiness;
    /* 0x02d0 */ float derived_productivity;
    /* 0x02d4 */ int32_t derived_carryCapacity;
    /* 0x02d8 */ bool isDummy;
    /* 0x02d9 */ bool isSelfTicking;
    /* 0x02da */ bool desireVisible;
    /* 0x02db */ bool isBeingManhandled;
    /* 0x02dc */ bool seekingHeat;
    /* 0x02e0 */ float seekHeatAttemptCooldown;
    /* 0x02e8 */ FString currentActionDesc;
    /* 0x02f8 */ UHouse* Home;
    /* 0x0308 */ float pathingCooldown;
    /* 0x030c */ float m_secondsUntilStarvationDeath;
    /* 0x0310 */ float pollutionAverage;
    /* 0x0314 */ float livePollution;
    /* 0x0318 */ float lightPollutionThoughtCooldown;
    /* 0x031c */ float heavyPollutionThoughtCooldown;
    /* 0x0320 */ float rapidConstructionCooldown;
    /* 0x0324 */ float hygiene;
    /* 0x0328 */ bool pendingRemoval;
    /* 0x0329 */ EAgentDeleteReason removalReason;
    /* 0x0330 */ TArray<FName> m_foodEatenToday;
    /* 0x0340 */ TArray<FName> m_drinkDrunkToday;
    /* 0x0350 */ EBehaviorType m_lastPushedBehavior;
    /* 0x0354 */ FIntVector lastWanderAnchor;
    /* 0x0360 */ bool stoodStillLastWander;
    /* 0x0361 */ EHeatRecipientState lastHeatState;
    /* 0x0364 */ FClothingState ClothingState;
    /* 0x0390 */ TMap<FName, FInjury> activeInjuries;
    /* 0x03e0 */ float medicalSearchCooldown;
    /* 0x03e8 */ float hardLaborCooldown;
    /* 0x03f0 */ TMap<FName, FAgentEquipment> equipment;
};

// Size: 0x48
struct FAgentState_Climber {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0028 */ FVector destination;
    /* 0x0040 */ bool wantGoDown;
};

// Size: 0x40
struct FAgentState_Passer {
    /* 0x0000 */ APrototype_Agent* Agent;
};

// Size: 0x438
class UAgentTemperatureWidget : public UArcoWidgetBase {
    /* 0x042c */ FAgentTemperatureWidgetState State;

    void UpdateInfo(uint8_t heat, EHeatRecipientState heatState);
};

// Size: 0xc
struct FAgentTemperatureWidgetState {
    /* 0x0000 */ uint8_t heat;
    /* 0x0004 */ int32_t temp;
    /* 0x0008 */ EHeatRecipientState currentHeatState;
    /* 0x0009 */ EAgentTemperatureDir dirState;
};

// Size: 0x40
struct FAgentThought : public FTableRowBase {
    /* 0x0008 */ UTexture2D* Icon;
    /* 0x0010 */ bool tintIcon;
    /* 0x0014 */ FName DisplayName;
    /* 0x001c */ FName Description;
    /* 0x0024 */ bool useResourceData;
    /* 0x0028 */ int32_t approvalCozy;
    /* 0x002c */ int32_t approvalDefault;
    /* 0x0030 */ int32_t approvalHard;
    /* 0x0034 */ int32_t approvalDire;
    /* 0x0038 */ int32_t nStacks;
    /* 0x003c */ int32_t approvalActive;
};

// Size: 0xa0
struct FAgentThoughtsState {
    /* 0x0000 */ TMap<FName, FAgentThought> positiveThoughts;
    /* 0x0050 */ TMap<FName, FAgentThought> negativeThoughts;
};

// Size: 0x48
struct FAgentTrait : public FTableRowBase {
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Description;
    /* 0x0028 */ EAgentTraitType Type;
    /* 0x002c */ FName associatedModifier;
    /* 0x0034 */ bool allowInRandomizer;
    /* 0x0038 */ TArray<FName> exclusiveTraits;
};

// Size: 0x28
class IAgentTraversable : public UInterface {

    bool ForceReleaseAgent(APrototype_Agent* Agent);
    void ForceReleaseAllAgents();
};

// Size: 0xe0
class UAimAutoReplacementListener : public UActorComponent {
};

// Size: 0xa8
struct FAimBoxHudData {
    /* 0x0000 */ TMap<FName, FResourceStockpileSubcategory> stockpileData;
    /* 0x0050 */ TSet<FName> whitelist;
    /* 0x00a0 */ bool showAsInbox;
    /* 0x00a1 */ bool whitelistEnabled;
    /* 0x00a2 */ bool explicitSourcesOnly;
};

// Size: 0x50
struct FAimDestinationRegistry {
    /* 0x0000 */ TSet<UAimMachine*> machines;
};

// Size: 0x60
struct FAimGlobalState {
    /* 0x0000 */ TArray<AAimItem*> unusedItems;
    /* 0x0010 */ TMap<FName, UStaticMesh*> itemMeshCache;
};

// Size: 0x150
struct FAimGraph {
    /* 0x0000 */ TMap<UAimMachine*, FAimNextPlan> links;
    /* 0x0050 */ TMap<FIntVector, UAimMachine*> entrances;
    /* 0x00a0 */ TMap<FIntVector, FAimDestinationRegistry> destinations;
    /* 0x00f0 */ TSet<UAimMachine*> inventoryEntrances;
    /* 0x0140 */ TArray<UAimMachine*> orderedMachines;
};

// Size: 0x118
class UAimInventory : public UActorComponent {
    /* 0x00b8 */ int32_t holdCapacity;
    /* 0x00bc */ bool canTake;
    /* 0x00bd */ bool canGive;
    /* 0x00c0 */ FStockpile Stockpile;
};

// Size: 0x2f8
class AAimItem : public AActor {
    /* 0x02a8 */ UStaticMeshComponent* MeshComp;
    /* 0x02b0 */ float Length;
    /* 0x02b4 */ FName ItemType;
    /* 0x02bc */ float progressInMachine;
    /* 0x02c0 */ UAimMachine* holder;
};

// Size: 0x230
class UAimMachine : public UActorComponent {
    /* 0x00b8 */ float lengthInSeconds;
    /* 0x00c0 */ FVector positionStart;
    /* 0x00d8 */ FVector positionEnd;
    /* 0x00f0 */ FVector positionMid;
    /* 0x0108 */ double positionMidBendRatio;
    /* 0x0110 */ FIntVector logicEntrance;
    /* 0x0120 */ FRotator visualBaseRotation;
    /* 0x0138 */ float visualRotationPeriod;
    /* 0x013c */ float visualRotationStart;
    /* 0x0140 */ float visualRotationMagnitude;
    /* 0x0144 */ bool logicEntranceIsInventory;
    /* 0x0148 */ FIntVector logicDestination;
    /* 0x0154 */ bool logicDestinationIsInventory;
    /* 0x0158 */ float anime_syncSpeed;
    /* 0x015c */ float anime_rotationSpeed;
    /* 0x0160 */ EEase movementEasing;
    /* 0x0164 */ float anime_pendingTimeDelta;
    /* 0x0168 */ float Speed;
    /* 0x0170 */ FVector worldPositionStart;
    /* 0x0188 */ FVector worldPositionEnd;
    /* 0x01a0 */ FVector worldPositionMid;
    /* 0x01b8 */ float worldLength;
    /* 0x01bc */ float reservedProgress;
    /* 0x01c0 */ TArray<AAimItem*> heldItems;
    /* 0x01d0 */ FIntVector worldLogicEntrance;
    /* 0x01dc */ FIntVector worldLogicDestination;
    /* 0x01e8 */ FRotator worldRotation;
    /* 0x0208 */ bool anime_callDelegateOnly;
    /* 0x0210 */ FMulticastInlineDelegate anime_delegate;
    /* 0x0220 */ TArray<USceneComponent*> anime_rotatables;

    void RegisterAnimationAsDelegateBased();
    void RegisterAnimationRotables(TArray<USceneComponent*> rotables);
    void SetAnimationprogress(float progressRatio);
};

// Size: 0x78
struct FAimNextPlan {
    /* 0x0000 */ TSet<UAimMachine*> priorMachines;
    /* 0x0050 */ bool priorIsInventory;
    /* 0x0060 */ UAimMachine* nextMachine;
    /* 0x0068 */ float nextPosition;
    /* 0x006c */ bool nextIsInventory;
};

// Size: 0x240
struct FAimSpace {
    /* 0x0000 */ TMap<FVector, UAimMachine*> machineByPosition;
    /* 0x0050 */ TSet<UAimMachine*> machines;
    /* 0x00a0 */ TSet<AAimItem*> Items;
    /* 0x00f0 */ FAimGraph Graph;
};

// Size: 0x390
class UAimSystem : public UActorComponent {
    /* 0x00b8 */ FAimSystemConfig config;
    /* 0x00d0 */ UWorld* World;
    /* 0x00d8 */ float Time;
    /* 0x00dc */ float speedStatus;
    /* 0x00e0 */ float speedForce;
    /* 0x00e4 */ float systemMomentum;
    /* 0x00e8 */ FAimSpace AimSpace;
    /* 0x0328 */ FAimGlobalState globalState;
};

// Size: 0x18
struct FAimSystemConfig {
    /* 0x0000 */ float topSpeed;
    /* 0x0004 */ float itemScale;
    /* 0x0008 */ UDataTable* itemTable;
    /* 0x0010 */ float camDistanceSquaredToStopAnim;
    /* 0x0014 */ float camDistanceSquaredToStopItemRender;
};

// Size: 0x610
class AAimTool : public AActor {
    /* 0x03a8 */ bool isDragging;
    /* 0x03ac */ FIntVector dragStartPos;
    /* 0x03b8 */ FIntVector dragEndPos;
    /* 0x03c4 */ FDir m_cursorFacing_player;
    /* 0x03c8 */ FName beltSegKey;
    /* 0x03d0 */ UClass* beltSegClass;
    /* 0x03e8 */ FDetailedResourceCost currentCost;
    /* 0x0580 */ UWidgetComponent* m_placementUiWidget;
    /* 0x0588 */ UStaticMesh* m_beltPreviewMesh;
    /* 0x0590 */ UStaticMesh* m_arrowMesh_oneDir;
    /* 0x0598 */ UStaticMeshComponent* m_arrowViz;
};

// Size: 0x330
class AAmbientAudio : public AActor {
    /* 0x02a8 */ UAudioComponent* m_audioVolume;
    /* 0x02b0 */ FAmbientSoundScenario m_defaultAudioScenario;
    /* 0x02d0 */ TMap<FName, FAmbientSoundScenario> m_weatherAudioOverrides;
};

// Size: 0x20
struct FAmbientSoundScenario {
    /* 0x0000 */ USoundBase* morningAudio;
    /* 0x0008 */ USoundBase* middayAudio;
    /* 0x0010 */ USoundBase* nightAudio;
    /* 0x0018 */ USoundBase* undergroundAudio;
};

// Size: 0x10
struct FAnimationLookupRow : public FTableRowBase {
    /* 0x0008 */ UAnimationAsset* Animation;
};

// Size: 0x460
class UAnnouncementView_Unlock : public UArcoView {
    /* 0x0448 */ FMailStyleNotif m_notifInfo;
};

// Size: 0x18
struct FApprovalDeltaRow {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ int32_t Value;
};

// Size: 0x60
struct FArcPlan {
    /* 0x0000 */ FVector worldStart;
    /* 0x0018 */ FVector worldEnd;
    /* 0x0030 */ FColor Color;
    /* 0x0034 */ float linewidthTop;
    /* 0x0038 */ float linewidthEnd;
    /* 0x003c */ float arcHeightRatioOfLength;
    /* 0x0040 */ UTexture2D* apexIcon;
    /* 0x0048 */ FLinearColor apexIconColor;
    /* 0x0058 */ float apexIconSize;
    /* 0x005c */ bool useApexIconColor;
};

// Size: 0x350
class AArcoCamInterpolator : public AActor {
    /* 0x02a8 */ UCineCameraComponent* m_interpolationCamera;
    /* 0x0338 */ AActor* m_endActor;
};

// Size: 0x380
class AArcoFreeCamPawn : public APawn {
    /* 0x0328 */ UCameraComponent* m_camera;
    /* 0x0330 */ FVector m_desiredPos;
    /* 0x0348 */ FRotator m_desiredRot;
    /* 0x0360 */ float m_baseMoveSpeed;
    /* 0x0364 */ float m_baseRotSpeed;
    /* 0x0368 */ float m_mouseRotScalar;
};

// Size: 0x28
class UArcoFunctionLibrary : public UBlueprintFunctionLibrary {

    static bool CheckEducation(const EAgentEducation& Target, EAgentEducation query);
    static TArray<FExpectationReason> GetExpectationReasons(const FAgentCharacteristics& characteristics, UClass* config, const UObject* Context);
    static void SortResourceCollectionByCountDescending(FResourceCollection& Collection);
    static void SortResourceCollectionByMagnitudeDescending(FResourceCollection& Collection);
};

// Size: 0x860
class UArcoGameInstance : public UBackbone {
    /* 0x02e0 */ UDataTable* CommonMaterials;
    /* 0x02e8 */ UDataTable* CommonAudio;
    /* 0x02f0 */ UDataTable* CommonIcons;
    /* 0x02f8 */ UDataTable* CommonAnimations;
    /* 0x0300 */ UDataTable* CommonMeshes;
    /* 0x0308 */ UDataTable* CommonParticles_Cascade;
    /* 0x0310 */ UDataTable* m_gridActorLookup;
    /* 0x0318 */ UDataTable* m_agentModifiersLookup;
    /* 0x0320 */ UDataTable* m_agentThoughtsLookup;
    /* 0x0328 */ UDataTable* m_resourcesLookup;
    /* 0x0330 */ UArcoGameTunes* m_arcoGameConfigTuning;
    /* 0x0338 */ UClass* m_agentPrototype;
    /* 0x0340 */ UDataTable* m_techUnlocks;
    /* 0x0348 */ UDataTable* m_mealDefs;
    /* 0x0350 */ UDataTable* m_drinkDefs;
    /* 0x0358 */ UDataTable* m_effectDefs;
    /* 0x0360 */ UDataTable* m_eventDefs;
    /* 0x0368 */ UDataTable* m_questDefs;
    /* 0x0370 */ UDataTable* m_systemtunes;
    /* 0x0378 */ UDataTable* m_scenarioDefs;
    /* 0x0380 */ UDataTable* m_problemIndicatorMessages;
    /* 0x0388 */ UDataTable* m_industryRecipeDefs;
    /* 0x0390 */ UDataTable* m_actionResults;
    /* 0x0398 */ TArray<FColor> skinColors;
    /* 0x03a8 */ UDataTable* m_policyDefs;
    /* 0x03b0 */ UDataTable* m_whiskerGuilds;
    /* 0x03b8 */ UDataTable* m_whiskerTraits;
    /* 0x03c0 */ UDataTable* m_diplomacyUpgrades;
    /* 0x03c8 */ UDataTable* m_resourceCategorySortOrder;
    /* 0x03d0 */ UDataTable* m_slotDecoratives;
    /* 0x03d8 */ UDataTable* m_toolbarDefs;
    /* 0x03e0 */ UDataTable* m_weatherDefs;
    /* 0x03e8 */ UDataTable* m_tooltipTags;
    /* 0x03f0 */ UDataTable* m_supportedResourceGroups;
    /* 0x03f8 */ UDataTable* m_taxPaymentThresholds;
    /* 0x0400 */ UDataTable* m_clawsGiftPools;
    /* 0x0408 */ UDataTable* m_seasonDefs;
    /* 0x0410 */ TMap<EArco_PlayerVerb, FName> m_verbToLoc;
    /* 0x0460 */ TMap<FKey, EInputIconButton> m_unrealKeyToInputIcon;
    /* 0x04b0 */ TMap<EArco_PlayerAction, FArco_PlayerActionUnrealKeybindMapper> m_actionToKeybind;
    /* 0x0500 */ TArray<FTechTier> m_techTiers;
    /* 0x0518 */ UMetaSave* m_metaSave;

    static EArco_PlayerAction ArcoVerbToAction(EArco_PlayerVerb verb);
    static TArray<FAgentCharacteristics> CalcArrayCharacteristicsWithGuildAndTraitMods(UObject* Context, const TArray<FAgentCharacteristics>& characteristics);
    static FAgentCharacteristics CalcCharacteristicsWithGuildAndTraitMods(UObject* Context, const FAgentCharacteristics& characteristics);
    static void EditorOnly_ClearSave();
    static void EditorOnly_RequestMasterSyncUpdate();
    static void EditorOnly_SetEnableAssertSaves(bool Enable);
    static void EditorOnly_SetGameLoadMode(EArcoGameType loadType);
    static void EditorOnly_SetMapgenExtents(FIntVector Extents);
    static void EditorOnly_SetNewMapSize(FIntVector Extents);
    static void EditorOnly_SetSaveToLoadOnLaunch(FString saveString);
    static void EditorOnly_SetShouldPlayWholeReplay(bool replayWholeReplay);
    static void EditorOnly_ToggleAlwaysSync(bool shouldSync);
    static void EditorOnly_ToggleIgnoreReplayDesync(bool shouldIgnore);
    static void EditorOnly_ToggleMinLoadingScreenTime(bool shouldHaveMinTime);
    static void EditorOnly_ToggleSkipIntro(bool shouldSkip);
    static void EnterMapEditor(const UObject* Context, FString Filename);
    static void EnterPlay(const UObject* Context, FString Filename, EArcoGameType gameType, ESaveLocation saveLocation, bool forceFullReplay);
    static EInputIconButton FKeyToInputIcon(const UObject* Context, FKey Key);
    static FActionResult GetActionResult(const UObject* Context, FName Name);
    static bool GetAgentModifier(const UObject* Context, FAgentModifier& out_modifier, FName Key);
    static bool GetAgentThought(const UObject* Context, FAgentThought& outThought, FName Key);
    static EInputIconButton GetBoundIconForVerb(const UObject* Context, EArco_PlayerVerb verb);
    static TArray<FName> GetCampResourceGroup(const UObject* Context, FName camp);
    static FKey GetCurrentlyBoundKeyForAction(const UObject* Context, EArco_PlayerAction playerAction);
    static bool GetDrinkDefForResource_outParam(const UObject* Context, FName Resource, FMealDef& outDef);
    static FGridActorDefinition_MasterSyncFormat GetGridActorClass_Copy(const UObject* Context, FName Key);
    static FResourceCollection GetGridActorCost(const UObject* Context, FName Name);
    static EStructureType GetGridActorStructureType(const UObject* Context, FName Name);
    static TArray<FName> GetGridActorsOfGroup(UObject* Context, const FName& Name);
    static TArray<FName> GetIndustriesThatOutputResource(const UObject* Context, FName Resource);
    static TArray<FName> GetIndustriesWithRecipe(const UObject* Context, FName recipeKey);
    static FIndustryRecipe GetIndustryRecipe(const UObject* Context, FName Name);
    static FName GetLocKeyForVerb(const UObject* Context, EArco_PlayerVerb verb);
    static bool GetMealDefForResource_outParam(const UObject* Context, FName Resource, FMealDef& outDef);
    static FMealDef GetMealDef_Copy(const UObject* Context, FName Key);
    static UMetaSave* GetMetaSave(const UObject* Context);
    static FQuestBatchDef GetQuestDef(const UObject* Context, FName Key);
    static TArray<FName> GetRecipesWithOutput(const UObject* Context, FName outputResource);
    static FName GetResourceCategory(const UObject* Context, FName Key);
    static FResourceDef GetResourceDefCopy(const UObject* Context, FName Key);
    static FName GetResourceSubCategory(const UObject* Context, FName Key);
    static TArray<FString> GetSaveGames(const UObject* Context, ESaveLocation saveLocation);
    static TArray<FString> GetSaveGamesDateSorted(const UObject* Context, ESaveLocation saveLocation);
    static float GetSystemTune(const UObject* Context, FName Key);
    static FTechTier GetTechTier(const UObject* Context, int32_t tier);
    static FName GetTechUnlockLocKey(const UObject* Context, FName unlockKey);
    static bool GetTechUnlock_outParam(const UObject* Context, FName Key, FTechUnlock_V2& outDef);
    static FTooltipTag GetTooltipTag(const UObject* Context, FName Name);
    static TArray<FName> GetUnlockPrerequisites(const UObject* Context, FName unlockKey);
    static FName GetUnlockResearchPrerequisite(const UObject* Context, FName unlockKey);
    static FName GetVariantParent(const UObject* Context, FName gridActorKey);
    static FWeatherPreset GetWeatherPreset_copy(const UObject* Context, FName Key);
    static TArray<FWorkerSlot> GetWorkerInfoFromPrefab(const UObject* Context, FName prefabKey);
    static FWorldEffectDefinition GetWorldEffectDef_Copy(const UObject* Context, FName Key);
    static bool HasQuestDef(const UObject* Context, FName Key);
    static ESaveLocation InferSaveLocationForSave(const UObject* Context, FString saveName);
    static bool IsPartOfVariantSet(const UObject* Context, FName gridActorKey);
    static void PlayUiSound(UObject* Context, FName soundKey, float Volume);
    static void SaveMetaSave(const UObject* Context);
    static void SetNewMapDifficulty_Debt(const UObject* Context, float difficulty);
    static void SetNewMapExtents(const UObject* Context, FIntVector Extents);
    static void SetNewMapName(const UObject* Context, FString Name);
    static void SetNewMapPreference(const UObject* Context, FName RuleName, FName choiceName, float Value);
    static void SetNewMapStartingAgents(const UObject* Context, TArray<FAgentCharacteristics> agents);
    void _mouseCursorBlip(FString Message, const FColor& Tint);
};

// Size: 0x30
class UArcoGameTunes : public UPrimaryDataAsset {
};

// Size: 0x3e8
class AArcoHUD : public AHUD {
    /* 0x0398 */ FHudConfig config;
    /* 0x03c8 */ TArray<FArcPlan> activeArcs;
    /* 0x03d8 */ TArray<FArcPlan> transientArcs;

    bool DrawArcPlan(const FArcPlan& ArcPlan);
    void DrawHUD();
};

// Size: 0x28
class UArcoInputBindingPrimitives : public UObject {
};

// Size: 0x410
class AArcoMusicController : public AActor {
    /* 0x02a8 */ TMap<EDayPhase, FMusicPool> m_musicPools;
    /* 0x02f8 */ TMap<EDayPhase, FMusicPool> m_standardMusicPools_ByDayPhase;
    /* 0x0348 */ TMap<FName, FMusicPool_WeatherOverride> m_weatherMusicPools;
    /* 0x0398 */ UAudioComponent* m_musicAudioComponent;
    /* 0x03b0 */ TMap<EMusicOverridePriority, USoundBase*> m_activeOverrideRequests;
    /* 0x0400 */ USoundBase* m_overridenMusic;
    /* 0x0408 */ EMusicOverridePriority m_currentOverrideGroup;

    void ClearMusicOverride(EMusicOverridePriority priorityGroup, bool desireFadeout);
    void RequestMusicOverride(USoundBase* music, EMusicOverridePriority priorityGroup);
    void _songEnded();
};

// Size: 0x80
struct FArcoNotification {
    /* 0x0000 */ FString Key;
    /* 0x0010 */ FName iconKey;
    /* 0x0018 */ FColor TintColor;
    /* 0x0020 */ FHudAction hudActionOnClick;
    /* 0x0078 */ bool dismissOnClick;
    /* 0x007c */ int32_t notifId;
};

// Size: 0x138
struct FArcoPlayerState {
    /* 0x0000 */ FCursorCastInfo m_cursorCastInfo;
    /* 0x00f8 */ int32_t m_explicitZ;
    /* 0x00fc */ ECameraBehavior m_cameraBehavior;
    /* 0x00fd */ FDir m_previewFacing;
    /* 0x00fe */ bool m_showHud;
    /* 0x00ff */ bool m_dev_hideAllHud;
    /* 0x0100 */ bool m_showSpatialElements;
    /* 0x0101 */ bool m_showReplayMenu;
    /* 0x0102 */ bool toolDesiresGridCursor;
    /* 0x0108 */ UArcoView* activeArcoView;
    /* 0x0110 */ bool showDevTools;
    /* 0x0111 */ bool hidePhotomodeUi;
    /* 0x0112 */ bool showGlobalHeatOverlay;
    /* 0x0113 */ bool showGlobalPollutionOverlay;
    /* 0x0114 */ bool m_forceMouseHidden;
    /* 0x0115 */ bool debugTemperatureCursor;
    /* 0x0116 */ bool debugAim;
    /* 0x0117 */ bool debugTemperatureAsHeat;
    /* 0x0118 */ bool debugPipeNetwork;
    /* 0x0119 */ bool debugCursorPos;
    /* 0x011a */ bool debugDisableHeatOverlays;
    /* 0x011b */ bool isModifierDown;
    /* 0x011c */ EPipeCategory pipeCategory;
};

// Size: 0x130
class UArcoPollutionSource : public UActorComponent {

    int32_t GetCurrentPollution() const;
};

// Size: 0x490
class UArcoRadialMenu : public UArcoWidgetBase {
    /* 0x0428 */ TArray<FName> toolbarStack;
    /* 0x0438 */ FRadialToolbarCfg m_toolbarData;

    void Event_CategoryClosed();
    void Event_CategoryOpened(FName Category);
    void Event_ToolbarDataChanged();
    void Event_VisibilityChanged(bool IsVisible);
    void SelectAction();
};

// Size: 0x88
struct FArcoScenario {
    /* 0x0000 */ FScenarioEventCalendar hardcodedCalendar;
    /* 0x0020 */ TArray<FName> unlocks;
    /* 0x0030 */ int32_t colonistsPerShip;
    /* 0x0038 */ FResourceCollection startingResources;
};

// Size: 0x30
struct FArcoSystemConfig {
    /* 0x0000 */ FAimSystemConfig aimConfig;
    /* 0x0018 */ FNavySystemConfig navyConfig;
    /* 0x0028 */ EDayPhase embarkDayPhase;
};

// Size: 0x3620
class AArcoSystems : public AActor {
    /* 0x02b0 */ FNewMapInitParams m_newMapParams;
    /* 0x03e8 */ FArcoSystemConfig config;
    /* 0x0418 */ FIntVector WorldOrigin;
    /* 0x0424 */ FIntVector WorldExtent;
    /* 0x0498 */ FMulticastInlineDelegate EmitHudActionDelegate;
    /* 0x04b0 */ FTaxState m_taxState;
    /* 0x0508 */ FTaxTradeInformation m_tradeMarketValues;
    /* 0x05e0 */ FShipTracker m_shipTracker;
    /* 0x06c0 */ UClass* m_canonballClass;
    /* 0x06d8 */ UClass* agentClass;
    /* 0x06e0 */ UClass* constructionSiteTemplate;
    /* 0x0718 */ UClass* m_infoBlipsClass;
    /* 0x0720 */ AInfoBlips* m_infoBlips;
    /* 0x0728 */ UPlayerBank* m_playerBank;
    /* 0x0730 */ UClass* m_worldTimeClass;
    /* 0x0738 */ AWorldTime* m_worldTime;
    /* 0x0740 */ UClass* m_eventsTimelineClass;
    /* 0x0748 */ UEventTimeline* m_eventsTimeline;
    /* 0x0750 */ UWorldEffects* m_worldEffects;
    /* 0x0758 */ UClass* m_scaffoldClass;
    /* 0x0760 */ AScaffoldRenderer* m_scaffoldRenderer;
    /* 0x0768 */ UClass* m_radiusRendererClass;
    /* 0x0770 */ ARadiusOfEffectRenderer* m_radiusRenderer;
    /* 0x0778 */ UClass* m_ambientAudioClass;
    /* 0x0780 */ AAmbientAudio* m_ambientAudio;
    /* 0x0788 */ UClass* m_railSystemClass;
    /* 0x0790 */ ARailSystem* m_railSystem;
    /* 0x0798 */ FWorldMeta m_worldMeta;
    /* 0x24a0 */ UClass* m_questTrackerClass;
    /* 0x24a8 */ UQuestTracker* m_questTracker;
    /* 0x24b0 */ UStatisticsTracker* m_statistics;
    /* 0x24b8 */ UClass* m_policiesClass;
    /* 0x24c0 */ UPolicies* m_policies;
    /* 0x24c8 */ UJobSystem* m_jobSystem;
    /* 0x24d0 */ UClass* m_giftPoolCalculatorClass;
    /* 0x24d8 */ UGiftPools* m_giftPoolCalculator;
    /* 0x24e0 */ FTiledTerrainData m_terrain;
    /* 0x2d60 */ UClass* m_tiledTerrainClass;
    /* 0x2d68 */ UClass* m_tiledTerrainConfigMule;
    /* 0x2d70 */ ATiledBlockTerrain* m_tiledTerrain;
    /* 0x2d78 */ UTerrainGenerator* m_terrainGenerator;
    /* 0x2d80 */ UClass* m_terrainGeneratorConfig;
    /* 0x2d88 */ UOreDistributor* m_oreDistributor;
    /* 0x2d90 */ UClass* m_oreDistributorConfig;
    /* 0x2d98 */ UHeatSystem* m_heatSystem;
    /* 0x2da0 */ UClass* m_heatSystemConfigMule;
    /* 0x2da8 */ UClass* m_farmCropConfigMule;
    /* 0x2db0 */ UExpectationSystem* m_expectationSystem;
    /* 0x2db8 */ UClass* m_expectationSystemConfigMule;
    /* 0x2dc0 */ UAimSystem* m_aimSystem;
    /* 0x2dc8 */ UNavySystem* m_navySystem;
    /* 0x2dd0 */ UClass* m_mineVizClass;
    /* 0x2dd8 */ UMineViz* m_mineViz;
    /* 0x2de0 */ UClass* m_farmVizClass;
    /* 0x2de8 */ UFarmViz* m_farmViz;
    /* 0x2df0 */ UClass* m_resourceMarkingVizClass;
    /* 0x2df8 */ UResourceMarkingViz* m_resourceMarkingViz;
    /* 0x2e00 */ UClass* m_terraformVizClass;
    /* 0x2e08 */ UTerraformViz* m_terraformViz;
    /* 0x2e10 */ UClass* m_problemIndicatorClass;
    /* 0x2e18 */ AProblemIndicator* m_problemIndicator;
    /* 0x2e20 */ UNotificationSystem* m_notificationSystem;
    /* 0x2e28 */ UColonyProblemsSummary* m_colonyProblemsSummary;
    /* 0x2e30 */ UClass* m_elevatorSystemClass;
    /* 0x2e38 */ AElevatorSystem* m_elevatorSystem;
    /* 0x2e40 */ UClass* m_pipeSystemClass;
    /* 0x2e48 */ APipeSystem* m_pipeSystem;
    /* 0x2e50 */ UClass* m_doorwayRendererClass;
    /* 0x2e58 */ AStructureDoorwayRenderer* m_doorwayRenderer;
    /* 0x2e60 */ AResourceFling* m_resourceFlinger;
    /* 0x2e68 */ UClass* m_roofSystemClass;
    /* 0x2e70 */ ARoofSystem* m_roofSystem;
    /* 0x2e78 */ UEventQueue* m_eventQueue;
    /* 0x2e80 */ UClass* m_musicControllerClass;
    /* 0x2e88 */ AArcoMusicController* m_musicController;
    /* 0x2e90 */ TSet<FName> m_enabledUnlocks;
    /* 0x2ee0 */ FUnlockTree m_unlockTree;
    /* 0x2f30 */ bool m_allUnlocksCheat;
    /* 0x2f38 */ FResearchState m_researchState;
    /* 0x3000 */ TMap<int32_t, FColor> m_heatToUiColorLookup;
    /* 0x3050 */ FString m_associatedSave;
    /* 0x3060 */ FArcoScenario m_scenarioData;
    /* 0x30e8 */ int32_t m_mealRationingCount;
    /* 0x30ec */ int32_t m_drinkRationingCount;
    /* 0x30f0 */ bool m_mealRationing_rawOnly;
    /* 0x30f1 */ bool m_mealRationing_preparedOnly;
    /* 0x30f2 */ bool m_assertSavesEnabled;
    /* 0x3118 */ TArray<FName> m_derivedResearchableTech;
    /* 0x3128 */ TArray<FMealDefTierGroup> m_mealDefsQualitySorted_descendingGroups;
    /* 0x3138 */ TArray<FMealDefTierGroup> m_drinkDefsQualitySorted_descendingGroups;
    /* 0x31c0 */ UClass* embarkBoatClass;
    /* 0x31c8 */ AEmbarkBoat* embarkBoatInstance;
    /* 0x31d0 */ int32_t m_totalActions;
    /* 0x31d4 */ int32_t m_totalAssertSaves;
    /* 0x31d8 */ int32_t m_maxAllowedSavesPerRun;
    /* 0x31e0 */ TSet<FName> m_miscEventFlags;
    /* 0x3260 */ TArray<FReportedDeath> m_recentDeaths;
    /* 0x3270 */ TArray<FReportedDeath> m_deathsPendingGraves;
    /* 0x3280 */ TArray<FMailStyleNotif> m_pendingMailNotifs;
    /* 0x3290 */ FPathfinderCallCounts m_pathfinderCallCountsForFrame;
    /* 0x33c0 */ TMap<FName, UClass*> m_workshipActorLookup;
    /* 0x34b0 */ FAutoExportState m_autoExportState;

    bool CalcAffordabilityOfChoice(FEventChoiceV2 choice);
    bool CalcAffordabilityOfResult(FActionResult Result);
    EDayPhase CurrentPhase();
    static void Delete_FromRecRec(UWorld* WorldContext, FString saveFileName, ESaveLocation saveLocation);
    int32_t GetApprovalDifficultyIndex() const;
    static AArcoSystems* GetArcoSys(bool& out_isValid);
    FBuildingCyclerInfo GetBuildingCyclerInfoForStructure(AGridActor* GridActor);
    TArray<FStringPair> GetColonyConfigParamKeys() const;
    FString GetColonyName() const;
    FWeatherPreset GetCurrentWeatherData() const;
    FDockableShipData GetCurrentlyDockedShipInfo() const;
    float GetCycleTimeForCurrentTier() const;
    float GetCycleTimeForTier(int32_t tier) const;
    int32_t GetDaysUntilTaxDay() const;
    float GetDebtMultiplier() const;
    FVector GetDockingPosForMainDock() const;
    static TArray<FName> GetGlobalWhiskerGenTraitsForScenario(FName scenario);
    FHeatDebugInfo GetHeatDebugInfo(int32_t day);
    TArray<FName> GetMissingPrerequisites(const FName& Name) const;
    FPopulationSummary_UI GetPopulationSummaryInfo() const;
    AActor* GetPrimaryDockActor() const;
    FResearchSummaryState GetResearchInfo() const;
    float GetResearchPercentage() const;
    float GetResearchProgress(FName tech) const;
    int32_t GetResourceValue(FName Resource, EResourceValueContext Context) const;
    double GetSessionPlaySeconds();
    FDiplomaticStandingSummary GetStandingInfo();
    int32_t GetTotalDebt() const;
    double GetTotalPlaySeconds();
    double GetUnixTimestamp();
    bool HasUnlock(const FName& Name) const;
    FColor HeatToUiColor(uint8_t heat);
    bool IsGridActorUnderground(AGridActor* GridActor);
    bool IsLive();
    bool IsSaveGame();
    int32_t ModifyUnlockCostByDifficulty(int32_t baseCost) const;
    void PolicyStateChanged(FName policy, bool Active);
    void _dayBegan(float timeSkipped);
    void _dayEnded(EDayPhase endedPhase);
    void _dayEvent(FName dayEvent);
    void _dayPhaseBegan(EDayPhase newPhase);
    void _dayPhaseEnded(EDayPhase dayPhase);
    void _eodReportSigned();
};

// Size: 0x428
class UArcoTabList : public UArcoWidgetBase {

    void SelectTabExternal(int32_t tabIdx);
};

// Size: 0x28
class UArcoUi_Utils : public UObject {

    static FString SecondsToCountdown(float Seconds);
};

// Size: 0x448
class UArcoView : public UArcoWidgetBase {
    /* 0x0428 */ FArcoViewConfig config;
    /* 0x0440 */ ACutscene* Cutscene;

    void CleanupView_Blueprint();
    void CloseSubView();
    void InitView_Blueprint();
    void OpenSubView(UClass* subViewClass, AActor* contextActor);
    void ViewPausedEvent();
    void ViewResumedEvent();
};

// Size: 0x18
struct FArcoViewConfig {
    /* 0x0000 */ UClass* cutsceneClass;
    /* 0x0008 */ bool hideMainUi;
    /* 0x0009 */ bool hideToolbar;
    /* 0x000a */ bool hideRightElements;
    /* 0x000b */ bool hideCenterMessages;
    /* 0x000c */ bool disableWorldCursor;
    /* 0x000d */ bool allowPlayerActionPassthrough;
    /* 0x000e */ bool allowSelectToolWhileOpen;
    /* 0x000f */ bool allowPlayerCameraMovement;
    /* 0x0010 */ bool playOpenCloseSounds;
    /* 0x0011 */ bool allowRightClickExit;
    /* 0x0012 */ bool desireHeatVision;
    /* 0x0013 */ bool desirePauseGame;
    /* 0x0014 */ bool disableCustceneByGameSetting;
};

// Size: 0x428
class UArcoWidgetBase : public UNaviSubGrid {
    /* 0x03b8 */ AActor* Context;
    /* 0x03c0 */ FMulticastInlineDelegate OnHudActionDelegate;

    void ClearAllListensToWidgetActions();
    void ContextUpdatedFromCPP();
    bool HandlePlayerAction(FName action);
    void HudAction(FHudAction action);
    void ListenToWidgetActions(UArcoWidgetBase* otherWidget);
    void ReceiveHudAction(FHudAction action);
    void UnlistenToWidgetActions(UArcoWidgetBase* otherWidget);
    bool _SendPlayerActionToChildren(FName playerAction);
};

// Size: 0x48
struct FArcoWorkShip {
    /* 0x0000 */ int32_t ID;
    /* 0x0008 */ ABoat* shipActor;
    /* 0x0010 */ FVector Pos;
    /* 0x0028 */ FRotator rot;
    /* 0x0040 */ int32_t assignedWorkDock;
    /* 0x0044 */ EWorkShipState shipState;
};

// Size: 0x20
struct FArco_PlayerActionUnrealKeybindMapper {
    /* 0x0000 */ FString asPc;
    /* 0x0010 */ FString asGamepad;
};

// Size: 0x270
class UAssignableDockPosition : public USceneComponent {
    /* 0x0240 */ bool m_treatDockedWorkboatAsUnassigned;
    /* 0x0244 */ int32_t m_assignedShipId;
    /* 0x0248 */ float transitionTimeRemaining;
    /* 0x024c */ float transitionSpan;
};

// Size: 0x28
class IAttachableUpgradeReceiver : public UInterface {

    void AttachUpgrade(Usteamengine* steamengine);
    void UnattachUpgrade(Usteamengine* steamengine);
};

// Size: 0x8
struct FAutoExportResourceCfg {
    /* 0x0000 */ bool Enabled;
    /* 0x0004 */ int32_t minHold;
};

// Size: 0x50
struct FAutoExportState {
    /* 0x0000 */ TMap<EShipType, FShipExportCfg> shipConfigs;
};

// Size: 0xc
struct FAvailablePolicy {
    /* 0x0000 */ FName policy;
    /* 0x0008 */ bool isAlreadyActive;
};

// Size: 0x428
class UBasicResourceDockUi : public UArcoWidgetBase {
};

// Size: 0xc0
struct FBathhouseView_UiData {
    /* 0x0000 */ FStockpile Stockpile;
    /* 0x0058 */ int32_t nMaxAgentsBathing;
    /* 0x005c */ int32_t nAgentsBathing;
    /* 0x0060 */ FResourceCollection m_fluidUsedPerBath;
    /* 0x00b0 */ bool bRequestingSoap;
    /* 0x00b4 */ int32_t ExpectationStars;
};

// Size: 0x10
struct FBathingAgent {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ float timeUntilDone;
};

// Size: 0x2f0
class ABlockadeVisual : public AActor {
    /* 0x02c0 */ float m_leaveDelay;
    /* 0x02c4 */ float m_barrageInterval;
};

// Size: 0x2b0
class ABoat : public AActor {

    void AnimateBoatInOut(bool In);
};

// Size: 0x220
class UBoiler : public UActorComponent {
    /* 0x00d8 */ bool m_cheatNoInputsNeeded;
    /* 0x00dc */ float m_fuelBurnTime;
    /* 0x00e0 */ int32_t m_outputCapacity;
    /* 0x00e4 */ int32_t m_inputCapacity;
    /* 0x00e8 */ int32_t m_steamPerCycle;
    /* 0x00ec */ int32_t m_basePollutionPerSecond;
    /* 0x00f0 */ FIntVector m_entranceInternalPos;
    /* 0x0128 */ FStockpile m_inputStockpile;
    /* 0x0180 */ FStockpile m_outputStockpile;
    /* 0x01d8 */ float m_burnTimeRemaining;
    /* 0x01dc */ EBoilerState m_state;
    /* 0x01e8 */ UHeatSourceComponent* m_heatComponent;
    /* 0x01f8 */ FMulticastInlineDelegate runningChangedEvent;

    int32_t GetPollutionOutput(bool ignorePaused);
};

// Size: 0x8
struct FBuildingCyclerInfo {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t currentIdx;
};

// Size: 0x440
class UBuildingTemperatureWidget : public UArcoWidgetBase {
    /* 0x0438 */ UHeatInsulatorComponent* Insulator;

    FTemperatureWidgetState CalcState() const;
    void SetHeatProbePosByActor(AGridActor* Actor);
};

// Size: 0x448
class ABulldozeTool : public AActor {
    /* 0x02c8 */ UStaticMesh* m_arrowMesh_allDirs;
    /* 0x02d0 */ UStaticMesh* m_arrowMesh_oneDir;
    /* 0x02d8 */ UStaticMeshComponent* m_arrowViz;
    /* 0x02e0 */ TArray<AGridActor*> m_gridActorsUnderDrag;
    /* 0x02f0 */ TArray<AGridActor*> m_linkedGridActorsUnderDrag;
    /* 0x03f8 */ UStaticMeshComponent* m_bulldozeMesh;
    /* 0x0420 */ UWidgetComponent* m_bulldozeUiWidget;
    /* 0x0428 */ UContextualHoverWidgetComponent* m_buildingDetailsHoverWidget;
    /* 0x0430 */ float m_requiredHoldTime_large;
    /* 0x0434 */ float m_requiredHoldTime_small;

    FVector GetCursorPos() const;
};

// Size: 0x10
struct FCameraSettings {
    /* 0x0000 */ float panMultiplier;
    /* 0x0004 */ float rotMultiplier;
    /* 0x0008 */ float zoomMultiplier;
    /* 0x000c */ float freelookSmoothingSpeed;
};

// Size: 0x18
struct FCampResourceGroup : public FTableRowBase {
    /* 0x0008 */ TArray<FName> supportedResources;
};

// Size: 0x58
struct FCannonball {
};

// Size: 0x200
class UChoppable : public UActorComponent {
    /* 0x0110 */ float baseChopTime;
    /* 0x0118 */ TMap<FName, float> oreChopTimes;
    /* 0x0168 */ float chopUpPenalty;
    /* 0x016c */ int32_t nReturnedOnChop;
    /* 0x0170 */ float baseToolWear;
    /* 0x0174 */ bool isHardLabor;
    /* 0x0178 */ float currentChopTimeRemaining;
    /* 0x0180 */ FMulticastInlineDelegate OnDeath;
    /* 0x0190 */ FName chopAnim;
    /* 0x0198 */ FName chopTool;
    /* 0x01a0 */ bool bMineable;
    /* 0x01ac */ FName ResourceType;
    /* 0x01b4 */ int32_t m_resourcesLeft;
    /* 0x01d8 */ UStaticMesh* m_platformMeshBase;
    /* 0x01e0 */ TArray<FTransform> m_platformTransforms;
    /* 0x01f0 */ TArray<UStaticMeshComponent*> m_platformMeshes;
};

// Size: 0x18
struct FCircularAverage {
};

// Size: 0x90
struct FClawsGiftChoice {
    /* 0x0000 */ FName titleKey;
    /* 0x0008 */ FActionResult ActionResult;
    /* 0x0088 */ bool chosen;
};

// Size: 0x60
struct FClawsGiftPool : public FTableRowBase {
    /* 0x0008 */ FClawsGiftPoolGenerationOptions generationOptions;
    /* 0x0024 */ FName descriptorKey;
    /* 0x0030 */ TArray<FName> previewResources;
    /* 0x0040 */ TArray<FClawsGiftChoice> choices_resourceBundles;
    /* 0x0050 */ TArray<FClawsGiftChoice> choices_worldEffects;
};

// Size: 0x1c
struct FClawsGiftPoolGenerationOptions {
    /* 0x0000 */ int32_t nOptions;
    /* 0x0004 */ float percentChanceToShowTechnology;
    /* 0x0008 */ int32_t nMinTechnologies;
    /* 0x000c */ int32_t nMaxTechnologies;
    /* 0x0010 */ float percentChanceToShowWorldEffect;
    /* 0x0014 */ int32_t nMinWorldEffects;
    /* 0x0018 */ int32_t nMaxWorldEffects;
};

// Size: 0x10
struct FClothingState {
    /* 0x0000 */ FName currentClothingType;
    /* 0x0008 */ float durabilitySpan;
    /* 0x000c */ float durabilityTimePassed;
};

// Size: 0x210
class UColonyProblemsSummary : public UObject {
    /* 0x0118 */ TMap<int32_t, FString> m_pathingErrAgents;
    /* 0x0168 */ TSet<int32_t> m_longPathAgents;
};

// Size: 0x1f0
struct FColonyShip_Trade_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ FTradeBreakdown tradeCostsBreakdown;
    /* 0x01d0 */ bool canAffordReroll;
    /* 0x01d1 */ bool canReroll;
    /* 0x01d2 */ bool anyAccepted;
    /* 0x01d4 */ int32_t availableDiplomacy;
    /* 0x01d8 */ int32_t availableApproval;
    /* 0x01dc */ int32_t maxApproval;
    /* 0x01e0 */ int32_t acceptedWhiskerCount;
    /* 0x01e4 */ int32_t extraCostPerAcceptance;
    /* 0x01e8 */ int32_t costForAcceptingAllRemaining;
    /* 0x01ec */ bool canAffordAll;
};

// Size: 0x1c0
struct FColonyShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ int32_t startingColonistsCost;
};

// Size: 0xf0
struct FCombinedStatsForDay {
    /* 0x0000 */ FStats_debtInfo debtSummary;
    /* 0x0018 */ FStats_approvalInfo approvalSummary;
    /* 0x0050 */ FStats_resourcesInfo resourcesSummary;
    /* 0x00a0 */ TMap<FName, int32_t> miscGlobalStats;
};

// Size: 0x28
class ICommonPlayerToolInterface : public UInterface {
};

// Size: 0x2a0
struct FConstructionDetailsState {
    /* 0x0000 */ FStockpile constructionStockpile;
    /* 0x0058 */ float progressPercent;
    /* 0x005c */ FName associatedGridActor;
    /* 0x0068 */ FString associatedGridActorStringKey;
    /* 0x0078 */ int32_t nWorkers;
    /* 0x007c */ int32_t nInboundWorkers;
    /* 0x0080 */ bool validConstructable;
    /* 0x0081 */ bool isRuin;
    /* 0x0082 */ bool isRuinAssigned;
    /* 0x0088 */ FResourceCollection inboundResources;
    /* 0x00d8 */ FIntVector constructionPos;
    /* 0x00e4 */ bool lowResources;
    /* 0x00e5 */ bool allResourcesDelivered;
    /* 0x00e6 */ bool cantFindResources;
    /* 0x00e7 */ bool paused;
    /* 0x00e8 */ bool highPriority;
    /* 0x00f0 */ FDetailedResourceCost cancelCost;
    /* 0x0288 */ bool canAffordCancel;
    /* 0x0289 */ bool showWarehouseCfgs;
    /* 0x028a */ bool warehousecfg_disableInputs;
    /* 0x0290 */ UTexture2D* buildingIcon;
    /* 0x0298 */ FName variantParentKey;
};

// Size: 0x510
class UConstructionSite : public USceneComponent {
    /* 0x0260 */ UStaticMesh* m_scaffoldMesh;
    /* 0x0268 */ UStaticMesh* m_halfScaffoldMesh;
    /* 0x0270 */ UStaticMesh* m_entranceMesh;
    /* 0x0278 */ UStaticMesh* m_awningMesh;
    /* 0x0280 */ UStaticMesh* m_entranceMesh_HalfHeight;
    /* 0x0288 */ float m_defaultWorkerRequestInterval;
    /* 0x02a0 */ EConstructionType m_constructionType;
    /* 0x02a1 */ bool m_isEnterableConstruction;
    /* 0x02a2 */ bool m_ruinsAssignedForRebuild;
    /* 0x02a8 */ FResourceCollection m_totalCost;
    /* 0x032c */ bool m_disableResourceBuildingPostBuild;
    /* 0x0330 */ FStockpile m_storageStockpile;
    /* 0x0388 */ float timeToConstruct;
    /* 0x038c */ float timeProgressed;
    /* 0x0390 */ FName m_gridActorToBuild;
    /* 0x0398 */ TMap<FIntVector, UStaticMeshComponent*> m_scaffoldMeshes;
    /* 0x03e8 */ TArray<UStaticMeshComponent*> m_awnings;
    /* 0x03f8 */ TArray<UPointLightComponent*> m_lights;
    /* 0x0414 */ int32_t m_maxConstructionWorkers;
    /* 0x0418 */ TSet<APrototype_Agent*> m_inboundConstructionWorkers;
    /* 0x0468 */ TSet<APrototype_Agent*> m_inboundResourceDeliverers;
    /* 0x04e0 */ UParticleSystem* m_cascadeExplodeParticle;

    float PercentProgressed() const;
};

// Size: 0x6d0
class UContextualHoverWidgetComponent : public UWidgetComponent {
};

// Size: 0x188
struct FContiguousRail {
    /* 0x0000 */ FSimpleSpline railSpline;
};

// Size: 0xf8
struct FContractEmbarkHudState {
    /* 0x0000 */ TArray<FTax> debts;
    /* 0x0010 */ int32_t totalDebt;
    /* 0x0018 */ FTaxTradeInformation tradeInfo;
    /* 0x00e8 */ FString colonyName;
};

// Size: 0xf8
struct FCursorCastInfo {
    /* 0x0000 */ bool isExplicitZ;
    /* 0x0004 */ FIntVector gridPos_atZlevel;
    /* 0x0010 */ FIntVector gridPos_castToCollision;
    /* 0x0020 */ AActor* actorHitByCastToCollision;
    /* 0x0028 */ USceneComponent* componentHitByCastToCollision;
    /* 0x0030 */ AActor* decorativeHitByCollision;
    /* 0x0038 */ AActor* hitAgent;
    /* 0x0040 */ FVector worldPos_atZLevel;
    /* 0x0058 */ FVector worldPos_atZlevel_halfHeight;
    /* 0x0070 */ FVector worldPos_atCollision;
    /* 0x0088 */ ETerrainRayCastResult terrainResponse;
    /* 0x008c */ FIntVector gridPos_terrain;
    /* 0x0098 */ FIntVector gridPos_vegetation;
    /* 0x00a8 */ FVector2D screenPos_uv;
    /* 0x00b8 */ FVector2D screenPos_pixel;
    /* 0x00c8 */ FVector collisionNormal;
    /* 0x00e0 */ FVector worldPos_AtCollision_unclamped;
};

// Size: 0x340
class UCursorContextualWidget : public UUserWidget {

    void ClearMessage();
    void SetHoldProgress(float Percent);
    void SetMessageKey(FString Key);
    void ShowZResetHint(bool Show);
    void _updateDisplay(FResourceCollection baseCost, FResourceCollection supportCosts, FResourceCollection constructionCost, FResourceCollection lostResources, FResourceCollection salvageResources);
};

// Size: 0x300
class ACursorGrid : public AActor {
    /* 0x02a8 */ UMaterialInstanceDynamic* m_cursorGridMat;
    /* 0x02b0 */ UMaterialInstanceDynamic* m_slicedGridMat;
    /* 0x02b8 */ UStaticMeshComponent* m_baseGridMesh;
    /* 0x02c0 */ UInstancedStaticMeshComponent* m_slicedTerrainTileMesh;
    /* 0x02c8 */ float sliceGridOffset;
    /* 0x02cc */ float gridpanelScalar;
};

// Size: 0x2d0
class ACutscene : public AActor {
    /* 0x02a8 */ USceneComponent* m_rootComponent;
    /* 0x02b0 */ USpringArmComponent* m_springArm;
    /* 0x02b8 */ UCineCameraComponent* m_camera;
    /* 0x02c0 */ float returnCamBlendTime;
    /* 0x02c4 */ EEase returnBlendFunction;
    /* 0x02c8 */ float returnCamBlendFactor;
};

// Size: 0x20
struct FDayEventData {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ float timeOfDay;
    /* 0x0010 */ FMulticastInlineDelegate Delegate;
};

// Size: 0x108
struct FDaySummary_UI {
    /* 0x0000 */ FCombinedStatsForDay reportData;
    /* 0x00f0 */ bool showDaysUntilTaxDay;
    /* 0x00f4 */ int32_t daysUntilTaxDay;
    /* 0x00f8 */ int32_t dayBeingSummarized;
    /* 0x00fc */ bool isHistoricalReport;
    /* 0x00fd */ bool allowPageBack;
    /* 0x00fe */ bool allowPageFwd;
    /* 0x0100 */ int32_t standingMax;
};

// Size: 0x40
struct FDebtsSummary_Hud {
    /* 0x0000 */ TArray<FTax> debts;
    /* 0x0010 */ int32_t totalDebt;
    /* 0x0014 */ int32_t daysUntil;
    /* 0x0018 */ int32_t diplomacyPoints;
    /* 0x001c */ int32_t standing;
    /* 0x0020 */ int32_t maxStanding;
    /* 0x0024 */ bool standingDanger;
    /* 0x0028 */ FString standingString;
    /* 0x0038 */ bool showDiplomacyBuyHint;
};

// Size: 0xc8
struct FDebtsViewHudData {
    /* 0x0000 */ TArray<FTax> debts;
    /* 0x0010 */ int32_t totalDebt;
    /* 0x0018 */ TArray<FExchangeRate> exchangeRates;
    /* 0x0028 */ int32_t daysUntil;
    /* 0x002c */ int32_t tradeValueOfStoredResources;
    /* 0x0030 */ TMap<FName, int32_t> resourceCounts;
    /* 0x0080 */ int32_t currentStanding;
    /* 0x0084 */ int32_t maxStanding;
    /* 0x0088 */ bool dangerOfLosing;
    /* 0x0090 */ FString standingString;
    /* 0x00a0 */ int32_t diplomacyPoints;
    /* 0x00a8 */ TArray<FDiplomacyEntry> DiplomacyUpgrades;
    /* 0x00b8 */ bool canBuyDiplomacyUpgrades;
    /* 0x00bc */ int32_t newWhiskersCost;
    /* 0x00c0 */ bool canAffordWhiskers;
    /* 0x00c1 */ bool alreadySentWhiskers;
};

// Size: 0xa
struct FDebugCfg {
    /* 0x0000 */ bool showAgentPaths;
    /* 0x0001 */ bool showAgentGridOcc;
    /* 0x0002 */ bool showTowergridOccupancy;
    /* 0x0003 */ bool showPathability;
    /* 0x0004 */ bool showElevatorDebug;
    /* 0x0005 */ bool showAgentTerrainOffsets;
    /* 0x0006 */ bool drawPollutionSources;
    /* 0x0007 */ bool drawPollutionValues;
    /* 0x0008 */ bool drawTrainNetworkDebug;
    /* 0x0009 */ bool drawOceanReachabilityOverlay;
};

// Size: 0x4b0
class ADebugTool : public AActor {
    /* 0x02f0 */ UClass* m_controlWidgetClass;
    /* 0x0404 */ EDebugMode m_currentMode;
    /* 0x0408 */ FPathfinderDebug m_pathfinderDebugState;
    /* 0x0428 */ FPathfinderSearchParamArgs m_searchArgs;
    /* 0x0440 */ FPathfinderDebugResults m_debugResults;
    /* 0x04a0 */ bool isDebugEnabled;

    void CycleFloodParam(bool Positive);
    FString GetCurrentFloodFlagString();
    FVector2D GetSightsPos() const;
    void ReceiveHudAction(FHudAction HudAction);
    void SetSearchArgs(FPathfinderSearchParamArgs args);
};

// Size: 0xf8
class UDecorative : public UActorComponent {
    /* 0x00b8 */ FMulticastInlineDelegate triggeredAnim;
    /* 0x00c8 */ FMulticastInlineDelegate enabledChangedEvent;
    /* 0x00d8 */ int32_t triggerCount;
    /* 0x00dc */ FDecorativeEffect m_decorativeEffect;
    /* 0x00e4 */ bool m_requireFluid;
};

// Size: 0x8
struct FDecorativeEffect {
    /* 0x0000 */ EDecorativeType decorType;
    /* 0x0004 */ int32_t power;
};

// Size: 0x350
class UDecorativeSlot : public USceneComponent {
};

// Size: 0x460
class ADecorativeSlotTool : public AActor {
    /* 0x02b0 */ UChildActorComponent* m_previewComponent;
    /* 0x02b8 */ UStaticMeshComponent* m_quadrantWedge;
};

// Size: 0x18
struct FDelayedExplosion {
    /* 0x0000 */ UParticleSystemComponent* smokeParticle;
    /* 0x0008 */ float fuse;
    /* 0x0010 */ AGridActor* gridActorToExplode;
};

// Size: 0x198
struct FDetailedResourceCost {
    /* 0x0000 */ FResourceCollection baseCost;
    /* 0x0050 */ FResourceCollection constructionCost;
    /* 0x00a0 */ FResourceCollection supportsCost;
    /* 0x00f0 */ int32_t nSupports;
    /* 0x00f8 */ FResourceCollection lostResources;
    /* 0x0148 */ FResourceCollection salvageCost;
};

// Size: 0x88
struct FDeveloperToolState {
    /* 0x0000 */ bool isFreePlacement;
    /* 0x0004 */ float cameraPanSpeed;
    /* 0x0008 */ float minPanSpeed;
    /* 0x000c */ float maxPanSpeed;
    /* 0x0010 */ bool continuousRotation;
    /* 0x0014 */ float rotationSpeed;
    /* 0x0018 */ bool isFreecam;
    /* 0x001c */ int32_t volume_master;
    /* 0x0020 */ int32_t volume_music;
    /* 0x0024 */ int32_t volume_ambient;
    /* 0x0028 */ int32_t volume_sfx;
    /* 0x002c */ int32_t volume_ui;
    /* 0x0030 */ bool showSpatialHud;
    /* 0x0031 */ bool overrideHeat;
    /* 0x0034 */ int32_t overriddenHeatVal;
    /* 0x0038 */ int32_t overriddenHeatAsTemp;
    /* 0x003c */ EDayPhase dayPhase;
    /* 0x003d */ bool pauseDayProgression;
    /* 0x003e */ bool showMainHud;
    /* 0x0040 */ TArray<FTransform> savedCameraPositions;
    /* 0x0050 */ bool debugTemp;
    /* 0x0051 */ bool debugTempAsHeat;
    /* 0x0052 */ bool drawPaths;
    /* 0x0053 */ bool drawOccupancy;
    /* 0x0054 */ bool drawPathability;
    /* 0x0055 */ bool drawAgentCells;
    /* 0x0056 */ bool drawElevatorDebug;
    /* 0x0057 */ bool drawTerrainZInfo;
    /* 0x0058 */ bool drawPipeDebug;
    /* 0x0059 */ bool drawAim;
    /* 0x005a */ bool drawCursorDebug;
    /* 0x005b */ bool disableAutoHeatOverlay;
    /* 0x005c */ bool drawPollutionSources;
    /* 0x005d */ bool drawPollutionValues;
    /* 0x005e */ bool drawRailDebug;
    /* 0x005f */ bool showFps;
    /* 0x0060 */ bool showOceanReachabilityOverlay;
    /* 0x0068 */ FString saveName;
    /* 0x0078 */ FIntVector mapSize;
    /* 0x0084 */ float resourceScaling;
};

// Size: 0x30
struct FDiplomacyEntry {
    /* 0x0000 */ FName unlockKey;
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Description;
    /* 0x0028 */ int32_t Cost;
    /* 0x002c */ bool canAfford;
    /* 0x002d */ bool unlocked;
};

// Size: 0x10
struct FDiplomacyUpgrade : public FTableRowBase {
    /* 0x0008 */ int32_t Cost;
};

// Size: 0x18
struct FDiplomaticStandingSummary {
    /* 0x0000 */ int32_t currentStanding;
    /* 0x0004 */ int32_t maxStanding;
    /* 0x0008 */ FString asString;
};

// Size: 0x1
struct FDir {
    /* 0x0000 */ DirectionEnum rawDir;
};

enum class DirectionEnum {
    NORTH = 0,
    EAST = 1,
    SOUTH = 2,
    WEST = 3,
    UP = 4,
    DOWN = 5,
    EDIR_LAST = 6,
    DirectionEnum_MAX = 7,
};

// Size: 0x1b8
struct FDockableShipData {
    /* 0x0000 */ int32_t shipId;
    /* 0x0004 */ EShipType shipType;
    /* 0x0005 */ EShipState shipState;
    /* 0x0008 */ float secondsUntilArrival;
    /* 0x000c */ float secondsUntilAutoLeave_total;
    /* 0x0010 */ float secondsUntilAutoLeave;
    /* 0x0014 */ bool canAutoleave;
    /* 0x0018 */ FShipData_Colonists asColonists;
    /* 0x0030 */ FShipData_TaxShip asTaxShip;
    /* 0x0088 */ FShipData_PirateShip asPirateShip;
    /* 0x00e8 */ FShipData_SmugglerTraderShip asSmugglerTrader;
    /* 0x0148 */ FShipData_EmbarkResources asEmbarkSupplies;
    /* 0x01a0 */ FSupplyShipState asSupplyShip;
};

// Size: 0x428
class UDockedBoatPanel_Colonists : public UArcoWidgetBase {

    FColonyShip_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_ColonistsTrade : public UArcoWidgetBase {

    FColonyShip_Trade_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_MissionGiver : public UArcoWidgetBase {

    FMissionShip_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_PirateShip : public UArcoWidgetBase {

    FPirateShip_UiState CalcState();
};

// Size: 0x448
class UDockedBoatPanel_SmugglerTrader : public UArcoView {

    FSmugglerTraderShip_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_Supplies : public UArcoWidgetBase {

    FSupplyShip_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_SupplyTrader : public UArcoWidgetBase {

    FSupplyTradeShip_UiState CalcState();
};

// Size: 0x428
class UDockedBoatPanel_Taxes : public UArcoWidgetBase {

    FTaxShip_UiState CalcState();
};

// Size: 0x38
struct FDoorway {
    /* 0x0000 */ FVector relativePos;
    /* 0x0018 */ FRotator relativeRot;
    /* 0x0030 */ int32_t associatedDoorwayId;
};

// Size: 0xa8
struct FDoorwayRenderIdMap {
};

// Size: 0x10
struct FDrinkingAgent {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ float timeLeftToDrink;
};

enum class EActionResultType {
    NoEffect = 0,
    ResourceReward = 1,
    ResourceLoss = 2,
    AgentReward = 3,
    AgentLoss = 4,
    EffectSpawn = 5,
    InfluenceGain = 6,
    InfluenceLoss = 7,
    UNUSED_1 = 8,
    UNUSED_2 = 9,
    UNUSED_3 = 10,
    GiveUnlock = 11,
    UNUSED_4 = 12,
    AcceptQuest = 13,
    RejectQuest = 14,
    TurnInQuest = 15,
    DebtCredit = 16,
    EActionResultType_MAX = 17,
};

enum class EActorRefundRule {
    STANDARD_REFUND = 0,
    NO_REFUND = 1,
    FULL_REFUND = 2,
    EActorRefundRule_MAX = 3,
};

enum class EAgentDeleteReason {
    ABANDON_ISLAND = 0,
    DEATH_ILLNESS = 1,
    DEATH_WOUND = 2,
    DEATH_STARVATION = 3,
    EAgentDeleteReason_MAX = 4,
};

enum class EAgentDesire {
    EDESIRE_NONE = 0,
    FOOD_BASIC = 1,
    DRINK_BASIC = 2,
    REFRESHMENT = 3,
    BATHING = 4,
    SLEEP_BASIC = 5,
    HEALING = 6,
    RESTROOM = 7,
    TOOLS = 8,
    CLOTHES = 9,
    EAgentDesire_MAX = 10,
};

enum class EAgentDetailsMode {
    NONE = 0,
    MOVING_AGENT = 1,
    ASSIGNING_HOUSE = 2,
    ASSIGNING_INDUSTRY = 3,
    EAgentDetailsMode_MAX = 4,
};

enum class EAgentEducation {
    None = 0,
    Apprentice = 1,
    Master = 3,
    Educated = 4,
    EducatedApprentice = 5,
    EducatedMaster = 7,
    Schooled = 8,
    SchooledApprentice = 9,
    SchooledMaster = 11,
    SchoolEducated = 12,
    SchoolEducatedApprentice = 13,
    SchoolEducatedMaster = 15,
    ApprenticeOnly = 128,
    EAgentEducation_MAX = 129,
};

enum class EAgentFilter {
    ALL = 0,
    UNEMPLOYED = 1,
    UNHOUSED = 2,
    EAgentFilter_MAX = 3,
};

enum class EAgentModifierSeverity {
    MODIFIER_DIRE = 0,
    MODIFIRE_NEGATIVE = 1,
    MODIFIER_NEUTRAL = 2,
    MODIFIER_GOOD = 3,
    MODIFIER_GREAT = 4,
    EAgentModifierSeverity_MAX = 5,
};

enum class EAgentSortOrder {
    NEW = 0,
    HAPPINESS = 1,
    PRODUCTIVITY = 2,
    HAULING = 3,
    SPEED = 4,
    EAgentSortOrder_MAX = 5,
};

enum class EAgentTemperatureDir {
    DOWN = 0,
    STILL = 1,
    UP = 2,
    EAgentTemperatureDir_MAX = 3,
};

enum class EAgentTraitType {
    Positive = 0,
    Negative = 1,
    Neutral = 2,
    EAgentTraitType_MAX = 3,
};

enum class EApprovalDeltaType {
    POSITIVE_THOUGHT_CASHOUT = 0,
    POLICY_COST = 1,
    POLICY_GAIN = 2,
    OTHER_ACTION = 3,
    REWARD = 4,
    ARRIVALS_ACCEPT = 5,
    NEGATIVE_THOUGHT_LOSS = 6,
    OVERTIME = 7,
    EApprovalDeltaType_MAX = 8,
};

enum class EArcoGameType {
    NEW_GENERATION = 0,
    STATIC_MAP_FILE = 1,
    SAVE_FILE = 2,
    SAVE_FILE_REPLAY = 3,
    EArcoGameType_MAX = 4,
};

enum class EArcoPlayerMode {
    INVALID = 0,
    SELECT = 1,
    BUILD_FLOOR = 2,
    BUILD_PROPS = 3,
    BUILD_PIPE = 4,
    BUILD_SLOTTED_DECORATIVE = 5,
    BULLDOZE = 6,
    DEBUG = 7,
    MINE = 8,
    FARM = 9,
    CHOPPING_PRIORITY = 10,
    FORAGING_PRIORITY = 11,
    FREECAM = 12,
    TERRAFORM = 13,
    NAVY = 14,
    BUILD_AIMBELT = 15,
    BUILD_RAILROAD = 16,
    BUILD_TRAIN = 17,
    TERRAIN = 18,
    EArcoPlayerMode_MAX = 19,
};

enum class EArco_PlayerAction {
    BAD_ACTION = 0,
    BACK = 1,
    SELECT = 2,
    ROTATE = 3,
    RAISE = 4,
    LOWER = 5,
    TOGGLE_HEIGHT_LOCK = 6,
    TOGGLE_BULLDOZE = 7,
    MODIFIER_KEY = 8,
    TOGGLE_SLICE_VIEW = 9,
    OPEN_MESSAGES = 10,
    MOVE_FORWARD = 11,
    MOVE_BACK = 12,
    MOVE_LEFT = 13,
    MOVE_RIGHT = 14,
    ZOOM_IN = 15,
    ZOOM_OUT = 16,
    TOGGLE_HEAT_VIEW = 17,
    CLONE = 18,
    TAB_LEFT = 19,
    TAB_RIGHT = 20,
    SPEED_1 = 21,
    SPEED_2 = 22,
    SPEED_3 = 23,
    ROTATE_CAM_CW = 24,
    ROTATE_CAM_CCW = 25,
    PAUSE = 26,
    HOTKEY_MINETOOL = 27,
    HOTKEY_FARMTOOL = 28,
    TOGGLE_POLLUTION_VIEW = 29,
    CYCLE_VARIANT = 30,
    EArco_MAX = 31,
};

enum class EArco_PlayerVerb {
    BACK = 0,
    CLOSE = 1,
    ACCEPT = 2,
    SELECT = 3,
    ROTATE = 4,
    BEGIN_DRAG = 5,
    END_DRAG = 6,
    CANCEL_DRAG = 7,
    RAISE = 8,
    LOWER = 9,
    RAISE_SLICE = 10,
    LOWER_SLICE = 11,
    LOCK_HEIGHT = 12,
    UNLOCK_HEIGHT = 13,
    TOGGLE_BULLDOZE = 14,
    REMOVAL_MODE = 15,
    ENABLE_SLICE_VIEW = 16,
    DISABLE_SLICE_VIEW = 17,
    OPEN_MESSAGES = 18,
    TOGGLE_HEAT = 19,
    ROTATE_CAM_CW = 20,
    ROTATE_CAM_CCW = 21,
    HOTKEY_MINETOOL = 22,
    PAUSE = 23,
    HOTKEY_FARMTOOL = 24,
    TOGGLE_POLLUTION = 25,
    SCROLL_HEIGHT_SPECIAL = 26,
    CYCLE_VARIANT = 27,
    INVALID = 28,
    EArco_MAX = 29,
};

enum class EAudioSoundPhase {
    DAWN = 0,
    DAY = 1,
    NIGHT = 2,
    UNDERGROUND = 3,
    INVALID = 4,
    EAudioSoundPhase_MAX = 5,
};

enum class EBehaviorType {
    UNKNOWN = 0,
    FOLLOW_PATH = 1,
    FIND_AND_PASS_TO_ENTERABLE = 2,
    FOLLOW_PATH_AND_PASS_TO_ENTERABLE = 3,
    FOLLOW_PATH_AND_ADD_RESOURCE = 4,
    FOLLOW_PATH_AND_DRAIN_RESOURCE = 5,
    FLOOD_AND_RETRIEVE_RESOURCES = 6,
    FLOOD_AND_EQUIP_TOOLS = 7,
    FLOOD_AND_SUPPLY_DEFICITS = 8,
    DELIVER_RESOURCES_TO_STORAGE = 9,
    FIND_AND_FULFILL_NEED = 10,
    HARVEST_RESOURCE = 11,
    EMOTE = 12,
    WANDER = 13,
    SLEEP_GROUND = 14,
    GO_HOME = 15,
    GO_WORKPLACE = 16,
    PATH_TO_DEST_AND_ADD_RESOURCE = 17,
    PATH_TO_DEST_AND_DRAIN_RESOURCE = 18,
    FULFILL_JOBTICKET = 19,
    SUPPLIER_WORKER_LOOP = 20,
    FARM = 21,
    UNUSED0 = 22,
    UNUSED1 = 23,
    UNUSED2 = 24,
    CONSTRUCT_BUILDING = 25,
    RESERVE_AND_TRANSPORT_RESOURCE_BETWEEN_BUILDINGS = 26,
    DELIVER_TO_CONSTRUCTION_THEN_BUILD_IF_VALID = 27,
    FLY_TO_TARGET = 28,
    SEEK_HEAT = 29,
    LOGISTICS_WORKER_LOOP = 30,
    TERRAFORM = 31,
    EXPORTS_WORKER_LOOP = 32,
    EBehaviorType_MAX = 33,
};

enum class EBoilerState {
    IDLE = 0,
    PAUSED_BY_PLAYER = 1,
    BURNING = 2,
    EBoilerState_MAX = 3,
};

enum class EBuildingHeatThreshold {
    DANGEROUSLY_COLD = 0,
    CHILLY = 1,
    WARM = 2,
    EBuildingHeatThreshold_MAX = 3,
};

enum class ECameraBehavior {
    CAST = 0,
    EXPLICIT_Z = 1,
    SLICE_Z = 2,
    ECameraBehavior_MAX = 3,
};

enum class ECarryMode {
    BY_HAND = 0,
    BY_CART = 1,
    BY_MAX = 2,
};

enum class ECheckCarryApproval {
    ASSUME_AFFORDABLE = 0,
    CHECK_AFFORDABLE = 1,
    ECheckCarryApproval_MAX = 2,
};

enum class EConstructionType {
    NewConstruction = 0,
    RuinsConstruction = 1,
    RuinsBuyout = 2,
    EConstructionType_MAX = 3,
};

enum class EDayPhase {
    MID_DAY = 0,
    LATE_NIGHT = 1,
    N_PHASES = 2,
    EDayPhase_MAX = 3,
};

enum class EDebugMode {
    UNINITIALIZED = 0,
    PATHING_POINT_TO_POINT = 1,
    PATHING_FIND_FLAG = 2,
    PATHING_HEAT = 3,
    PATHING_NEAREST_WHISKER = 4,
    PATHING_DELIVER_TO_STORAGE = 5,
    PATHING_RETRIEVE_RESOURCES = 6,
    PATHING_WANDER = 7,
    PATHING_CUSTOM = 8,
    KILL_WHISKER = 9,
    EDebugMode_MAX = 10,
};

enum class EDecorativeSlotPos {
    OUTER_EDGE = 0,
    INNER_EDGE = 1,
    EDecorativeSlotPos_MAX = 2,
};

enum class EDecorativeType {
    Beauty = 0,
    Intimidation = 1,
    EDecorativeType_MAX = 2,
};

enum class EDockState {
    NO_SHIP = 0,
    SHIP_DOCKING = 1,
    SHIP_DOCKED = 2,
    EDockState_MAX = 3,
};

enum class EElevatorAction {
    TOO_SHORT = 0,
    WAITING_AT_FLOOR = 1,
    TRAVELLING = 2,
    EElevatorAction_MAX = 3,
};

enum class EEmbarkPhase {
    PLACE_DOCK = 0,
    ACCEPT_ARRIVALS = 1,
    BUILD_WAREHOUSE = 2,
    ACCEPT_SUPPLIES = 3,
    SIGN_CONTRACT = 4,
    EMBARKED = 5,
    INVALID = 6,
    EEmbarkPhase_MAX = 7,
};

enum class EExpectationResult {
    Negative = 0,
    Neutral = 1,
    Positive = 2,
    EExpectationResult_MAX = 3,
};

enum class EExpectationType {
    Housing = 0,
    Food = 1,
    Clothing = 2,
    Bathing = 3,
    Dining = 4,
    Supplies = 5,
    MAX = 6,
};

enum class EFarmToolTemperatureResponse {
    None = 0,
    Good = 1,
    NotGrowing = 2,
    Rotting = 3,
    EFarmToolTemperatureResponse_MAX = 4,
};

enum class EFuelSource {
    SOLID_FUEL = 0,
    STEAM = 1,
    TEMPORARY = 2,
    EFuelSource_MAX = 3,
};

enum class EGameSaveResult {
    SUCCESS = 0,
    FAILED_PACKING_NOT_START_REC = 1,
    FAILED_PACKING_BUFFER_GEN = 2,
    FAILED_PACKING_COMPRESSION = 3,
    FAILED_PACKING_DECOMPRESS_TEST = 4,
    FAILED_VERIFY_UNPACKING_NOT_START_REC = 5,
    FAILED_VERIFY_UNPACKING_BAD_ALGO = 6,
    FAILED_VERIFY_UNPACKING_BAD_SIZE = 7,
    FAILED_VERIFY_UNPACKING_UNCOMPRESS = 8,
    FAILED_VERIFY_UNPACKING_PARSE_FAILED = 9,
    FAILED_FILE_WRITE = 10,
    FAILED_VERIFY_FILE_WRITE = 11,
    FAILED_INVALID_FLATBUFFER_AFTER_PACK = 12,
    FAILED_VERIFY_UNPACKING_MISSING_RECORD = 13,
    EGameSaveResult_MAX = 14,
};

enum class EGoalType {
    Population = 0,
    BuildingTypeCount = 1,
    ResourceEarned = 2,
    ResourceTurnIn = 3,
    Influence = 4,
    ResidentialCapacity = 5,
    OneDayProduction = 6,
    FoodRationing = 7,
    REMOVED_NumExportsTotal = 8,
    ResourceNodesDestroyed = 9,
    FarmProduction = 10,
    WorkAssignment = 11,
    RefusePirateRequest = 12,
    EDecorCount = 13,
    EPathDecorCount = 14,
    ResourcesInStorage = 15,
    AvailableFood = 16,
    HomelessCount_BelowThreshold = 17,
    WorkerCount_BelowThreshold = 18,
    HungerCount_BelowThreshold = 19,
    SurviveDays = 20,
    Smuggle = 21,
    FindIslands = 22,
    DebtPaidInFull = 23,
    EGoalType_MAX = 24,
};

enum class EGridOccupancy {
    NO_OCCUPATION = 0,
    FULL_OCCUPATION = 1,
    FLOOR_OCCUPATION = 2,
    DEMAND_PARTIAL_OCCUPATION = 3,
    EGridOccupancy_MAX = 4,
};

enum class EHaulVisualPos {
    ANCHOR_HAND = 0,
    ANCHOR_BACK = 1,
    ANCHOR_MAX = 2,
};

enum class EHeaterState {
    IDLE = 0,
    PAUSED_BY_PLAYER = 1,
    BURNING = 2,
    EHeaterState_MAX = 3,
};

enum class EHighlightMode {
    HIGHLIGHT_SELECT = 0,
    HIGHLIGHT_BULLDOZE = 1,
    HIGHLIGHT_SELECTED = 2,
    HIGHLIGHT_MAX = 3,
};

enum class EIndustryState {
    PRODUCING = 0,
    IDLE_OUTPUT_FULL = 1,
    IDLE_MISSING_INPUTS = 2,
    IDLE_NO_WORKERS = 3,
    IDLE_PAUSED = 4,
    IDLE_NORECIPE = 5,
    IDLE_SAFETYSTOP = 6,
    IDLE_NO_PUMPABLE_WATER = 7,
    IDLE_BLOCKED_DOCK = 8,
    IDLE_PRODUCTION_LIMIT = 9,
    EIndustryState_MAX = 10,
};

enum class EInitPhase {
    INIT = 0,
    UPDATING_MASTERSYNC = 1,
    FIRST_FRAME_DELAY = 2,
    INIT_ARCOSYS = 3,
    PLAYING_REPLAY = 4,
    DONE = 5,
    ERR = 6,
    EInitPhase_MAX = 7,
};

enum class EJobCategory {
    INVALID = 0,
    MAINTENANCE = 1,
    TRASH = 2,
    FIRE = 3,
    WATERPLANT = 4,
    REPAIR = 5,
    EJobCategory_MAX = 6,
};

enum class ELoadBehavior {
    NEW_MAP = 0,
    SAVE_REPLAY = 1,
    SAVE_STATE = 2,
    ELoadBehavior_MAX = 3,
};

enum class EMailType {
    UNLOCK = 0,
    EMERGENCY_QUEST = 1,
    EMERGENCY_QUEST_FAILED = 2,
    EMERGENCY_QUEST_COMPLETED = 3,
    CLAWS_REWARD_SELECTION = 4,
    EMailType_MAX = 5,
};

enum class EMusicOverridePriority {
    NONE = 0,
    EMBARK = 1,
    DOCKED_SHIP = 2,
    CUTSCENE = 3,
    OTHER = 4,
    EMusicOverridePriority_MAX = 5,
};

enum class ENavyFormationType {
    None = 0,
    Line = 1,
    Square = 2,
    Spincer = 3,
    Wing = 4,
    ENavyFormationType_MAX = 5,
};

enum class ENavyHudWindowDirection {
    None = 0,
    Up = 1,
    UpRight = 2,
    Right = 3,
    DownRight = 4,
    Down = 5,
    DownLeft = 6,
    Left = 7,
    UpLeft = 8,
    ENavyHudWindowDirection_MAX = 9,
};

enum class ENodeBoundary {
    BLOCKED = 0,
    OPEN = 1,
    EXIT_ONLY = 2,
    ENTER_ONLY = 4,
    TRAVEL_SYSTEM_ENTER = 8,
    SPECIAL_INTERACTION = 16,
    ENodeBoundary_MAX = 17,
};

enum class EOverviewUiMode {
    NONE = 0,
    ASSIGNING_HOUSE = 1,
    ASSIGNING_INDUSTRY = 2,
    EOverviewUiMode_MAX = 3,
};

enum class EPathableNodeFlag {
    NONE = 0,
    TRAVERSIBLE_PASS = 1,
    ENTERABLE_PASS = 2,
    FOOD_SOURCE = 4,
    WATER_SOURCE = 8,
    STORAGE_LOCATION = 16,
    SURFACE_HARVESTABLE = 32,
    PLAYER_PATH = 64,
    HOUSING = 128,
    TERRAFORMJOB = 256,
    MEDICAL_CARE = 512,
    BATH_LOCATION = 1024,
    FARMLAND = 2048,
    IGNORE_BLOCKING_CONSTRUCTION = 4096,
    BLOCK_TO_MINE = 8192,
    SUPPLIABLE = 16384,
    UNUSED_15 = 32768,
    EPathableNodeFlag_MAX = 32769,
};

enum class EPipeCategory {
    FLUID = 0,
    STEAM = 1,
    EPipeCategory_MAX = 2,
};

enum class EPipeType {
    PIPE = 0,
    ADAPTER = 1,
    VALVE = 2,
    EPipeType_MAX = 3,
};

enum class EPlacementResponse {
    VALID = 0,
    BLOCKED_TERRAIN = 1,
    BLOCKED = 2,
    NOT_OVER_WATER = 3,
    MISSING_REQUESTED_BUFFER_SPACE = 4,
    NOT_SEA_LEVEL = 5,
    UNDERWATER = 6,
    NOT_SHORE = 7,
    NOT_GROUNDED = 8,
    BAD_DEFINITION = 9,
    BLOCKED_ENTRANCES = 10,
    PLACING_VALVE_ON_PIPE = 11,
    PLACING_ONTO_RAIL = 12,
    NOT_AFFORDABLE = 13,
    EPlacementResponse_MAX = 14,
};

enum class EPolicyCardType {
    ACTIVE_POLICY = 0,
    EMPTY_SLOT = 1,
    POLICY_OPTION_UNLOCKED = 2,
    POLICY_OPTION_LOCKED = 3,
    EPolicyCardType_MAX = 4,
};

enum class EProblemSummaryType {
    AGENTS_MISSING_HOME = 0,
    AGENTS_WITH_MODIFIER = 1,
    CONSTRUCTION_NO_IDLERS = 2,
    CONSTRUCTION_MISSING_MATS = 3,
    PATHING_FAILURES = 4,
    LOW_FOOD = 5,
    DESTROYED_STRUCTURE = 6,
    SUSPICIOUSLY_LONG_PATH = 7,
    UNBURIED_WHISKERS = 8,
    NO_RESOURCES_NEAR_CAMP = 9,
    CAMP_OUTPUT_FULL = 10,
    EProblemSummaryType_MAX = 11,
};

enum class EQuestType {
    STANDARD_REQUEST = 0,
    PRIORITY_EMERGENCY = 1,
    EQuestType_MAX = 2,
};

enum class ERadiusHighlightRule {
    HIGHLIGHT_INDUSTRIES = 0,
    HIGHLIGHT_GRIDACTORS = 1,
    HIGHLIGHT_HEATABLE = 2,
    HIGHLIGHT_NONE = 3,
    HIGHLIGHT_MAX = 4,
};

enum class ERadiusHighlightType {
    HIGHLIGHT_INDUSTRIES = 0,
    HIGHLIGHT_GRIDACTORS = 1,
    HIGHLIGHT_MAX = 2,
};

enum class EResourceMarkingType {
    Chopping = 0,
    Foraging = 1,
    EResourceMarkingType_MAX = 2,
};

enum class EResourceSpawnerMode {
    SOLID_RESOURCE_SPAWNER = 0,
    SOLID_RESOURCE_SINK = 1,
    FLUID_SPAWNER = 2,
    FLUID_SINK = 3,
    EResourceSpawnerMode_MAX = 4,
};

enum class EResourceValueContext {
    EXPORT = 0,
    IMPORT_SMUGGLER = 1,
    EResourceValueContext_MAX = 2,
};

enum class ESaveLocation {
    CUSTOM_MAPS = 0,
    SAVED_GAMES = 1,
    DEVELOPER_ASSERT_SAVES = 2,
    BAD_LOCATION = 3,
    ESaveLocation_MAX = 4,
};

enum class EShipState {
    TRAVELLING = 0,
    AT_DOCK = 1,
    EShipState_MAX = 2,
};

enum class EShipType {
    TAX_SHIP = 0,
    COLONIST_SHIP_EMBARK = 1,
    SUPPLY_SHIP_EMBARK = 2,
    SUPPLY_SHIP_TRADE = 3,
    COLONIST_SHIP_TRADE = 4,
    PIRATE_SHIP = 5,
    NO_SHIP = 6,
    SMUGGLER_TRADER_SHIP = 7,
    EShipType_MAX = 8,
};

enum class ESimAction {
    SPAWN_AGENT = 0,
    PICKUP_AGENT = 1,
    DROP_AGENT = 2,
    PLACE_GRIDACTOR = 3,
    REMOVE_GRIDACTOR = 4,
    REPLACE_GRIDACTOR = 5,
    BULK_PLACE_GRIDACTOR = 6,
    BULK_REMOVE_GRIDACTOR = 7,
    SPAWN_PLAYER_RESOURCE = 8,
    SPEND_PLAYER_RESOURCE = 9,
    ACCEPT_QUEST_REWARD = 10,
    CHEAT_SPAWN_SHIP = 11,
    DECREASE_WORKERS = 12,
    SHIPYARD_BUILD_SHIP = 13,
    CHEAT_FREE_ACTIONS = 14,
    DAY_CYCLE_PAUSE = 15,
    DAY_CYCLE_JUMPTOPHASE = 16,
    BEGIN_FACTION_REQUEST = 17,
    DEBUG_REVOKE_UNLOCK = 18,
    SENDOFF_FACTION_REQUEST = 19,
    PURCHASE_TECH = 20,
    DEBUG_KILL_AGENT = 21,
    DEBUG_GIVE_UNLOCK = 22,
    GIVE_INFLUENCE = 23,
    ADD_FREE_WORKER_TO_SLOT = 24,
    FIRE_WORKER = 25,
    MOVE_GRIDACTOR = 26,
    CHEAT_ALL_UNLOCKS = 27,
    FORCE_DELIVERY = 28,
    SET_RESOURCE_RESERVE = 29,
    SET_RESOURCE_MINHOLD = 30,
    TRACK_RESOURCE = 31,
    OBSOLETE_NEW_DAY_REPORT = 32,
    START_NEW_DAY = 33,
    RESOLVE_EVENT = 34,
    INSTANT_DELIVERY = 35,
    BEGIN_RESEARCH = 36,
    SET_FOOD_RATIONINING = 37,
    SET_FOOD_RAW_ONLY = 38,
    SET_FOOD_PREPARED_ONLY = 39,
    SIGNPOST_SET_MSG = 40,
    DIG_CELL = 41,
    SET_POWER_OVERDRIVE = 42,
    TOGGLE_MINE_BLOCK = 43,
    GIVE_RESEARCH = 44,
    EMBARK = 45,
    REROLL_FACTION_REQUESTS = 46,
    MARK_RESOURCE_FOR_HARVEST = 47,
    PLACE_CONSTRUCTION_SITE = 48,
    ASSIGN_SOURCE_STOCKPILE = 49,
    ASSIGN_DEST_STOCKPILE = 50,
    POLICY_ENACT = 51,
    POLICY_CANCEL = 52,
    POLICY_UNLOCK = 53,
    TOGGLE_SKIP_EOD = 54,
    BLOWUP_BUILDING = 55,
    ASSIGN_RECONSTRUCTION = 56,
    OVERRIDE_HEAT = 57,
    TOGGLE_HEATER = 58,
    TOGGLE_HEATER_AUTOPAUSE = 59,
    DAY_CYCLE_JUMP_TO_TIME = 60,
    DISABLE_BUILDING = 61,
    SWITCH_INDUSTRY_RECIPE = 62,
    SPAWN_PLAYER_RESOURCE_PARTIAL = 63,
    SPAWN_PLAYER_RESOURCE_PARTIAL_COMMIT = 64,
    TOGGLE_FARM_BLOCK = 65,
    RENAME_AGENT = 66,
    ASSIGN_HOUSING_DIRECTLY = 67,
    ASSIGN_HOUSING_DIRECTLY_TO_SLOT = 68,
    PRIORITIZE_CONSTRUCTION = 69,
    SPAWN_TERRAIN_BLOCK = 70,
    SET_FORCE_EMPTY_ON_WAREHOUSE = 71,
    SET_WHITELIST_ENABLE = 72,
    SET_WHITELIST_FILTER = 73,
    CLEAR_WHITELIST_FILTER = 74,
    CLEAR_SOURCE_STOCKPILES = 75,
    CLEAR_DEST_STOCKPILES = 76,
    FARM_SET_SEED = 77,
    FARM_SET_EARLY_HARVEST = 78,
    FARM_SET_FERTILIZER = 79,
    FARM_FIELD_DRAG_COMMIT = 80,
    SHIP_SELL_RESOURCE = 81,
    SHIP_COMMIT_PAYMENT = 82,
    SHIP_ACCEPT = 83,
    SHIP_SUPPLY_CHOOSE_IDX = 84,
    SET_INDUSTRY_MAINTENANCE_THRESHOLD = 85,
    SHIP_SELECT_AGENT = 86,
    REQUEST_ADDITIONAL_WHISKERS = 87,
    SHIP_REROLL_COLONISTS = 88,
    PURCHASE_DIPLOMACY_UPGRADE = 89,
    GIVE_DIPLOMACY = 90,
    SET_ALLOW_DROPOFF_ON_WAREHOUSE = 91,
    ENABLE_GATHER_RESOURCE = 92,
    SET_HEATER_OVERDRIVE = 93,
    ADD_REMOVE_DECORATIVE_SLOT = 94,
    EMERGENCY_REPAIR_STRUCTURE = 95,
    SET_SKIP_EOD = 96,
    DEVELOPER_ADD_WORLDEFFECT = 97,
    DEVELOPER_REMOVE_WORLDEFFECT = 98,
    CLOSE_VALVE = 99,
    FORCE_WEATHER = 100,
    CONFIGURE_INFINITE_SOURCE_SINK = 101,
    SET_MINING_LADDER_UNUSED = 102,
    UPGRADE_HOUSE = 103,
    TOGGLE_OVERTIME = 104,
    SET_JUMPPAD_DESTINATION = 105,
    SET_OVERFLOW_THRESHOLD = 106,
    TRAIN_PLACE = 107,
    TRAIN_REMOVE = 108,
    TRAIN_KICK = 109,
    CATALYST_ENABLE = 110,
    CHEAT_STARTQUEST = 111,
    GIFT_CHOOSE_GIFT = 112,
    GIFT_REROLL = 113,
    INCREASE_WORKERS = 114,
    TOGGLE_HOUSING_LOCK = 115,
    SET_RESOURCE_SUBCATEGORY_MINHOLD = 116,
    WORKSHIP_ASSIGN_TO_DOCK = 117,
    DEVELOPER_UNLOCK_ALL_VIA_GIFTS = 118,
    START_RESEARCH = 119,
    CLEAR_RESEARCH = 120,
    SET_INPUT_ASSIGNED_ONLY = 121,
    FARM_SET_REMOVING_ROCKS = 122,
    DEBUG_EJECT_AGENTS = 123,
    DEBUG_IMMEDIATE_EOD = 124,
    TOGGLE_TERRAFORM_BLOCK = 125,
    TERRAFORM_ASSIGNMENT_ACTION = 126,
    WHITELIST_SET_ALL_REJECT = 127,
    WHITELIST_SET_ALL_ALLOW = 128,
    SHIP_DISMISS = 129,
    ADD_FUEL_TO_HEATER = 130,
    TOGGLE_PRECONSTRUCTION_DISABLE = 131,
    SET_PRODUCTION_LIMIT = 132,
    FORCE_TRAIN_NETWORK_UPDATES = 133,
    EXPORTS_SET_RESOURCE_ENABLED = 134,
    EXPORTS_SET_RESOURCE_MINHOLD = 135,
    EXPORTS_SET_PERCENT_PAY = 136,
    EXPORTS_SET_ENABLE_FOR_SHIPTYPE = 137,
    SET_WORK_RADIUS = 138,
    FINAL_ACTION = 139,
    ESimAction_MAX = 140,
};

enum class ESimPauseReason {
    PAUSE_GAMEINIT = 0,
    PAUSE_PLAYER = 1,
    PAUSE_UI = 2,
    PAUSE_EOD = 3,
    PAUSE_BLOCKING_EVENT = 4,
    PAUSE_RADIAL_MENU = 5,
    PAUSE_MAX = 6,
};

enum class EStatResourceFlowType {
    EXTRACTED = 0,
    PRODUCED = 1,
    CONSUMED_INDUSTRY = 2,
    CONSUMED_AGENT = 3,
    CONSTRUCTION = 4,
    TRADE = 5,
    LOST = 6,
    EStatResourceFlowType_MAX = 7,
};

enum class EStructureType {
    HOUSING = 0,
    INDUSTRY = 1,
    GATHERER = 2,
    AESTHETIC = 3,
    TRAVEL = 4,
    VENDING = 5,
    STORAGE = 6,
    WATER = 7,
    OTHER = 8,
    JOB_BUILDING = 9,
    CROP = 10,
    IMPROVEMENT = 11,
    POWER_GEN = 12,
    AIM = 13,
    HEATING = 14,
    EStructureType_MAX = 15,
};

enum class ETechCardSlotType {
    TECH = 0,
    TECH_LOCKED = 1,
    TECH_PURCHASED = 2,
    HIDDEN = 3,
    TIER_LINE = 4,
    TIER_TECH = 5,
    ETechCardSlotType_MAX = 6,
};

enum class ETerraformerState {
    WORKING = 0,
    IDLE_NO_VALID_DROP = 1,
    IDLE_MISSING_INPUTS = 2,
    IDLE_NO_WORKERS = 3,
    IDLE_PAUSED = 4,
    ETerraformerState_MAX = 5,
};

enum class ETerrainToolMode {
    NONE = 0,
    BRUSH_TERRAFORMING = 1,
    BRUSH_PROPS = 2,
    BRUSH_ORES = 3,
    ETerrainToolMode_MAX = 4,
};

enum class ETimelineEventType {
    NOTIFICATION = 0,
    PLAYER_CHOICE = 1,
    BAD_UNDEFINED = 2,
    MISSION_START = 3,
    MISSION_EXPIRATION = 4,
    UNUSED1 = 5,
    BOAT_AT_DOCK = 6,
    TUTORIAL_HINT = 7,
    UNUSED2 = 8,
    DEATH_REPORT = 9,
    QUEST_COMPLETE = 10,
    ETimelineEventType_MAX = 11,
};

enum class EToolbarItemType {
    ACTION_BUTTON = 0,
    FOLDER = 1,
    DIVIDER = 2,
    GRIDACTOR_GROUP = 3,
    DECORATIVE_GROUP = 4,
    GRIDACTOR_SINGLE = 5,
    EToolbarItemType_MAX = 6,
};

enum class ETowerGridFlag {
    NONE = 0,
    DEMAND_SHORE = 1,
    SELF_SUPPORTING = 2,
    BURNED = 4,
    POLLUTION_OUTPUT_POS = 8,
    DEMAND_GROUNDLEVEL = 16,
    TERRAIN_OVERLAY = 32,
    PRIORITY_HARVEST = 64,
    DEMAND_OVER_WATER = 128,
    ETowerGridFlag_MAX = 129,
};

enum class ETowerGridFlag_Alt {
    NONE = 0,
    IGNORED_BY_SUPPORTS = 1,
    ALLOW_WATER_PLACEMENT = 2,
    ETowerGridFlag_MAX = 3,
};

enum class ETrainState {
    CRUISING = 0,
    STOPPED_AT_STATION = 1,
    ETrainState_MAX = 2,
};

enum class EUnrestDeltaType {
    OTHER_ACTION = 0,
    REWARD = 1,
    CLAWPUNISHMENT = 2,
    DECAY = 3,
    SMUGGLING = 4,
    EUnrestDeltaType_MAX = 5,
};

enum class EWorkShipState {
    IDLE = 0,
    DEPARTING = 1,
    ARRIVING = 2,
    IN_NAUTICAL = 3,
    EWorkShipState_MAX = 4,
};

enum class EWorkerAssignmentValidity {
    VALID = 0,
    FAILED_OTHER = 1,
    FAILED_MISSKILLED = 2,
    FAILED_LOCKED = 3,
    FAILED_ALREADYASSIGNED = 4,
    FAILED_SLOTALREADYFULL = 5,
    EWorkerAssignmentValidity_MAX = 6,
};

enum class EWorkerSlotType {
    SIMPLE = 0,
    INDUSTRY = 1,
    EWorkerSlotType_MAX = 2,
};

// Size: 0x18
struct FEateryChairState_UI {
    /* 0x0000 */ float eatProgressPercent;
    /* 0x0004 */ bool agentPresent;
    /* 0x0008 */ FString agentName;
};

// Size: 0x50
struct FEateryFoodInfo_UI {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t capacity;
    /* 0x0008 */ FAgentModifier relatedModifier;
};

// Size: 0x170
struct FEateryView_UiData {
    /* 0x0000 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory;
    /* 0x0050 */ FStockpile Stockpile;
    /* 0x00a8 */ TMap<FName, int32_t> requestValuePerCategory;
    /* 0x00f8 */ int32_t capacity;
    /* 0x00fc */ int32_t nMaxAgentsEating;
    /* 0x0100 */ TArray<FEateryChairState_UI> chairs;
    /* 0x0110 */ int32_t allowedMealsPerAgent;
    /* 0x0118 */ FWorkerAssignmentData workerData;
    /* 0x0128 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x0168 */ bool disabledByPlayer;
    /* 0x016c */ int32_t ExpectationStars;
};

// Size: 0x8
struct FElevatorLandingData {
    /* 0x0000 */ UElevatorSegment* ElevatorSegment;
};

// Size: 0x2d8
class AElevatorPlatform : public AActor {
    /* 0x02a8 */ float rotScalar;
    /* 0x02b0 */ TArray<UStaticMeshComponent*> m_gears;
    /* 0x02c0 */ UAudioComponent* m_audio;
};

// Size: 0x160
class UElevatorSegment : public UActorComponent {
    /* 0x00e0 */ bool m_isLanding;
    /* 0x0148 */ Aelevator* m_associatedShaft;
    /* 0x0150 */ TArray<FWaitingElevatorAgent> m_waitingAgents;
};

// Size: 0x360
class AElevatorSystem : public AActor {
    /* 0x02a8 */ UClass* m_shaftPrefab;
    /* 0x02b0 */ TMap<UElevatorSegment*, Aelevator*> m_segmentToShaftLookup;
    /* 0x0300 */ TArray<Aelevator*> m_elevatorShafts;
    /* 0x0310 */ TMap<FIntVector, UElevatorSegment*> m_segmentPositions;
};

// Size: 0x2b0
class AEmbarkBoat : public AActor {

    void AnimateBoatInOut(bool In);
    void SendActionToShip(FName action);
    void SetArrivingAgents(FEmbarkBoatWhiskerGroup colonists);
    void SetNBoxes(int32_t nBoxes);
    void SetNColonists(int32_t colonists);
};

// Size: 0x10
struct FEmbarkBoatWhiskerGroup {
    /* 0x0000 */ TArray<FAgentCharacteristics> colonists;
};

// Size: 0x38
struct FEmbarkHudState {
    /* 0x0000 */ EEmbarkPhase CurrentPhase;
    /* 0x0008 */ FString currentMessageString;
    /* 0x0018 */ FName currentLetterId;
    /* 0x0020 */ FString tutorialHintString;
    /* 0x0030 */ bool paused;
    /* 0x0034 */ int32_t simSpeed;
};

// Size: 0x2d0
class AEmbarkIntroCutscene : public ACutscene {
};

// Size: 0xc
struct FEnabledResource {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ bool Enabled;
};

// Size: 0xa0
struct FEntityStatsForDay {
    /* 0x0000 */ FStats_resourcesInfo resourcesInfo;
    /* 0x0050 */ TMap<FName, int32_t> miscStats;
};

// Size: 0x38
struct FEntryContext {
};

// Size: 0x10
struct FEveningSummary {
    /* 0x0000 */ int32_t desiredSleeps;
    /* 0x0004 */ int32_t completedSleeps;
    /* 0x0008 */ int32_t nHomeless;
    /* 0x000c */ int32_t secondsUntilPhaseEnd;
};

// Size: 0x10
struct FEventBatch {
    /* 0x0000 */ TArray<FScenarioQuestStart> questStarts;
};

// Size: 0x40
struct FEventChoiceV2 {
    /* 0x0000 */ FString Text;
    /* 0x0010 */ FString ButtonText;
    /* 0x0020 */ USoundBase* clickAudio;
    /* 0x0028 */ TArray<FActionResult> ActionResults;
    /* 0x0038 */ bool canAfford;
};

// Size: 0x448
class UEventDetailsView : public UArcoView {

    void SetEvent(FTimelineEventDef eventDef, int32_t eventId);
};

// Size: 0xb0
class UEventQueue : public UObject {
};

// Size: 0x80
struct FEventQueue_EventCard_Hud {
    /* 0x0000 */ FTimelineEventDef eventDef;
    /* 0x0078 */ bool triggerAnimation;
    /* 0x007c */ int32_t eventId;
};

// Size: 0x10
struct FEventQueue_Hud {
    /* 0x0000 */ TArray<FEventQueue_EventCard_Hud> pendingEvents;
};

// Size: 0x38
class UEventTimeline : public UObject {
    /* 0x0028 */ TArray<FTimelineDay> futureTimeline;
};

// Size: 0x10
struct FExchangeRate {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ int32_t Value;
    /* 0x000c */ bool highPriority;
    /* 0x000d */ bool lowPriority;
};

// Size: 0x80
struct FExpectationConfig {
    /* 0x0000 */ int32_t MinimumExpectationInHalfStars;
    /* 0x0004 */ int32_t MaximumExpectationInHalfStars;
    /* 0x0008 */ int32_t BaseExpectationInHalfStars;
    /* 0x000c */ int32_t ApprenticeExpectationInHalfStars;
    /* 0x0010 */ int32_t CraftsmasterExpectationInHalfStars;
    /* 0x0014 */ int32_t EducatedExpectationInHalfStars;
    /* 0x0018 */ int32_t SchooledExpectationInHalfStars;
    /* 0x0020 */ TMap<FName, int32_t> TraitExpectationsInHalfStars;
    /* 0x0070 */ TArray<FExpectationResponse> ResponseDifficulties;
};

// Size: 0xa8
class UExpectationConfigMule : public UObject {
    /* 0x0028 */ FExpectationConfig config;
};

// Size: 0xc
struct FExpectationReason {
    /* 0x0000 */ FName Reason;
    /* 0x0008 */ int32_t HalfStars;
};

// Size: 0x18
struct FExpectationResponse {
    /* 0x0000 */ float ChanceForSkippingNegativeThought;
    /* 0x0008 */ TArray<float> ExpectationExcessPerDelta;
};

// Size: 0x150
class UExpectationSystem : public UActorComponent {
    /* 0x00b8 */ int32_t DifficultyIndex;
    /* 0x00bc */ float PenaltyMultiplier;
    /* 0x00c0 */ float ExcessMultiplier;
    /* 0x00c8 */ FExpectationConfig config;
    /* 0x0148 */ URandomXorshift* Randomizer;
};

// Size: 0xc
struct FExtraWoodPolicyState {
    /* 0x0000 */ float triggerProgress;
    /* 0x0004 */ float progress_naturalTree;
    /* 0x0008 */ float progress_farmedTree;
};

// Size: 0x388
class UFactionDock : public UActorComponent {
    /* 0x00c0 */ TMap<EShipType, UClass*> m_boatVisualsTable;
    /* 0x0160 */ float m_boatArrivalAnimTime;
    /* 0x0164 */ float interpExponent;
    /* 0x0168 */ int32_t m_currentStanding;
    /* 0x016c */ int32_t m_maxStanding;
    /* 0x0170 */ bool m_dangerOfLosing;
    /* 0x0180 */ UClass* m_pirateBlockadeClass;
    /* 0x0188 */ UClass* m_taxBlockadeClass;
    /* 0x0241 */ EDockState m_dockState;
    /* 0x02e8 */ UClass* m_widgetDef;
    /* 0x02f0 */ UWidgetComponent* m_hintWidget;
    /* 0x0300 */ FMulticastInlineDelegate TickDockVisuals;
    /* 0x0310 */ FMulticastInlineDelegate DockedShipChanged;
    /* 0x0320 */ float m_minShipSpawnSpacingTime;

    static FString GetKeyForStanding(int32_t standing);
    void SpatialHudAction(FHudAction HudAction);
};

// Size: 0x220
struct FFactionDock_UiState {
    /* 0x0000 */ bool shipPresent;
    /* 0x0008 */ FDockableShipData dockedShipState;
    /* 0x01c0 */ FShipsForDay inboundShips;
    /* 0x01d0 */ TArray<FShipsForDay> futureShips;
    /* 0x01e0 */ bool isEmbarkMode;
    /* 0x01e1 */ bool shipIsComingIn;
    /* 0x01e4 */ float timeUntilShipArrives;
    /* 0x01e8 */ TArray<FTax> debts;
    /* 0x01f8 */ int32_t totalDebt;
    /* 0x01fc */ int32_t daysUntilDebtDue;
    /* 0x0200 */ int32_t currentStanding;
    /* 0x0204 */ int32_t maxStanding;
    /* 0x0208 */ bool dangerOfLosing;
    /* 0x0210 */ FString standingString;
};

// Size: 0x14
struct FFactionExportSummary_Hud {
    /* 0x0000 */ int32_t currentColonyLevel;
    /* 0x0004 */ int32_t xpToNextLevel;
    /* 0x0008 */ float progressPercent;
    /* 0x000c */ int32_t rawDystrumStored;
    /* 0x0010 */ int32_t refinedDystrumStored;
};

// Size: 0x290
class UFarmBuilding : public UActorComponent {
    /* 0x00f8 */ FWorkerAssignment m_workers;
    /* 0x0118 */ UWorkerViz* m_workerViz;
    /* 0x0120 */ FStockpile m_storageStockpile;
    /* 0x0178 */ FStockpile m_fertilizerStockpile;
    /* 0x0240 */ UServiceRange* m_serviceRange;
};

// Size: 0x20
struct FFarmFertility {
    /* 0x0000 */ FName crop;
    /* 0x0008 */ float NutrientSaturation;
    /* 0x000c */ float NutrientMinimum;
    /* 0x0010 */ float LightTarget;
    /* 0x0014 */ float LightPenalty;
    /* 0x0018 */ float RockPenalty;
    /* 0x001c */ float PollutionPenalty;
};

// Size: 0x14
struct FFarmFieldCrop {
    /* 0x0004 */ FName CropName;
    /* 0x000c */ float GrowingYield;
    /* 0x0010 */ float GrownYield;
};

// Size: 0x148
struct FFarmFieldUIState {
    /* 0x0000 */ int32_t FieldSize;
    /* 0x0008 */ TArray<FFarmFieldCrop> FieldCrops;
    /* 0x0018 */ FName activeSeeds;
    /* 0x0020 */ TArray<FCropOption> allSeeds;
    /* 0x0030 */ TMap<FName, float> AllAverageFertilities;
    /* 0x0080 */ bool bEarlyHarvestActive;
    /* 0x0081 */ bool bHasAnythingGrowing;
    /* 0x0082 */ ETerrainFarmFieldPhase CurrentPhase;
    /* 0x0083 */ bool bFertilizerActive;
    /* 0x0084 */ bool bRemovingRocksActive;
    /* 0x0088 */ FStatEntity statsToShow;
    /* 0x0138 */ int32_t avgFertility;
    /* 0x013c */ int32_t avgNutrients;
    /* 0x0140 */ int32_t avgMaxNutrients;
    /* 0x0144 */ int32_t avgRockiness;
};

// Size: 0x560
class AFarmTool : public AActor {
    /* 0x02b0 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x02b8 */ UClass* m_fertilityWidgetClass;
    /* 0x02c8 */ TArray<FFarmFertility> m_fertility;
    /* 0x02d8 */ bool bFertilityInitialized;
    /* 0x02e0 */ UFarmToolWidgetComponent* m_farmToolWidget;
    /* 0x02e8 */ FTerrainCellTypeLibrary TypeLibrary;

    FFertilityInfo GetFertilityInfo() const;
    FFarmToolInfo GetInfo() const;
    bool HandleHudAction(FHudAction HudAction);
    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0x50
struct FFarmToolInfo {
    /* 0x0000 */ int32_t FieldSize;
    /* 0x0004 */ bool bClickable;
    /* 0x0008 */ TArray<FFarmFieldCrop> FieldCrops;
    /* 0x0018 */ bool bIsInLandMarkingMode;
    /* 0x001c */ FName hintMessage;
    /* 0x0024 */ FName selectedCrop;
    /* 0x002c */ int32_t cropFertility;
    /* 0x0030 */ int32_t Nutrients;
    /* 0x0034 */ int32_t NutrientLimit;
    /* 0x0038 */ int32_t rockiness;
    /* 0x003c */ int32_t pollution;
    /* 0x0040 */ int32_t lightLevel;
    /* 0x0044 */ int32_t temperature;
    /* 0x0048 */ EFarmToolTemperatureResponse temperatureResponse;
};

// Size: 0x6d0
class UFarmToolWidgetComponent : public UWidgetComponent {

    void SetMessage(FName msgKey);
};

// Size: 0x1d0
struct FFarmUIState {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FStockpile Stockpile;
    /* 0x0068 */ FStockpile fertilizerStockpile;
    /* 0x00c0 */ float fertilizerPercent;
    /* 0x00c4 */ bool allowForceDelivery;
    /* 0x00c5 */ bool pendingForceDelivery;
    /* 0x00c8 */ FStatEntity statsToShow;
    /* 0x0178 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x01b8 */ bool disabledByPlayer;
    /* 0x01b9 */ bool overtimeHours;
    /* 0x01bc */ int32_t overtimeCost;
    /* 0x01c0 */ bool canAffordOvertime;
    /* 0x01c4 */ float remainingOvertime;
    /* 0x01c8 */ bool onlyPriorityFields;
    /* 0x01c9 */ bool bAssignmentMode;
};

// Size: 0x530
class UFarmViz : public USceneComponent {
    /* 0x0240 */ FGridInstaMesh m_farmToolMeshes;
    /* 0x0360 */ TArray<FGridInstaMesh> m_farmFields;
    /* 0x0370 */ UMaterialInstance* m_matBase;
    /* 0x0378 */ UMaterialInstance* m_matHighlight;
    /* 0x0380 */ UMaterialInstance* m_matAddTo;
    /* 0x0388 */ UMaterialInstance* m_matAdding;
    /* 0x0390 */ UMaterialInstance* m_matRemoveFrom;
    /* 0x0398 */ UMaterialInstance* m_matRemoving;
    /* 0x03a0 */ UMaterialInstance* m_matInvalid;
    /* 0x03a8 */ UMaterialInstance* m_matSelected;
    /* 0x03b0 */ UStaticMesh* Mesh;
    /* 0x03c8 */ TSet<int32_t> HighlightedFields;
    /* 0x0418 */ UFarmBuilding* AssignmentFarmBuilding;
    /* 0x0420 */ FColor FreeArcColor;
    /* 0x0424 */ FColor RemovalArcColor;
    /* 0x0428 */ FColor AssignedArcColor;
};

// Size: 0x18
struct FFarmingAgent {
};

// Size: 0xf0
class UFarmland : public UActorComponent {
    /* 0x00c0 */ FFarmingAgent m_farmingAgent;
    /* 0x00d8 */ float m_earlyHarvestWeightPenalty;
    /* 0x00e9 */ bool reservedByAgent;

    void HandleArcoPhaseBegan(EDayPhase newPhase);
};

// Size: 0x20
struct FFertilityInfo {
    /* 0x0000 */ TArray<FCropOption> CropTypes;
    /* 0x0010 */ int32_t CurrentCropIndex;
    /* 0x0014 */ int32_t LastActualCropIndex;
    /* 0x0018 */ int32_t SoilPropertyThreshold;
};

// Size: 0x618
class AFloorTool : public AActor {
    /* 0x03a8 */ bool isDragging;
    /* 0x03ac */ FIntVector dragStartPos;
    /* 0x03b8 */ FIntVector dragEndPos;
    /* 0x03c4 */ FName floorSegKey;
    /* 0x03d0 */ UClass* floorSeg;
    /* 0x03e8 */ FDetailedResourceCost currentCost;
    /* 0x0580 */ UWidgetComponent* m_placementUiWidget;
    /* 0x0588 */ UStaticMesh* m_arrowMesh_allDirs;
    /* 0x0590 */ UStaticMesh* m_arrowMesh_oneDir;
    /* 0x0598 */ UStaticMeshComponent* m_arrowViz;
};

// Size: 0xe0
class UFluidValve : public UActorComponent {
    /* 0x00b8 */ UPipeSegment* m_inSeg;
    /* 0x00c0 */ UPipeSegment* m_outSeg;
    /* 0x00c8 */ bool m_valveClosed;
    /* 0x00cc */ int32_t m_valveOverflowPercentThreshold;
    /* 0x00d0 */ FMulticastInlineDelegate closedStateChange;
};

// Size: 0xc
struct FFoodDationing_UiData {
    /* 0x0000 */ int32_t m_rationCount;
    /* 0x0004 */ bool rawOnly;
    /* 0x0005 */ bool preparedOnly;
    /* 0x0008 */ int32_t estimatedConsumption;
};

// Size: 0x388
class UFoodDistributor : public UActorComponent {
    /* 0x00d0 */ FWorkerAssignment m_workers;
    /* 0x00f0 */ TArray<FVendingAgent> m_agentsEating;
    /* 0x0100 */ TArray<FMealDef> m_sortedMealDefs;
    /* 0x0110 */ int32_t m_maxAgentsEating;
    /* 0x0114 */ float m_eatLength;
    /* 0x0118 */ int32_t m_baseQuality;
    /* 0x011c */ int32_t m_foodCount;
    /* 0x0120 */ int32_t m_teaCount;
    /* 0x0128 */ FStockpile m_stockpile;
    /* 0x0180 */ int32_t m_capacity;
    /* 0x0188 */ TMap<FName, int32_t> m_requestsPerCategory;
    /* 0x01d8 */ FName thoughtForVisitors;
    /* 0x01e0 */ TSet<FName> m_supportedResourceCategories;
    /* 0x0230 */ TSet<FName> m_supportedResourceSubCategories;
    /* 0x0298 */ UStockpileRender* m_stockpileVisual;
    /* 0x02a0 */ TSet<int32_t> m_inboundAgents_food;
    /* 0x02f0 */ TSet<int32_t> m_inboundAgents_drink;
    /* 0x0348 */ UWorkerViz* m_workerViz;
};

// Size: 0x10
struct FFootprintCell {
    /* 0x0000 */ AGridActor* actorRef;
    /* 0x0008 */ uint8_t Flags;
    /* 0x0009 */ uint8_t altFlags;
    /* 0x000a */ EGridOccupancy occupancy;
    /* 0x000b */ ETerrainBlockage terrainBlockage;
};

// Size: 0x330
class AFootprintTool : public AActor {
    /* 0x02a8 */ UClass* footprintCellClass;
    /* 0x02b0 */ UClass* gridActorClass;
    /* 0x02b8 */ UMaterialInstance* gridActorMat;
    /* 0x02c0 */ AGridActor* gridActorInstance;
    /* 0x02d4 */ int32_t editableExtent;
    /* 0x02d8 */ int32_t maxEditableZ;
    /* 0x02e0 */ TMap<FIntVector, AFootprintTool_Cell*> footprintCellActors;
};

// Size: 0x340
class AFootprintTool_Cell : public AActor {
    /* 0x02c8 */ UMaterialInstance* material_passing;
    /* 0x02d0 */ UMaterialInstance* material_blocking;
    /* 0x02d8 */ UMaterialInstance* material_occupied;
    /* 0x02e0 */ UMaterialInstance* material_stairBottom;
    /* 0x02e8 */ UMaterialInstance* material_stairTop;
    /* 0x02f0 */ UMaterialInstance* material_none;
    /* 0x02f8 */ UMaterialInstance* material_entrance;
    /* 0x0300 */ UMaterialInstance* material_floorOccupancy;
    /* 0x0308 */ UMaterialInstance* material_demandPartialOccupation;
    /* 0x0310 */ USceneComponent* Root;
    /* 0x0318 */ UStaticMeshComponent* floor;
    /* 0x0320 */ UStaticMeshComponent* north;
    /* 0x0328 */ UStaticMeshComponent* east;
    /* 0x0330 */ UStaticMeshComponent* south;
    /* 0x0338 */ UStaticMeshComponent* west;
};

// Size: 0x1e8
class UFueledHeater : public UActorComponent {
    /* 0x00dc */ EFuelSource m_fuelSource;
    /* 0x00e0 */ int32_t m_maxFuelCapacity;
    /* 0x00e4 */ float m_fuelBurnTime;
    /* 0x00e8 */ int32_t m_basePollutionPerSecond;
    /* 0x00f0 */ FString m_radius_flavortext;
    /* 0x0100 */ FIntVector m_entranceInternalPos;
    /* 0x0138 */ FStockpile m_supplyStockpile;
    /* 0x0190 */ float m_burnTimeRemaining;
    /* 0x0194 */ EHeaterState m_state;
    /* 0x0198 */ UHeatSourceComponent* m_heatComponent;
    /* 0x01a8 */ FMulticastInlineDelegate runningChangedEvent;
    /* 0x01b8 */ FMulticastInlineDelegate fuelLevelChanged;
    /* 0x01d0 */ bool m_autoPauseEnabled;
    /* 0x01d1 */ bool m_isPausedDueToAmbientTemp;
    /* 0x01d4 */ int32_t m_heatOverdrive;

    bool CanAddExternalFuel() const;
    FName GetFuelResource() const;
    int32_t GetFuelStored() const;
    int32_t GetPollutionOutput(bool ignorePaused);
    void PolicyStateChanged(FName policy, bool Active);
};

// Size: 0x48
struct FFueledHeaterHudInfo {
    /* 0x0000 */ EHeaterState heaterState;
    /* 0x0004 */ int32_t fuelRate;
    /* 0x0008 */ float heatTotal;
    /* 0x0010 */ FString rangeText;
    /* 0x0020 */ int32_t heatOverrideLevel;
    /* 0x0024 */ int32_t fuelStored;
    /* 0x0028 */ int32_t maxFuel;
    /* 0x002c */ bool autoSleep;
    /* 0x002d */ bool autopaused;
    /* 0x002e */ bool Enabled;
    /* 0x0030 */ float percentFuel;
    /* 0x0034 */ FName fuelType;
    /* 0x003c */ int32_t pollution;
    /* 0x0040 */ EFuelSource fuelTypeEnum;
};

// Size: 0x18
struct FGameOverInfo {
    /* 0x0000 */ FString colonyName;
    /* 0x0010 */ int32_t nDaysPassed;
    /* 0x0014 */ int32_t totalPaid;
};

// Size: 0x68
class UGiftPools : public UObject {
    /* 0x0028 */ FActiveClawsSelectionScreen m_activeChoicePrompt;

    static TArray<FGiftPreviewRow> CreateGiftPoolPreview(UObject* Context, FName giftPool);
};

// Size: 0x14
struct FGiftPreviewRow {
    /* 0x0000 */ bool isElipses;
    /* 0x0001 */ EActionResultType resultType;
    /* 0x0004 */ FName relevantKey;
    /* 0x000c */ bool showChance;
    /* 0x0010 */ float chance;
};

// Size: 0x278
class UGranaryResourceBuilding : public UResourceBuilding {
    /* 0x0260 */ TArray<FVendingAgent> m_agentsControlled;
    /* 0x0270 */ int32_t m_maxAgentsEating;
    /* 0x0274 */ float m_eatLength;
};

// Size: 0x4
struct FGranaryViewState {
    /* 0x0000 */ int32_t m_rationingValue;
};

// Size: 0x408
class AGridActor : public AActor {
    /* 0x02a8 */ FPrefabInfo PrefabInfo;
    /* 0x0380 */ FGridFootprint liveFootprint;
    /* 0x03e8 */ UClass* contextualArcoView;
    /* 0x03f0 */ UClass* contextualHoverWidget;
    /* 0x03f8 */ bool isPlayerOwned;
    /* 0x03fc */ int32_t ID;
    /* 0x0400 */ bool allowOverwrite;

    bool GetGridActorDefinition(FGridActorDefinition_MasterSyncFormat& Out) const;
};

// Size: 0x8
struct FGridActorDef_CropInfo {
    /* 0x0000 */ int32_t minZ;
    /* 0x0004 */ int32_t desiredSun;
};

// Size: 0xc0
struct FGridActorDef_IndustryInfo {
    /* 0x0000 */ FIndustryRecipe recipe;
    /* 0x00b8 */ float avgUptimeBeforeBreakdown;
    /* 0x00bc */ int32_t basePowerDraw;
};

// Size: 0x130
struct FGridActorDefinition_MasterSyncFormat : public FTableRowBase {
    /* 0x0008 */ UClass* GridActor;
    /* 0x0010 */ FString stringKey;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ FName cost1;
    /* 0x0038 */ int32_t ct1;
    /* 0x003c */ FName cost2;
    /* 0x0044 */ int32_t ct2;
    /* 0x0048 */ FName cost3;
    /* 0x0050 */ int32_t ct3;
    /* 0x0054 */ FName cost4;
    /* 0x005c */ int32_t ct4;
    /* 0x0060 */ FName unlockPrerequisite;
    /* 0x0068 */ FName toolbarGroup;
    /* 0x0070 */ int32_t toolbarGroupSort;
    /* 0x0074 */ bool useCustomIcon;
    /* 0x0078 */ UTexture2D* Icon;
    /* 0x0080 */ USoundBase* detailCue;
    /* 0x0088 */ TArray<FName> SupportedImprovements;
    /* 0x0098 */ FName structureType;
    /* 0x00a0 */ int32_t maxAgents_contextual;
    /* 0x00a4 */ int32_t asHouseTier;
    /* 0x00a8 */ FName asIndustryDef;
    /* 0x00b0 */ TArray<FName> supportedIndustryRecipes;
    /* 0x00c0 */ int32_t minMaintenanceInterval;
    /* 0x00c4 */ FColor workerColor;
    /* 0x00c8 */ bool limitOne;
    /* 0x00d0 */ USoundBase* customBuildCue;
    /* 0x00d8 */ bool requiresConstruction;
    /* 0x00dc */ FName decorType;
    /* 0x00e4 */ FName guildSpecialty;
    /* 0x00ec */ bool hardLabor;
    /* 0x00ed */ bool industrialLabor;
    /* 0x00f0 */ TArray<FName> TooltipTags;
    /* 0x0100 */ float constructionTime;
    /* 0x0104 */ FName catalyst;
    /* 0x010c */ bool norefund;
    /* 0x010d */ bool randomlyRotate;
    /* 0x0110 */ FName refundRule;
    /* 0x0118 */ int32_t Quality;
    /* 0x0120 */ TArray<FName> Variants;
};

// Size: 0x30
struct FGridActorDoorwayRender {
    /* 0x0000 */ TArray<FDoorway> entrances;
    /* 0x0010 */ TArray<FDoorway> waterAdapters;
    /* 0x0020 */ TArray<FDoorway> steamAdapters;
};

// Size: 0x68
struct FGridFootprint {
    /* 0x0000 */ TMap<FIntVector, FFootprintCell> Cells;
    /* 0x0050 */ FDir Facing;
    /* 0x0054 */ FIntVector rootPosition;
    /* 0x0060 */ bool IsRelative;
    /* 0x0061 */ bool isAbstract;
};

// Size: 0x68
struct FGridPathability {
    /* 0x0000 */ TMap<FIntVector, FPathableNode> pathability;
    /* 0x0050 */ FDir Facing;
    /* 0x0054 */ FIntVector rootPosition;
    /* 0x0060 */ bool IsRelative;
};

// Size: 0x1a0
struct FHarvestCampUIState {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FStockpile Stockpile;
    /* 0x0068 */ bool allowForceDelivery;
    /* 0x0069 */ bool pendingForceDelivery;
    /* 0x0070 */ FStatEntity statsToShow;
    /* 0x0120 */ int32_t costToInstantDeliver;
    /* 0x0124 */ int32_t currentInfluence;
    /* 0x0128 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x0168 */ FName toolHotkey;
    /* 0x0170 */ TArray<FEnabledResource> enabledResources;
    /* 0x0180 */ bool m_overtimeEnabled;
    /* 0x0184 */ int32_t overtimeCost;
    /* 0x0188 */ bool canAffordOvertime;
    /* 0x018c */ float remainingOvertime;
    /* 0x0190 */ bool disabledByPlayer;
    /* 0x0194 */ FServiceRangeCfg serviceRangeInfo;
};

// Size: 0x270
class UHarvestingCamp : public UActorComponent {
    /* 0x00e0 */ FWorkerAssignment m_workers;
    /* 0x0100 */ UStockpileRender* m_stockpileVisual;
    /* 0x0108 */ float m_pathfindingMaxSearchCost;
    /* 0x0110 */ UWorkerViz* m_workerViz;
    /* 0x0118 */ TArray<FName> m_supportedResources;
    /* 0x0128 */ TSet<FName> m_enabledResources;
    /* 0x0178 */ FName m_optional_supportedSubcat;
    /* 0x0180 */ EPathableNodeFlag m_flagToSearchFor;
    /* 0x0188 */ FStockpile m_storageStockpile;
    /* 0x01e0 */ TArray<FIdlingAgent> m_agentsInCamp;
    /* 0x0220 */ UServiceRange* m_serviceRange;
};

// Size: 0x48
struct FHeatDebugInfo {
    /* 0x0000 */ int32_t day;
    /* 0x0004 */ uint8_t heat;
    /* 0x0008 */ int32_t temp;
    /* 0x000c */ FColor tempColor;
    /* 0x0010 */ FString seasonStr;
    /* 0x0020 */ FString tempDesc;
    /* 0x0030 */ FString whiskerEffect;
    /* 0x0040 */ int32_t difficulty;
};

// Size: 0x2f0
class UHeightVisualizer : public USceneComponent {
    /* 0x0240 */ UMaterialInstance* m_heightMat;
    /* 0x0248 */ UStaticMesh* m_heightFooter;
    /* 0x0250 */ UStaticMesh* m_heightMid;
    /* 0x0258 */ UStaticMesh* m_heightTop;
    /* 0x0260 */ TArray<UStaticMeshComponent*> m_heightMeshes;
};

// Size: 0x228
class UHouse : public UActorComponent {
    /* 0x00d8 */ UWorkerViz* m_workerViz;
    /* 0x00e0 */ FStockpile m_supplyStockpile;
    /* 0x0138 */ TArray<FHouseSlot> m_bedSlots;
    /* 0x0148 */ int32_t m_maxResidents;
    /* 0x014c */ int32_t m_housingTier;
    /* 0x0150 */ FName m_nextUpgradeHouseKey;
    /* 0x0158 */ float m_timeTillNextTick;
    /* 0x0160 */ TMap<FName, int32_t> m_activeLuxuries_hundreths;
    /* 0x01d0 */ FMulticastInlineDelegate NotifyBlueprint_residentCountChanged;

    bool IsResidentPermenant(APrototype_Agent* Agent) const;
};

// Size: 0x28
struct FHouseHoverState {
    /* 0x0000 */ int32_t nResidents;
    /* 0x0004 */ int32_t nCapacity;
    /* 0x0008 */ bool Hovered;
    /* 0x0009 */ bool Selected;
    /* 0x000a */ bool currentHome;
    /* 0x0010 */ TArray<FResidentData_UiData> residenceSlots;
    /* 0x0020 */ int32_t Stars;
};

// Size: 0x18
struct FHouseSlot {
    /* 0x0000 */ bool isPermenantReservation;
    /* 0x0008 */ APrototype_Agent* reservingAgent;
    /* 0x0010 */ bool isAgentPresent;
};

// Size: 0x438
class UHousingAssignmentWidget : public UArcoWidgetBase {

    FHouseHoverState CalcState();
};

// Size: 0x150
struct FHousingDetails_UiData {
    /* 0x0000 */ int32_t Quality;
    /* 0x0004 */ FName sleepModifier;
    /* 0x0010 */ TArray<FResidentData_UiData> bedslots;
    /* 0x0020 */ FStockpile supplyStockpile;
    /* 0x0078 */ int32_t percentBedding_int;
    /* 0x007c */ int32_t percentFurniture_int;
    /* 0x0080 */ int32_t furnitureBonus;
    /* 0x0084 */ bool hasFurniture;
    /* 0x0088 */ int32_t beddingBonus;
    /* 0x008c */ bool hasBedding;
    /* 0x008d */ bool upgradeExists;
    /* 0x008e */ bool upgradeUnlocked;
    /* 0x0090 */ FResourceCollection upgradeCost;
    /* 0x00e0 */ FResourceCollection bankResources;
    /* 0x0130 */ FString upgradeString;
    /* 0x0140 */ bool canAffordUpgrade;
    /* 0x0141 */ bool upgrading;
    /* 0x0144 */ float percentUpgraded;
    /* 0x0148 */ float upgTimeRemaining;
};

// Size: 0x2a8
class AHoverDetailsWidgetRenderer : public AActor {
};

// Size: 0x58
struct FHudAction {
    /* 0x0000 */ FString action;
    /* 0x0010 */ FString paramString;
    /* 0x0020 */ FName paramName;
    /* 0x0028 */ int32_t paramInt;
    /* 0x002c */ float paramFloat;
    /* 0x0030 */ FIntVector paramGrid;
    /* 0x003c */ bool paramBool;
    /* 0x0040 */ FVector paramVector;
};

// Size: 0x30
struct FHudConfig {
    /* 0x0000 */ int32_t arcSegmentCount;
    /* 0x0004 */ float arcHeightMax;
    /* 0x0008 */ float arcCurvePower;
    /* 0x000c */ float overdrawCullThreshhold;
    /* 0x0010 */ UTexture2D* sampleIcon;
    /* 0x0018 */ UTexture2D* iconBackground;
    /* 0x0020 */ FLinearColor standardIconColor;
};

// Size: 0x14
struct FHudEvents {
    /* 0x0000 */ int32_t happyDelta;
    /* 0x0004 */ int32_t prodDelta;
    /* 0x0008 */ int32_t speedDelta;
    /* 0x000c */ int32_t buffDelta;
    /* 0x0010 */ int32_t debuffDelta;
};

// Size: 0x4f8
struct FHudState {
    /* 0x0000 */ int32_t influence;
    /* 0x0004 */ int32_t influenceCap;
    /* 0x0008 */ float recentInfluenceChanges;
    /* 0x000c */ int32_t unrest;
    /* 0x0010 */ int32_t unrestCap;
    /* 0x0014 */ float recentUnrestChanges;
    /* 0x0018 */ int32_t currentResearch;
    /* 0x001c */ int32_t maxResearch;
    /* 0x0020 */ int32_t currentPopulation;
    /* 0x0024 */ int32_t maxPopulation;
    /* 0x0028 */ int32_t nUnemployed;
    /* 0x002c */ int32_t zLevel;
    /* 0x0030 */ FReplayHudState replayState;
    /* 0x0068 */ FTimeHudState TimeHudState;
    /* 0x00a0 */ FResourceHudState playerResourceSummary;
    /* 0x01b0 */ FNotificationHudState notifications;
    /* 0x01c8 */ FResourceCollection maxResources;
    /* 0x0218 */ FResourceCollection minResources;
    /* 0x0268 */ FQuestHudState questState;
    /* 0x0278 */ FEventQueue_Hud eventQueueState;
    /* 0x0288 */ FSeasonSummary SeasonSummary;
    /* 0x02d8 */ FMorningSummary MorningSummary;
    /* 0x0300 */ FMidDaySummary MidDaySummary;
    /* 0x0304 */ FEveningSummary EveningSummary;
    /* 0x0318 */ FProblemSummaries_UI problemSummaries;
    /* 0x0330 */ bool showDebugUi;
    /* 0x0331 */ bool showDeveloperUi;
    /* 0x0332 */ bool ShowHUD;
    /* 0x0333 */ bool showToolbar;
    /* 0x0334 */ bool showRightElements;
    /* 0x0335 */ bool showCenterMessageArea;
    /* 0x0336 */ bool showWheelHint;
    /* 0x0338 */ int32_t music;
    /* 0x033c */ FHudEvents HudEvents;
    /* 0x0350 */ bool sliceView;
    /* 0x0351 */ bool heatView;
    /* 0x0352 */ bool pollutionView;
    /* 0x0353 */ bool bulldozeActive;
    /* 0x0358 */ TArray<FAgentModifier> globalModifiers;
    /* 0x0368 */ bool victoryPending;
    /* 0x0369 */ bool postVictory;
    /* 0x036a */ bool eodPending;
    /* 0x036b */ bool enablePolicybutton;
    /* 0x036c */ bool enableResearchbutton;
    /* 0x0370 */ FPolicySummary PolicySummary;
    /* 0x0374 */ FFactionExportSummary_Hud factionSummary;
    /* 0x0388 */ FActiveEffects_Hud m_activeEffects;
    /* 0x0408 */ FTimelineSummary m_timelineSummary;
    /* 0x0428 */ FDebtsSummary_Hud m_debtsSummary;
    /* 0x0468 */ FLastHappinessEffect lastHappinessMod;
    /* 0x0478 */ TArray<FLastHappinessEffect> recentEffects;
    /* 0x0488 */ FTechSummary TechSummary;
    /* 0x04c8 */ bool showSaving;
    /* 0x04d0 */ FString colonyName;
    /* 0x04e0 */ bool showGamepadCursor;
    /* 0x04e8 */ TArray<FRecentPolicyCost> recentPolicyCosts;
};

// Size: 0x18
struct FIconLookupRow : public FTableRowBase {
    /* 0x0008 */ UTexture2D* iconTexture;
    /* 0x0010 */ FColor defaultColor;
};

// Size: 0x10
struct FIdlingAgent {
    /* 0x0000 */ APrototype_Agent* Agent;
};

// Size: 0x1c
struct FImprovementsCommonHudInfo {
    /* 0x0000 */ FSupportedImprovements SupportedImprovements;
    /* 0x0003 */ FSupportedImprovementsState liveImprovementsState;
    /* 0x0008 */ int32_t basePowerDraw;
    /* 0x000c */ int32_t livePowerDraw;
    /* 0x0010 */ float powerSatisfaction;
    /* 0x0014 */ float liveProductionModifier;
    /* 0x0018 */ bool overdriveEnabled;
};

// Size: 0x1
struct FIndividualLadderData {
};

// Size: 0x4b8
class UIndustry : public UActorComponent {
    /* 0x00e0 */ bool reportOutputAsExtraction;
    /* 0x00e4 */ float m_baseToolWear;
    /* 0x00e8 */ float m_powerDrawPerSecond;
    /* 0x00ec */ bool m_isScienceLab;
    /* 0x00f0 */ FIndustryRecipe m_recipe;
    /* 0x01a8 */ TArray<FName> m_recipeOptions;
    /* 0x01b8 */ bool m_isRecipeFoodProduction;
    /* 0x01b9 */ bool m_isRecipeFuelProduction;
    /* 0x01ba */ bool m_isRecipeScienceProduction;
    /* 0x01c0 */ UWorkerViz* m_workerViz;
    /* 0x0238 */ FWorkerAssignment m_workers;
    /* 0x0258 */ FName m_activeRecipeKey;
    /* 0x0260 */ FStockpile m_outputStockpile;
    /* 0x02b8 */ FStockpile m_inputStockpile;
    /* 0x0310 */ FStockpile m_partsStockpile;
    /* 0x0368 */ FStockpile m_catalystStockpile;
    /* 0x03c0 */ FName m_catalystResource;
    /* 0x03c8 */ int32_t m_catalystResourceCyclesLeft;
    /* 0x03cc */ int32_t m_cyclesPerCatalyst;
    /* 0x03d8 */ bool m_allowCatalysts;
    /* 0x03e4 */ FMaintenanceState m_maintenanceState;
    /* 0x0420 */ float m_agentDispatchCooldown;
    /* 0x0428 */ UStockpileRender* m_stockpileVisual;
    /* 0x0450 */ UHeatSourceComponent* m_heatSource;
    /* 0x0458 */ UParticleSystemComponent* m_breakdownParticle;
    /* 0x0468 */ FMulticastInlineDelegate runningChangedEvent;
    /* 0x0478 */ FMulticastInlineDelegate progressEvent;
    /* 0x0490 */ FMulticastInlineDelegate completedEvent;
    /* 0x04ac */ float waterDrainPerCycle;
    /* 0x04b0 */ float cachedWaterLevel;

    void DockSlotChanged(int32_t newBoatId, EWorkShipState NewState);
};

// Size: 0x438
class UIndustryAssignmentWidget : public UArcoWidgetBase {

    FIndustryHoverState CalcState();
};

// Size: 0x450
class UIndustryDetails : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;
    /* 0x0449 */ bool m_recipeSelectorOpen;

    FIndustryHudState ComputeState();
    void CycleCompletedEvent(FResourceCollection base, FResourceCollection cat);
    void CycleCompletedEvent_BlueprintEvent(FResourceCollection base, FResourceCollection cat);
    void CycleTabs(bool tabRight);
    void EndRecipeSelection();
    void EndStockpileSelection();
};

// Size: 0x28
struct FIndustryHoverState {
    /* 0x0000 */ bool Hovered;
    /* 0x0001 */ bool Selected;
    /* 0x0002 */ bool currentAssignment;
    /* 0x0008 */ FWorkerAssignmentData workerData;
    /* 0x0018 */ FName guildSpecialty;
    /* 0x0020 */ FName structureNameKey;
};

// Size: 0x2f8
struct FIndustryHudState {
    /* 0x0000 */ FIndustryRecipe baseRecipe;
    /* 0x00b8 */ TArray<FName> recipeOptionKeys;
    /* 0x00c8 */ FName selectedRecipeKey;
    /* 0x00d0 */ TMap<FName, FIndustryRecipe> availableRecipes;
    /* 0x0120 */ float liveRecipeLength;
    /* 0x0124 */ float TimeRemaining;
    /* 0x0128 */ FString statusString;
    /* 0x0138 */ float recipeProgressPercent;
    /* 0x013c */ float workerEfficiency;
    /* 0x0140 */ FWorkerAssignmentData agentsInfo;
    /* 0x0150 */ FStockpile outputStockpile;
    /* 0x01a8 */ FStockpile inputStockpile;
    /* 0x0200 */ TSet<FName> newRecipes;
    /* 0x0250 */ FString productionState;
    /* 0x0260 */ int32_t statDaysIntoPast;
    /* 0x0264 */ int32_t costToInstantDeliver;
    /* 0x0268 */ int32_t currentInfluenceAvailable;
    /* 0x0270 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x02b0 */ bool disabledByPlayer;
    /* 0x02b1 */ bool overtimeHours;
    /* 0x02b4 */ int32_t overtimeCost;
    /* 0x02b8 */ bool canAffordOvertime;
    /* 0x02bc */ float remainingOvertime;
    /* 0x02c0 */ bool showInputStockpileOverrider;
    /* 0x02c1 */ bool showOutputStockpileOverrider;
    /* 0x02c2 */ bool showScienceShortcut;
    /* 0x02c4 */ FMaintenanceUiState maintenance;
    /* 0x02d4 */ bool steamPowerConnected;
    /* 0x02d5 */ bool steamPowerSupplied;
    /* 0x02d6 */ bool running;
    /* 0x02d8 */ FName catalystResource;
    /* 0x02e0 */ int32_t catalystCount;
    /* 0x02e4 */ int32_t catalystResource_cyclesRemaining;
    /* 0x02e8 */ int32_t catalystResource_cyclesPerResource;
    /* 0x02ec */ float catalystPercent_towardsNextProduction;
    /* 0x02f0 */ bool catalystEnabled;
};

// Size: 0xb8
struct FIndustryRecipe {
    /* 0x0000 */ FResourceCollection Inputs;
    /* 0x0050 */ FResourceCollection Outputs;
    /* 0x00a0 */ float baseRecipeTime;
    /* 0x00a4 */ FName RequiredUnlock;
    /* 0x00ac */ int32_t pollutionPerSecond;
    /* 0x00b0 */ bool hideUnlessUnlocked;
};

// Size: 0x80
struct FIndustryRecipe_MasterSyncFormat : public FTableRowBase {
    /* 0x0008 */ int32_t recipeTime;
    /* 0x000c */ int32_t powerPerWorker;
    /* 0x0010 */ FName outputMode;
    /* 0x0018 */ FName in1;
    /* 0x0020 */ int32_t inCt1;
    /* 0x0024 */ FName in2;
    /* 0x002c */ int32_t inCt2;
    /* 0x0030 */ FName in3;
    /* 0x0038 */ int32_t inCt3;
    /* 0x003c */ FName in4;
    /* 0x0044 */ int32_t inCt4;
    /* 0x0048 */ FName out1;
    /* 0x0050 */ int32_t outCt1;
    /* 0x0054 */ FName out2;
    /* 0x005c */ int32_t outCt2;
    /* 0x0060 */ FName out3;
    /* 0x0068 */ int32_t outCt3;
    /* 0x006c */ FName RequiredUnlock;
    /* 0x0074 */ int32_t pollutionPerSecond;
    /* 0x0078 */ bool hideUnlessUnlocked;
};

// Size: 0x128
class UInfiniteResourceSourceOrDrain : public UActorComponent {
    /* 0x00c0 */ EResourceSpawnerMode m_spawnerType;
    /* 0x00c1 */ bool m_enabled;
    /* 0x00c2 */ bool m_spawnEverything;
};

// Size: 0x58
struct FInfiniteResourceSpawnerHudState {
    /* 0x0000 */ EResourceSpawnerMode spawnerType;
    /* 0x0001 */ bool spawnAll;
    /* 0x0002 */ bool IsEnabled;
    /* 0x0008 */ TMap<FName, FResourceStockpileSubcategory> categorizedResources;
};

// Size: 0x448
class UInfiniteResourceSpawnerView : public UArcoView {

    FInfiniteResourceSpawnerHudState ComputeState();
};

// Size: 0x318
class AInfoBlips : public AActor {
    /* 0x02a8 */ UClass* m_widgetPrefab;
    /* 0x02b0 */ UClass* m_resourceWidgetPrefab;
    /* 0x02b8 */ UOptionManager* m_optMan;
    /* 0x02c8 */ TArray<FMsgBlipData> m_tmpBlipPool;
    /* 0x02d8 */ int32_t m_nBlips;
    /* 0x02dc */ float m_nextIconScale;
    /* 0x02e0 */ float zoomBeginShrinking;
    /* 0x02e4 */ float zoomMaxShrink;
    /* 0x02e8 */ float MinScale;
    /* 0x02f0 */ TArray<FMsgBlipData> m_resourceBlipPool;
    /* 0x0300 */ int32_t m_nResourceBlips;

    void HandleSimSpeedChanged(int32_t simSpeed_tenths);
};

// Size: 0xc
struct FInjury {
    /* 0x0000 */ FName modifier;
    /* 0x0008 */ float timeUntilDeath;
};

// Size: 0xc
struct FInvoiceRow {
    /* 0x0000 */ FName stringKey;
    /* 0x0008 */ int32_t Value;
};

// Size: 0x38
struct FIslandBadgeState {
    /* 0x0000 */ FString islandName;
    /* 0x0010 */ int32_t year;
    /* 0x0018 */ FString season;
    /* 0x0028 */ int32_t day;
    /* 0x002c */ int32_t yearsPlayed;
    /* 0x0030 */ int32_t daysPlayed;
};

// Size: 0x28
struct FJob {
    /* 0x0000 */ AActor* requester;
    /* 0x0008 */ FIntVector entryDest;
    /* 0x0014 */ EJobCategory requestType;
    /* 0x0018 */ APrototype_Agent* jobWorker;
    /* 0x0020 */ int32_t jobId;
};

// Size: 0xc0
struct FJobDispenserUIState {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ int32_t pendingJobs;
    /* 0x0014 */ int32_t activeJobs;
    /* 0x0018 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory;
    /* 0x0068 */ FStockpile Stockpile;
};

// Size: 0x128
class UJobSystem : public UObject {
    /* 0x0078 */ int32_t debug_nPending;
    /* 0x0080 */ TMap<int32_t, FJob> m_activeJobs;
};

// Size: 0x1d0
class UJobTicketDispenserBuilding : public UActorComponent {
    /* 0x00d8 */ FWorkerAssignment m_workers;
    /* 0x00f8 */ TArray<EJobCategory> m_associatedJobTypes;
    /* 0x0108 */ FStockpile m_stockpile;
    /* 0x0160 */ FString m_actionStringForFulfillingTicket;
};

// Size: 0x20
struct FJumpPadUiState {
    /* 0x0000 */ FIntVector assignedLanding;
    /* 0x000c */ bool assigned;
    /* 0x000d */ bool assigning;
    /* 0x0010 */ int32_t maxSteam;
    /* 0x0014 */ int32_t storedSteam;
    /* 0x0018 */ int32_t steamPerLaunch;
    /* 0x001c */ int32_t projectedSteamForNewAssignment;
};

// Size: 0x10
struct FKeybindHintsPanelData {
    /* 0x0000 */ TArray<EArco_PlayerVerb> hints;
};

// Size: 0x1c8
struct FLabHudState {
    /* 0x0000 */ FResearchSummaryState m_globalScienceState;
    /* 0x0078 */ FScienceState m_scienceState;
    /* 0x00e8 */ float workerEfficiency;
    /* 0x00f0 */ FWorkerAssignmentData agentsInfo;
    /* 0x0100 */ FStockpile inputStockpile;
    /* 0x0158 */ FString productionState;
    /* 0x0168 */ bool showInputStockpileOverrider;
    /* 0x0169 */ bool steamPowerConnected;
    /* 0x016a */ bool steamPowerSupplied;
    /* 0x016b */ bool running;
    /* 0x0170 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x01b0 */ bool disabledByPlayer;
    /* 0x01b1 */ bool overtimeHours;
    /* 0x01b4 */ int32_t overtimeCost;
    /* 0x01b8 */ bool canAffordOvertime;
    /* 0x01bc */ float remainingOvertime;
    /* 0x01c0 */ int32_t diminishingReturns;
};

// Size: 0x1d0
class ULadder : public UActorComponent {
    /* 0x00c8 */ UStaticMesh* m_ladderMeshBase;
    /* 0x00d0 */ float m_visualClimbOffset;
    /* 0x00d4 */ float m_visualClimbRightOffset;
    /* 0x00d8 */ bool m_isChildLadder;
    /* 0x00e0 */ AGridActor* m_ownerOrChildGridActor;
    /* 0x00e8 */ float ladderSpeedMult;
    /* 0x00ec */ float timeBetweenClimbers;
    /* 0x00f0 */ FLadderData m_data;
    /* 0x0168 */ TArray<FTransform> m_ladderTransforms;
    /* 0x0178 */ TArray<UStaticMeshComponent*> m_ladderMeshes;
    /* 0x0190 */ int32_t nValidLadders;
};

// Size: 0x78
struct FLadderData {
    /* 0x0000 */ FVector groundPos;
    /* 0x0018 */ FIntVector groundCell;
    /* 0x0040 */ TArray<FAgentState_Climber> m_waitingAgents;
    /* 0x0050 */ TArray<FAgentState_Climber> m_climbingAgents;
    /* 0x0060 */ TArray<FAgentState_Passer> m_passingAgents;
    /* 0x0074 */ bool currentClimbDirectionDown;
};

// Size: 0x10
struct FLastHappinessEffect {
    /* 0x0000 */ int32_t Delta;
    /* 0x0004 */ FName String;
    /* 0x000c */ int32_t multCount;
};

// Size: 0x358
class ALevelEditorGameMode : public AGameModeBase {
    /* 0x0340 */ UClass* m_arcoSystemsClass;
    /* 0x0348 */ AArcoSystems* m_arcoSys;
    /* 0x0350 */ UMetaSave* m_metaSave;
};

// Size: 0x428
class ULevelEditorHud : public UArcoWidgetBase {

    FLevelEditorHudState RecalcHudState();
};

// Size: 0x6
struct FLevelEditorHudState {
    /* 0x0000 */ bool canPlay;
    /* 0x0001 */ bool hasGranary;
    /* 0x0002 */ bool hasWarehouse;
    /* 0x0003 */ bool hasDock;
    /* 0x0004 */ bool hasAssociatedSave;
    /* 0x0005 */ EDayPhase CurrentPhase;
};

// Size: 0x60
struct FLevelEditorPropToolState {
    /* 0x0000 */ TMap<FName, FGridActorDefinition_MasterSyncFormat> gridActorsInCategory;
    /* 0x0050 */ FName selectedGridActorName;
    /* 0x0058 */ FName CategoryName;
};

// Size: 0x88
struct FLiveTimelineEvent {
    /* 0x0000 */ FTimelineEventDef eventDef;
    /* 0x0078 */ int32_t decisionMade;
    /* 0x007c */ int32_t liveEventId;
    /* 0x0080 */ float initialMinimumDelay;
};

// Size: 0x78
struct FLogisticsView_UIData {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FResourceCollection activeDeficits;
    /* 0x0060 */ int32_t nGranaries;
    /* 0x0064 */ int32_t nLogisticsWorkers;
    /* 0x0068 */ bool disabledByPlayer;
    /* 0x0069 */ bool overtimeHours;
    /* 0x006c */ int32_t overtimeCost;
    /* 0x0070 */ bool canAffordOvertime;
    /* 0x0074 */ float remainingOvertime;
};

// Size: 0x14
struct FMailStyleNotif {
    /* 0x0000 */ EMailType NotifType;
    /* 0x0004 */ FName Key;
    /* 0x000c */ FName priorityQuest;
};

// Size: 0x738
class AMainMenuController : public APlayerController {
};

// Size: 0x428
class UMainMenuWidget : public UArcoWidgetBase {
};

// Size: 0x1c
struct FMaintenanceState {
    /* 0x0000 */ float maxSecondsPerPart_base;
    /* 0x0004 */ float remainingSeconds;
    /* 0x0008 */ bool safetyOverrideActive;
    /* 0x000c */ float chanceToExplodeCooldown;
    /* 0x0010 */ float timeSinceSafetyOverride;
    /* 0x0014 */ bool brokenDown;
    /* 0x0015 */ bool m_canBreakdown;
    /* 0x0018 */ float decaySpeedMultiplier;
};

// Size: 0x10
struct FMaintenanceUiState {
    /* 0x0000 */ float percentDurabilityRemaining;
    /* 0x0004 */ bool supportsMaintenance;
    /* 0x0005 */ bool showBadState;
    /* 0x0006 */ bool showEmergencyRepair;
    /* 0x0008 */ int32_t overrideCost;
    /* 0x000c */ bool safetyOverrideActive;
    /* 0x000d */ bool canAffordEmergencyRepair;
};

// Size: 0x10
struct FMaterialLookupRow : public FTableRowBase {
    /* 0x0008 */ UMaterialInstance* Material;
};

// Size: 0x28
struct FMealDef : public FTableRowBase {
    /* 0x0008 */ int32_t mealTierGroup;
    /* 0x000c */ int32_t qualityOrder;
    /* 0x0010 */ FName associatedResource;
    /* 0x0018 */ FName associatedModifier;
    /* 0x0020 */ FName associatedThought;
};

// Size: 0x18
struct FMealDefTierGroup {
    /* 0x0000 */ int32_t tierIdx;
    /* 0x0008 */ TArray<FName> mealDefs_descendingPriority;
};

// Size: 0x200
class UMetaSave : public USaveGame {
    /* 0x0028 */ FString mapEditorMapToLoad;
    /* 0x0038 */ FSimLoadCfg m_simLoadCfg;
    /* 0x0058 */ bool m_music;
    /* 0x0059 */ bool m_fuelDetails;
    /* 0x005a */ bool m_desireMasterSync;
    /* 0x005b */ bool m_alwaysDesireMasterSync;
    /* 0x005c */ bool m_disableMinimumLoadingTime;
    /* 0x005d */ bool m_assertOnReplayDesync;
    /* 0x005e */ bool m_enableAssertSaves;
    /* 0x0060 */ FIntVector newMapExtents;
    /* 0x0070 */ FString newMapColonyName;
    /* 0x0080 */ TArray<FAgentCharacteristics> newStartingAgents;
    /* 0x0090 */ float difficulty_debtMultiplier;
    /* 0x009c */ FCameraSettings m_gameplayCam;
    /* 0x00ac */ FCameraSettings m_photomodeCam;
    /* 0x00c0 */ TMap<FString, FTransform> m_savedCameraPositions;
    /* 0x0110 */ TSet<FName> tutorialIgnoreFlags;
    /* 0x0160 */ TMap<FName, float> newMapRawPreferences;
    /* 0x01b0 */ TMap<FName, FName> newMapPreferenceNames;
};

// Size: 0x4
struct FMidDaySummary {
    /* 0x0000 */ int32_t secondsUntilPhaseEnd;
};

// Size: 0x598
class AMineTool : public AActor {
    /* 0x02b0 */ UMaterialInterface* startRemovingCursorMat;
    /* 0x02b8 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x02c0 */ UClass* m_surveyorWidgetClass;
    /* 0x02e0 */ UMineToolWidgetComponent* m_resourceHoverWidget;
    /* 0x02f0 */ TArray<FString> traces;
    /* 0x0300 */ FTerrainCellTypeLibrary TypeLibrary;
    /* 0x0570 */ FSurveyInfo m_surveyorInfo;

    FMineToolInfo GetInfo() const;
    FSurveyInfo GetSurveyInfo() const;
    bool HandleHudAction(FHudAction HudAction);
    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0x80
struct FMineToolInfo {
    /* 0x0000 */ FName ResourceName;
    /* 0x0008 */ int32_t resourceCount;
    /* 0x000c */ bool bResourceCountValid;
    /* 0x0010 */ TArray<FMineToolTrace> traces;
    /* 0x0020 */ int32_t cellCount;
    /* 0x0028 */ TMap<FName, int32_t> resourceCounts;
    /* 0x0078 */ int32_t unsurveyedCellCount;
};

// Size: 0x18
struct FMineToolTrace {
    /* 0x0000 */ FName ResourceName;
    /* 0x0008 */ FString traceAmount;
};

// Size: 0x6d0
class UMineToolWidgetComponent : public UWidgetComponent {
};

// Size: 0x4b0
class UMineViz : public USceneComponent {
    /* 0x0240 */ FGridInstaMesh m_mineToolMeshes;
    /* 0x0360 */ FGridInstaMesh m_mineChoppableMeshes;
    /* 0x0480 */ UMaterialInstance* m_mineToolMaterialSet;
    /* 0x0488 */ UMaterialInstance* m_mineToolMaterialUnset;
    /* 0x0490 */ UMaterialInstance* m_mineToolMaterialInvalid;
    /* 0x0498 */ TArray<UStaticMesh*> Meshes;
};

// Size: 0x1b8
struct FMissionShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
};

// Size: 0x18
struct FModifierCategory_Ui {
    /* 0x0000 */ FName categoryKey;
    /* 0x0008 */ FString LocKey;
};

// Size: 0x50
struct FModifierPair {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FAgentModifier mod;
};

// Size: 0x68
struct FModifierTracker {
    /* 0x0000 */ FName modKey;
    /* 0x0008 */ FAgentModifier modData;
    /* 0x0050 */ TArray<APrototype_Agent*> agentsWithMod;
};

// Size: 0x28
struct FMorningSummary {
    /* 0x0000 */ int32_t desiredMeals;
    /* 0x0004 */ int32_t consumedMeals;
    /* 0x0008 */ int32_t availableRawFood;
    /* 0x000c */ int32_t availablePreppedFood;
    /* 0x0010 */ int32_t desiredDrink;
    /* 0x0014 */ int32_t consumedDrink;
    /* 0x0018 */ int32_t availableWater;
    /* 0x001c */ int32_t availableAle;
    /* 0x0020 */ int32_t secondsUntilPhaseEnd;
    /* 0x0024 */ bool phaseIsPaused;
};

// Size: 0x340
class UMsgBlip : public UUserWidget {

    void Animate();
    void SetBgTint(FColor TintColor);
    void SetMsg(FString String);
    void SetTexture(UTexture2D* Texture);
    void SetTint(FColor TintColor);
};

// Size: 0x10
struct FMsgBlipAnim {
};

// Size: 0x50
struct FMsgBlipData {
    /* 0x0000 */ FVector Pos;
    /* 0x0018 */ FVector initialPos;
    /* 0x0030 */ FMsgBlipAnim anim;
    /* 0x0040 */ UWidgetComponent* Component;
    /* 0x0048 */ FColor TintColor;
};

// Size: 0x18
struct FMusicPool {
    /* 0x0000 */ TArray<USoundBase*> music;
};

// Size: 0x50
struct FMusicPool_WeatherOverride {
    /* 0x0000 */ TMap<EDayPhase, FMusicPool> musicPools_ByDayPhase;
};

// Size: 0x468
class ANavyConfigMule : public AActor {
    /* 0x02a8 */ FOceanConfig OceanConfig;
};

// Size: 0x38
struct FNavyDragState {
    /* 0x0000 */ bool IsActive;
    /* 0x0008 */ FVector startWorld;
    /* 0x0020 */ FVector endWorld;
};

// Size: 0x550
class UNavyHudBase : public UArcoWidgetBase {
    /* 0x0428 */ FNavyToolConfig config;
    /* 0x0500 */ FNavyHudConfig HudConfig;
    /* 0x0510 */ TArray<FNavyHudWindowPlan> windowPlans;
    /* 0x0520 */ ULocManager* locMan;
    /* 0x0528 */ ANavyTool* NavyTool;
    /* 0x0530 */ ANauticalOcean* ocean;
    /* 0x0538 */ int32_t initRand;
    /* 0x0540 */ FNavyHudInterframe interframe;

    void ApplyWindowChoice(FNavyHudSubWindow windowData, FName choiceStirngId);
    FNavyHudState CalcState();
    void RunAging(float deltaTime);
};

// Size: 0x18
struct FNavyHudCannonReloadStatus {
    /* 0x0000 */ FVector2D screenPosition;
    /* 0x0010 */ float Ratio;
};

// Size: 0x10
struct FNavyHudConfig {
    /* 0x0000 */ float damageHitPeriod;
    /* 0x0008 */ double windowHeight;
};

// Size: 0x38
struct FNavyHudDamageHit {
    /* 0x0000 */ FVector WorldPosition;
    /* 0x0018 */ FVector2D screenPosition;
    /* 0x0028 */ int32_t dmgPoints;
    /* 0x002c */ float Age;
    /* 0x0030 */ float ageRatio;
};

// Size: 0x28
struct FNavyHudDrag {
    /* 0x0000 */ bool IsActive;
    /* 0x0008 */ FVector2D startScreen;
    /* 0x0018 */ FVector2D endScreen;
};

// Size: 0x28
struct FNavyHudDynamicState {
    /* 0x0000 */ bool IsActive;
    /* 0x0008 */ TArray<FNavyHudCannonReloadStatus> cannonReloads;
    /* 0x0018 */ TArray<FNavyHudDamageHit> damageHits;
};

// Size: 0x28
struct FNavyHudFullscreenMessage {
    /* 0x0000 */ bool IsActive;
    /* 0x0008 */ FNavyHudWindowPlan plan;
};

// Size: 0x10
struct FNavyHudInterframe {
    /* 0x0000 */ TArray<FNavyHudDamageHit> damageHits;
};

// Size: 0x38
struct FNavyHudShipCard {
    /* 0x0000 */ UTexture2D* shipIcon;
    /* 0x0008 */ bool IsSelected;
    /* 0x0009 */ bool isAutomated;
    /* 0x0010 */ double hp;
    /* 0x0018 */ FName actionLocId;
    /* 0x0020 */ FString resultAction;
    /* 0x0030 */ int32_t resultPayload;
};

// Size: 0x108
struct FNavyHudState {
    /* 0x0000 */ TArray<FNavyHudSubWindow> Windows;
    /* 0x0010 */ TArray<FNavyHudShipCard> ships;
    /* 0x0020 */ FNavyHudWarState warState;
    /* 0x0038 */ FNavyHudDynamicState dynamics;
    /* 0x0060 */ FNavyHudDrag Drag;
    /* 0x0088 */ FNauticalConflicts conflicts;
    /* 0x00d8 */ FNavyHudFullscreenMessage fullscreenMessage;
    /* 0x0100 */ int32_t simSpeed;
    /* 0x0104 */ bool IsPaused;
};

// Size: 0x48
struct FNavyHudSubWindow {
    /* 0x0000 */ FNavyHudWindowPlan plan;
    /* 0x0020 */ ANauticalShip* issueingShip;
    /* 0x0028 */ ANauticalIsland* issueingIsland;
    /* 0x0030 */ FVector2D screenPos;
    /* 0x0040 */ ENavyHudWindowDirection overrideDir;
};

// Size: 0x18
struct FNavyHudWarState {
    /* 0x0000 */ bool IsActive;
    /* 0x0004 */ int32_t waveIndex;
    /* 0x0008 */ FName commanderId;
    /* 0x0010 */ FName enemyId;
};

// Size: 0x20
struct FNavyHudWindowPlan {
    /* 0x0000 */ FName titleId;
    /* 0x0008 */ FName descId;
    /* 0x0010 */ TArray<FName> decisionIds;
};

// Size: 0xe0
class UNavySystem : public UActorComponent {
    /* 0x00b8 */ FNavySystemConfig config;
    /* 0x00c8 */ UWorld* World;
    /* 0x00d0 */ ANauticalOcean* ocean;
    /* 0x00d8 */ float Time;
};

// Size: 0x10
struct FNavySystemConfig {
    /* 0x0000 */ int32_t scenarioId;
    /* 0x0008 */ UClass* configMule;
};

// Size: 0x458
class ANavyTool : public AActor {
    /* 0x02b0 */ FNavyToolConfig config;
    /* 0x0388 */ FNavyToolMembers M;
    /* 0x03c0 */ FNavyToolState State;

    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0xd8
struct FNavyToolConfig {
    /* 0x0000 */ double selectionRadius;
    /* 0x0008 */ double minimumDragMovement;
    /* 0x0010 */ FString playerFaction;
    /* 0x0020 */ FString pirateFaction;
    /* 0x0030 */ FString clawFaction;
    /* 0x0040 */ UClass* navyHudClass;
    /* 0x0048 */ UMaterialParameterCollection* matParams;
    /* 0x0050 */ USoundBase* windSfx;
    /* 0x0058 */ double windSfxFadeIn;
    /* 0x0060 */ double windSfxFadeOut;
    /* 0x0068 */ USoundBase* bgm;
    /* 0x0070 */ double bgmFadeIn;
    /* 0x0078 */ double bgmFadeOut;
    /* 0x0080 */ USoundBase* battleBgm;
    /* 0x0088 */ double battleBgmFadeIn;
    /* 0x0090 */ double battleBgmFadeOut;
    /* 0x0098 */ double arcEndHeight;
    /* 0x00a0 */ FColor arcHomeColor;
    /* 0x00a4 */ FColor arcPlanColor;
    /* 0x00a8 */ FColor arcIconColor;
    /* 0x00b0 */ double arcPlanHeight;
    /* 0x00b8 */ double arcPlanHeightRatio;
    /* 0x00c0 */ double arcPlanWidth;
    /* 0x00c8 */ double arcPlanIconSize;
    /* 0x00d0 */ double formationSimSpacing;
};

// Size: 0x38
struct FNavyToolMembers {
    /* 0x0000 */ APlayerController_Play* pCon;
    /* 0x0008 */ UNavySystem* navy;
    /* 0x0010 */ ANauticalOcean* ocean;
    /* 0x0018 */ UNavyHudBase* navyHud;
    /* 0x0020 */ UAudioComponent* audioWind;
    /* 0x0028 */ UAudioComponent* audioBgm;
    /* 0x0030 */ UAudioComponent* audioBattleBgm;
};

// Size: 0x98
struct FNavyToolState {
    /* 0x0000 */ bool isDragging;
    /* 0x0001 */ bool didDragMove;
    /* 0x0008 */ FVector dragWorldStart;
    /* 0x0020 */ FVector dragWorldNow;
    /* 0x0038 */ bool isModifier;
    /* 0x0040 */ FVector focus;
    /* 0x0058 */ bool isOnGround;
    /* 0x0060 */ TArray<ANauticalShip*> shipsSelection;
    /* 0x0070 */ ENavyFormationType activeFormation;
    /* 0x0071 */ bool hideSpatialUi;
    /* 0x0072 */ bool hideHudUi;
    /* 0x0073 */ bool inPendingConfirmation;
    /* 0x0074 */ FName confirmDescId;
    /* 0x0080 */ FVector pendingSimFocusLoc;
};

// Size: 0x130
struct FNewMapInitParams {
};

// Size: 0x18
struct FNotificationHudState {
    /* 0x0000 */ TArray<FArcoNotification> notifications;
    /* 0x0010 */ bool needsUpdated;
};

// Size: 0x80
class UNotificationSystem : public UObject {

    void RemoveNotification(int32_t NotificationId);
};

// Size: 0x1b8
class UPackageDelivery : public UActorComponent {
    /* 0x00d8 */ FWorkerAssignment m_workers;
    /* 0x00f8 */ UWorkerViz* m_workerViz;
    /* 0x0100 */ FStockpile m_stockpile;
    /* 0x0170 */ UStockpileRender* m_stockpileVisual;
    /* 0x01b0 */ UServiceRange* m_serviceRange;
};

// Size: 0xc8
struct FPackageDelivery_UiData {
    /* 0x0000 */ FStockpile Stockpile;
    /* 0x0058 */ FWorkerAssignmentData workerData;
    /* 0x0068 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x00a8 */ bool disabledByPlayer;
    /* 0x00a9 */ bool overtimeHours;
    /* 0x00ac */ int32_t overtimeCost;
    /* 0x00b0 */ bool canAffordOvertime;
    /* 0x00b4 */ float remainingOvertime;
    /* 0x00b8 */ FServiceRangeCfg serviceRangeInfo;
};

// Size: 0x10
struct FParticleLookupRow_Cascade : public FTableRowBase {
    /* 0x0008 */ UParticleSystem* particle;
};

// Size: 0xc
struct FPathableNode {
    /* 0x0000 */ uint16_t Flags;
    /* 0x0004 */ float costMultiplier;
    /* 0x0008 */ ENodeBoundary boundaries[4];
};

// Size: 0x60
struct FPathfinderCallCounts {
    /* 0x0000 */ int32_t pathfinderCalls_pathToPos;
    /* 0x0004 */ int32_t pathfinderCalls_pathToWarmTile;
    /* 0x0008 */ int32_t pathfinderCalls_pathToEnterableWithFlag;
    /* 0x000c */ int32_t pathfinderCalls_pathToSupplyDeficit;
    /* 0x0010 */ int32_t pathfinderCalls_pathToResourceReceiver;
    /* 0x0014 */ int32_t pathfinderCalls_pathToResourceSupplier;
    /* 0x0018 */ int32_t pathfinderCalls_random;
    /* 0x001c */ int32_t pathfinderCalls_idleAgent;
    /* 0x0020 */ int32_t pathfinderCalls_pathToPos_MAX;
    /* 0x0024 */ int32_t pathfinderCalls_pathToWarmTile_MAX;
    /* 0x0028 */ int32_t pathfinderCalls_pathToEnterableWithFlag_MAX;
    /* 0x002c */ int32_t pathfinderCalls_pathToSupplyDeficit_MAX;
    /* 0x0030 */ int32_t pathfinderCalls_pathToResourceReceiver_MAX;
    /* 0x0034 */ int32_t pathfinderCalls_pathToResourceSupplier_MAX;
    /* 0x0038 */ int32_t pathfinderCalls_random_MAX;
    /* 0x003c */ int32_t pathfinderCalls_idleAgent_MAX;
    /* 0x0040 */ float pathfinderCalls_pathToPos_MAX_SINGLE;
    /* 0x0044 */ float pathfinderCalls_pathToWarmTile_MAX_SINGLE;
    /* 0x0048 */ float pathfinderCalls_pathToEnterableWithFlag_MAX_SINGLE;
    /* 0x004c */ float pathfinderCalls_pathToSupplyDeficit_MAX_SINGLE;
    /* 0x0050 */ float pathfinderCalls_pathToResourceReceiver_MAX_SINGLE;
    /* 0x0054 */ float pathfinderCalls_pathToResourceSupplier_MAX_SINGLE;
    /* 0x0058 */ float pathfinderCalls_random_MAX_SINGLE;
    /* 0x005c */ float pathfinderCalls_idleAgent_MAX_SINGLE;
};

// Size: 0x20
struct FPathfinderDebug {
    /* 0x0000 */ bool m_startPosSet;
    /* 0x0004 */ FIntVector m_pathStartPos;
    /* 0x0010 */ bool m_endPosSet;
    /* 0x0014 */ FIntVector m_pathEndPos;
};

// Size: 0x60
struct FPathfinderDebugResults {
    /* 0x0020 */ int32_t currentVistitionNode;
    /* 0x0024 */ int32_t nNodes;
    /* 0x0028 */ FIntVector foundNode;
    /* 0x0034 */ bool success;
    /* 0x0038 */ float bestHeatFound;
    /* 0x003c */ int32_t out_searchCost;
    /* 0x0040 */ FVector bestAgentPos;
    /* 0x0058 */ int32_t bestAgentFound;
};

// Size: 0x428
class UPathfinderDebuggerView : public UArcoWidgetBase {
};

// Size: 0x18
struct FPathfinderSearchParamArgs {
    /* 0x0000 */ EPathableNodeFlag flag_playerChosen;
    /* 0x0004 */ float maxSearchCost;
    /* 0x0008 */ FName agentIntent;
    /* 0x0010 */ int32_t agentIntent_intParam;
    /* 0x0014 */ int32_t minHeat;
};

// Size: 0x4e0
class APawn_Play : public APawn {
    /* 0x0350 */ FPlayPawnCfg m_config;
    /* 0x03d0 */ float adjustedMinCamDist;
    /* 0x03d8 */ FVector m_desiredPanPos;
    /* 0x03f0 */ float m_desiredZoomDist;
    /* 0x03f8 */ FRotator m_desiredRot;
    /* 0x0430 */ float m_focusLockCooldown;
    /* 0x0438 */ FVector m_currentFocalPoint;

    void DoApplyFocalLength(float FocalLength);
    void DoApplyVolumetricCloudsActive(bool cloudsActive);
};

// Size: 0x58
struct FPaymentBreakdown {
    /* 0x0000 */ int32_t amountPaid;
    /* 0x0008 */ FResourceCollection resourcesLoaded;
};

// Size: 0x30
struct FPhotomodeHudState {
    /* 0x0000 */ bool showPhotomodeHud;
    /* 0x0004 */ float minMultiplier;
    /* 0x0008 */ float maxMultiplier;
    /* 0x000c */ float moveMultiplier;
    /* 0x0010 */ float rotMultiplier;
    /* 0x0018 */ TArray<FString> savedViews;
    /* 0x0028 */ float smoothingSpeed;
};

// Size: 0x20
struct FPipeConnectionDef {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ FRotator Rotation;
};

// Size: 0x10
struct FPipeLookup {
    /* 0x0000 */ TArray<FPipeConnectionDef> pipeVisualLookup;
};

// Size: 0x180
class UPipeSegment : public UActorComponent {
    /* 0x00b8 */ FIntVector offsetFromOwnerRoot;
    /* 0x00c4 */ float capacity;
    /* 0x00c8 */ bool isOpenAir;
    /* 0x00d0 */ TSet<FDir> adapterSocketDirs_local;
    /* 0x0120 */ TSet<FDir> adapterSocketDirs_world;
    /* 0x0170 */ int32_t owningPipeNetwork;
    /* 0x0174 */ EPipeCategory pipeCategory;
    /* 0x0175 */ EPipeType pipeType;
    /* 0x0178 */ UStaticMeshComponent* pipeStaticMesh;
};

// Size: 0x78
struct FPipeSubNetwork {
    /* 0x0000 */ int32_t ID;
    /* 0x0008 */ TSet<UPipeSegment*> pipeSegments;
    /* 0x0058 */ EPipeCategory groupType;
    /* 0x005c */ FColor DebugColor;
    /* 0x0060 */ UMaterialInstanceDynamic* MaterialInstance;
    /* 0x006c */ int32_t contents;
    /* 0x0070 */ int32_t capacity;
};

// Size: 0x468
class APipeSystem : public AActor {
    /* 0x0398 */ TMap<int32_t, FPipeSubNetwork> m_subnetworks;
    /* 0x03e8 */ UStaticMesh* m_fallbackMesh;
    /* 0x03f0 */ FPipeLookup m_fluidPipeLookup;
    /* 0x0400 */ FPipeLookup m_steamPipeLookup;
    /* 0x0410 */ TMap<EPipeCategory, FPipeLookup> m_pipeLookups;

    int32_t GetCapacityOfNetwork(int32_t network) const;
    int32_t GetFluidInNetwork(int32_t network) const;
};

// Size: 0x668
class APipeTool : public AActor {
    /* 0x0450 */ UWidgetComponent* m_placementUiWidget;
    /* 0x0550 */ bool isDragging;
    /* 0x0554 */ FIntVector dragStartPos;
    /* 0x0560 */ FIntVector dragEndPos;
    /* 0x056c */ FIntVector derivedEndPos;
    /* 0x0580 */ TMap<EPipeCategory, FName> m_pipeTemplates;
    /* 0x05d0 */ UStaticMesh* m_dragStartMesh;
    /* 0x05d8 */ UStaticMesh* m_dragEndMesh;
    /* 0x05e0 */ UStaticMeshComponent* m_dragStartViz;
    /* 0x05e8 */ UStaticMeshComponent* m_dragEndViz;
};

// Size: 0x2a0
struct FPirateShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ TArray<FTradeRow> tradeRows;
    /* 0x01c8 */ FResourceCollection loadedResources;
    /* 0x0218 */ int32_t totalDebt;
    /* 0x021c */ int32_t totalCanonballs;
    /* 0x0220 */ int32_t canonBallsToShoot;
    /* 0x0224 */ bool canShip;
    /* 0x0228 */ FString currentTradeBinKey;
    /* 0x0238 */ FString currentTradeBin_ButtonKey;
    /* 0x0248 */ bool autopayEnabled;
    /* 0x024c */ int32_t autopayPercentGoal;
    /* 0x0250 */ FResourceCollection inboundResources;
};

// Size: 0xf0
struct FPlacementResponse {
};

// Size: 0x10
struct FPlannedFloorSeg {
};

// Size: 0x20
struct FPlannedWallSeg {
};

// Size: 0x960
class UPlayHud : public UArcoWidgetBase {
    /* 0x0428 */ UClass* m_agentOverviewWidgetClass;
    /* 0x0430 */ UClass* m_resourceOverviewWidgetClass;
    /* 0x0438 */ bool m_uiHasFadedIn;
    /* 0x0440 */ FHudState m_hudState;
    /* 0x0948 */ UToolbar* m_toolbar;
    /* 0x0950 */ UArcoRadialMenu* M_RadialMenu;
    /* 0x0958 */ UArcoWidgetBase* m_submenu;

    void AnimateEnterNauticalUi();
    void AnimateRecentPolicyCosts(const TArray<FRecentPolicyCost>& recentPolicyCosts);
    void AnimateReturnToMainui();
    void CloseTutorialDialog();
    void EventPhaseChanged(EDayPhase newPhase);
    void FadeInMainUi();
    void OpenTutorialDialog();
    void PushHeadlinerMessage(FString Msg);
    void ShowLoadingScreenEvent(bool Show);
    void UpdateActiveEffects(FActiveEffects_Hud effects);
    void UpdateDebtInfo(FDebtsSummary_Hud debtSummary);
    void UpdateDebugWindow(bool showDebugWindow);
    void UpdateDeveloperUi(bool Show);
    void UpdateDisplayState(FHudState NewState);
    void UpdateEodButton(bool showButton);
    void UpdateEveningSummary(FEveningSummary EveningSummary);
    void UpdateEventQueue(FEventQueue_Hud EventQueue);
    void UpdateFactionExportSummary(FFactionExportSummary_Hud factionInfo);
    void UpdateGeneralUiValues(FHudState NewState);
    void UpdateKeybinds_BpEvent(FKeybindHintsPanelData newHints);
    void UpdateLastModifier(FLastHappinessEffect lastEffect);
    void UpdateMidDaySummary(FMidDaySummary MidDaySummary);
    void UpdateMorningSummary(FMorningSummary MorningSummary);
    void UpdateNotifications(FNotificationHudState notifications);
    void UpdatePhotomode(FPhotomodeHudState State);
    void UpdatePoliciesSummary(FPolicySummary nPolicies);
    void UpdateProblemSummaries(const FProblemSummaries_UI summary);
    void UpdateQuestElement(FQuestHudState QuestHudState);
    void UpdateRecentModifiers(const TArray<FLastHappinessEffect>& recentEffects);
    void UpdateReplayWindow(FReplayHudState replayState);
    void UpdateResourceView(FResourceHudState Resources);
    void UpdateSaveEvent(EGameSaveResult statuCode);
    void UpdateSavingOverlay(bool Show);
    void UpdateScienceValues(FHudState NewState);
    void UpdateSeasonInfo(FSeasonSummary SeasonSummary);
    void UpdateTechProgress(FTechSummary TechSummary);
    void UpdateTimeElement(FTimeHudState timeState);
    void UpdateTimelineSummary(FTimelineSummary Timeline);
    void UpdateVictoryButton(bool victoryAllowed, bool postVictory);
};

// Size: 0x80
struct FPlayPawnCfg {
    /* 0x0000 */ float panSpeed;
    /* 0x0004 */ float zoomSpeed;
    /* 0x0008 */ EEase zoomEase;
    /* 0x000c */ float minCamDist;
    /* 0x0010 */ float maxCamDist;
    /* 0x0014 */ float camSmoothness;
    /* 0x0018 */ float startCamZoomRatio;
    /* 0x001c */ int32_t degreesPerRot;
    /* 0x0020 */ float rotLerpSpeed;
    /* 0x0024 */ float continuousRotateSpeed;
    /* 0x0028 */ float navyCamDist;
    /* 0x002c */ float navyForceBoundaryDist;
    /* 0x0030 */ float navyForceBoundarySpeed;
    /* 0x0034 */ float navyForceBoundaryMargin;
    /* 0x0038 */ float maxPanSpeedCamDist;
    /* 0x003c */ float panSpeedMultAtMaxZoomout;
    /* 0x0040 */ float boundsLimitDist;
    /* 0x0044 */ float maxZoomVelocity;
    /* 0x0048 */ float orthoDistanceStart;
    /* 0x004c */ float orthoDistanceFull;
    /* 0x0050 */ float orthoFocalLenStart;
    /* 0x0054 */ float orthoFocalLenEnd;
    /* 0x0058 */ float volCloudDistance;
    /* 0x005c */ float lowestTilt;
    /* 0x0060 */ float highestTilt;
    /* 0x0064 */ float orbitMult;
    /* 0x0068 */ float tiltMult;
    /* 0x006c */ float edgePanPixels;
    /* 0x0070 */ UMaterialInterface* rtCleanerMat;
    /* 0x0078 */ UMaterialParameterCollection* mpcPlanetViewRatio;
};

// Size: 0x268
class UPlayerBank : public UObject {
    /* 0x0028 */ TMap<FName, int32_t> m_productionLimit;
    /* 0x0078 */ FResourceFlowTracker m_flowTracker;
    /* 0x00d8 */ TMap<FName, FPlayerBankResource> m_bankResources;
    /* 0x0138 */ int32_t m_influenceCurrency;
    /* 0x013c */ int32_t influenceCapacity;
    /* 0x0140 */ int32_t m_diplomacyPoints;
    /* 0x0144 */ int32_t m_researchCurrency;
    /* 0x0148 */ int32_t m_unrestCurrency;
    /* 0x014c */ int32_t unrestCapacity;
    /* 0x01a0 */ int32_t researchCurrencyCapacity;
    /* 0x01a4 */ int32_t foodCount;
    /* 0x01a8 */ int32_t foodCount_raw;
    /* 0x01ac */ int32_t foodCount_cooked;
    /* 0x01b0 */ FResourceCollection m_distributorStoredFoods;
    /* 0x0200 */ int32_t drinkCount;

    TMap<FName, FResourceStockpileSubcategory> GetDisplayResourcesForSubcategories(FName Category, TSet<FName> subcategories, bool includeDistributorStores);
    int32_t GetResourceCount(FName Resource) const;
    int32_t GetTotalTradeValue() const;
};

// Size: 0xc
struct FPlayerBankResource {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t capacity;
    /* 0x0008 */ bool discovered;
};

// Size: 0xc
struct FPlayerBankResourceInfo_UI {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t capacity;
    /* 0x0008 */ bool trackOnHud;
};

// Size: 0x14
struct FPlayerBankResource_UI {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FPlayerBankResource Resource;
};

// Size: 0x50
struct FPlayerBankSubcategory_UI {
    /* 0x0000 */ TMap<FName, FPlayerBankResourceInfo_UI> rows;
};

// Size: 0x770
class APlayerController_FootprintTool : public APlayerController {
    /* 0x0768 */ AFootprintTool* m_footprintTool;

    void AssignBoundaryValueToSelectedCell(int32_t wallDir, ENodeBoundary boundaryType);
    void AssignGridFlagToSelectedCell(ETowerGridFlag Flag, bool Set);
    void AssignOccupancyValueToSelectedCell(EGridOccupancy occupancyType);
    void AssignPathabilityFlagToSelectedCell(int32_t flagAsInt, bool Set);
    void ClearCell();
    void CopyFootprintToClipboard();
    void CopySelectedCell();
    bool DoesSelectedCellHaveGridCellFlag(ETowerGridFlag Flag);
    bool DoesSelectedCellHavePathabilityFlag(int32_t pathabilityflag);
    FFootprintCell GetSelectedCell_FootprintState();
    void PasteToCurrentCell();
    void SetFootprintActorVisible(bool Visible);
};

// Size: 0xc58
class APlayerController_Play : public APlayerController {
    /* 0x0738 */ UClass* m_playHudClass;
    /* 0x0740 */ UPlayHud* m_playHud;
    /* 0x0748 */ UClass* m_endOfDayPanelView;
    /* 0x0750 */ UClass* m_agentOverviewPanel;
    /* 0x0758 */ UClass* m_introCutsceneView;
    /* 0x0760 */ UClass* m_embarkCutscene;
    /* 0x0768 */ UClass* m_stockpileView;
    /* 0x0770 */ UClass* m_tutorialView;
    /* 0x0778 */ UClass* m_newDayReport;
    /* 0x0780 */ UClass* m_eventView;
    /* 0x0788 */ UClass* m_colonyProgress;
    /* 0x0790 */ UClass* m_policyPanel;
    /* 0x0798 */ UClass* m_questLog;
    /* 0x07a0 */ UClass* m_techTreeView;
    /* 0x07a8 */ UClass* m_helpGlossary;
    /* 0x07b0 */ UClass* m_cheatMenu;
    /* 0x07b8 */ UClass* m_eventFrame;
    /* 0x07c0 */ UClass* m_pauseMenuView;
    /* 0x07c8 */ UClass* m_debtsView;
    /* 0x07d0 */ UClass* m_embarkContractView;
    /* 0x07d8 */ UClass* m_mailboxView;
    /* 0x07e0 */ UClass* m_agentManagementView;
    /* 0x07e8 */ USoundClass* m_muteSoundClass;
    /* 0x07f0 */ UClass* m_freecamPawnClass;
    /* 0x0808 */ UClass* m_playerCursorClass;
    /* 0x0818 */ UClass* m_camInterpolaterClass;
    /* 0x0820 */ AArcoCamInterpolator* m_camInterpolator;
    /* 0x0828 */ TMap<FName, float> m_debugTrends;
    /* 0x0880 */ FArcoPlayerState m_state;
    /* 0x09b8 */ float m_timeToPreserveRadialDepth;
    /* 0x09c8 */ UClass* m_bulldozeToolClass;
    /* 0x09d0 */ UClass* m_selectToolClass;
    /* 0x09d8 */ UClass* m_propToolClass;
    /* 0x09e0 */ UClass* m_debugToolClass;
    /* 0x09e8 */ UClass* m_decorativeToolClass;
    /* 0x09f0 */ UClass* m_pipeToolClass;
    /* 0x09f8 */ UClass* m_floorToolClass;
    /* 0x0a00 */ UClass* m_mineToolClass;
    /* 0x0a08 */ UClass* m_aimToolClass;
    /* 0x0a10 */ UClass* m_farmToolClass;
    /* 0x0a18 */ UClass* m_navyToolClass;
    /* 0x0a20 */ UClass* m_terrainToolClass;
    /* 0x0a28 */ UClass* m_railroadToolClass;
    /* 0x0a30 */ UClass* m_trainToolClass;
    /* 0x0a38 */ UClass* m_terraformToolClass;
    /* 0x0a40 */ UClass* m_choppingPriorityToolClass;
    /* 0x0a48 */ UClass* m_foragingPriorityToolClass;
    /* 0x0a50 */ UClass* m_cursorGridClass;
    /* 0x0a58 */ UClass* m_victoryCutscene;
    /* 0x0a60 */ UClass* m_devToolView;
    /* 0x0a68 */ UClass* m_achievementDebuggerClass;
    /* 0x0a70 */ UArcoWidgetBase* m_achievementDebugger;
    /* 0x0a78 */ UClass* m_packagedCanaryWarningClass;
    /* 0x0a80 */ UArcoWidgetBase* m_packagedCanaryWarning;
    /* 0x0a90 */ UClass* m_spatialTextClass;
    /* 0x0a98 */ ASpatialTextPool* m_spatialTextPool;
    /* 0x0aa0 */ bool useContinuousRotation;
    /* 0x0aa8 */ ACursorGrid* m_cursorGridActor;
    /* 0x0b60 */ ADebugTool* debugToolInst;
    /* 0x0b9c */ FScrollClickSoundState m_scrollClickerAudioState;
    /* 0x0bb0 */ UDataTable* m_mainToolbarConfigured;
    /* 0x0c08 */ bool m_autosavesEnabled;
    /* 0x0c0c */ float m_timeUntilNextAutosave;
    /* 0x0c50 */ float overrideZoomSpeed;

    void Arco_AchievementDebugger(bool Show);
    void Arco_CreateDebt(int32_t debtVal);
    void Arco_GenTestShipSchedule(EShipType shipType);
    void Arco_GiveDiplomacy(int32_t diplomacy);
    void Arco_GiveInfluence(int32_t influence);
    void Arco_GiveResource(FString ResourceName, int32_t Count);
    void Arco_GiveScience(int32_t Count);
    void Arco_GiveUnlock(FName unlock);
    void Arco_KillSelectedWhisker();
    void Arco_NoCost(bool actionsAreFree);
    void Arco_PauseDayCycle(bool Pause);
    void Arco_RemoveWorldEffect(FName effect);
    void Arco_RevokeUnlock(FName unlock);
    void Arco_SetDayPhase(EDayPhase Phase);
    void Arco_SetTimeOfDay(float Time);
    void Arco_SetWeatherVisual(FName weatherType);
    void Arco_SpawnAgentsAtCursor(int32_t nAgents);
    void Arco_SpawnAgentsAtDock(int32_t nAgents, EAgentEducation education);
    void Arco_SpawnShip(EShipType shipType);
    void Arco_SpawnWorldEffect(FName effect);
    void Arco_UnlockAll(bool unlock);
    void Arco_ValidateResourceReservations();
    void Arco_ValidateStorage();
    void AutosaveTrigger();
    ECameraBehavior GetCurrentCameraBehavior();
    static TArray<int32_t> GetValidPlayerGameplaySpeeds();
    void HandleArcoDayEnded(EDayPhase endedPhase);
    void HandleHudAction(FHudAction HudAction);
    void HandlePhaseBegin(EDayPhase newPhase);
    void HandleSimSpeedChanged(int32_t SpeedMultiplier);
    static void InterpretCameraView(AActor* endingViewTarget, float travelTime, EEase easingFunction, float blendFactor);
    void Load(FString saveSlot);
    void PostPawnTick(float rotationDelta);
    void Save(FString saveSlot);
};

// Size: 0xa8
struct FPlayerResourcesView_UiData {
    /* 0x0000 */ TMap<FName, FPlayerBankSubcategory_UI> foodCategorized;
    /* 0x0050 */ TMap<FName, FPlayerBankSubcategory_UI> resourcesCategorized;
    /* 0x00a0 */ bool productionLimitsAvailable;
};

// Size: 0x120
class UPolicies : public UObject {
    /* 0x0028 */ int32_t m_nMaxPolicySlots;
    /* 0x002c */ int32_t m_nInitialPolicySlots;
    /* 0x0030 */ TArray<FActivePolicySlot> m_policySlots;
    /* 0x0040 */ TMap<FName, FAvailablePolicy> m_availablePolicies;
    /* 0x0110 */ FExtraWoodPolicyState m_woodPolicyState;
};

// Size: 0x80
struct FPoliciesState {
    /* 0x0000 */ FName currentPolicyCategory;
    /* 0x0008 */ TArray<FPolicyData_UI> m_activePolicies;
    /* 0x0018 */ TArray<FPolicyData_UI> m_availablePolicies;
    /* 0x0028 */ TMap<FName, int32_t> m_policyCounts;
    /* 0x0078 */ int32_t influenceCount;
    /* 0x007c */ int32_t maxInfluence;
};

// Size: 0x70
struct FPolicyData_UI {
    /* 0x0000 */ EPolicyCardType cardType;
    /* 0x0004 */ FName Key;
    /* 0x0010 */ FPolicyLookupRow policyDef;
    /* 0x0060 */ bool isAlreadyActive;
    /* 0x0061 */ bool canAfford;
    /* 0x0064 */ int32_t historicExpense;
    /* 0x0068 */ bool canAffordUnlockCost;
};

// Size: 0x50
struct FPolicyLookupRow : public FTableRowBase {
    /* 0x0008 */ FName nameKey;
    /* 0x0010 */ FName descKey;
    /* 0x0018 */ UTexture2D* Icon;
    /* 0x0020 */ int32_t baseCost;
    /* 0x0024 */ float popCostMultiplier;
    /* 0x0028 */ FName RequiredUnlock;
    /* 0x0030 */ FName policyGroup;
    /* 0x0038 */ FString costUnit;
    /* 0x0048 */ int32_t unlockCost;
};

// Size: 0x4
struct FPolicySummary {
    /* 0x0000 */ int32_t nActivePolicies;
};

// Size: 0xa0
struct FPolicy_UiData {
    /* 0x0000 */ FFoodDationing_UiData rationingData;
    /* 0x0010 */ FPoliciesState PoliciesState;
    /* 0x0090 */ int32_t secondsRemainingInDay;
    /* 0x0094 */ bool policiesDirty;
    /* 0x0095 */ bool approvalDirty;
    /* 0x0098 */ int32_t officeCount;
    /* 0x009c */ bool showExpansionHint;
};

// Size: 0x438
struct FPopulation {
    /* 0x0008 */ TMap<int32_t, APrototype_Agent*> agents;
    /* 0x0058 */ TArray<APrototype_Agent*> freeAgents;
    /* 0x0068 */ TMap<APrototype_Agent*, int32_t> agentsToId;
    /* 0x00b8 */ TSet<APrototype_Agent*> agentsWanderingIdle;
    /* 0x0108 */ TMap<FName, int32_t> m_guildCounts;
    /* 0x01a8 */ FAgentModifierState m_globalModifiersState;
};

// Size: 0x50
struct FPopulationModifierInfo {
    /* 0x0000 */ FAgentModifier modifier;
    /* 0x0048 */ int32_t nInstances;
};

// Size: 0x160
struct FPopulationOverviewState {
    /* 0x0000 */ TArray<FAgentDisplaySummary> allAgents;
    /* 0x0010 */ TArray<FAgentModifier> globalModifiers;
    /* 0x0020 */ int32_t averageAgentSpeed;
    /* 0x0024 */ int32_t averageAgentProductivity;
    /* 0x0028 */ float timeLeftInDay;
    /* 0x0030 */ FCombinedStatsForDay liveDayStats;
    /* 0x0120 */ int32_t currAvgHappiness;
    /* 0x0124 */ int32_t possibleBonusInfluence;
    /* 0x0128 */ int32_t influencePerHappiness;
    /* 0x012c */ FPublicOpinionBreakdown ApprovalBreakdown;
    /* 0x0140 */ TArray<FActiveEffect> m_activeEffects;
    /* 0x0150 */ TArray<FWorkplaceInfo> workplaces;
};

// Size: 0xa8
struct FPopulationSummary_UI {
    /* 0x0000 */ int32_t totalPopulation;
    /* 0x0004 */ int32_t totalHousing;
    /* 0x0008 */ TMap<EAgentEducation, int32_t> educationCounts;
    /* 0x0058 */ TMap<FName, int32_t> guildCounts;
};

// Size: 0xd8
struct FPrefabInfo {
    /* 0x0000 */ FName prefabKey;
    /* 0x0008 */ FGridPathability pathability;
    /* 0x0070 */ FGridFootprint footprint;
};

// Size: 0x380
class AProblemIndicator : public AActor {
    /* 0x02a8 */ UOptionManager* m_optMan;
    /* 0x02b4 */ float zoomBeginShrinking;
    /* 0x02b8 */ float zoomMaxShrink;
    /* 0x02bc */ float MinScale;
    /* 0x02c0 */ UClass* m_problemWidgetClass;

    void Event_ProblemsChanged(const TArray<FName>& Keys);
};

// Size: 0xc
struct FProblemIndicatorData {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ float remainingDuration;
};

// Size: 0x40
struct FProblemIndicatorGroup {
    /* 0x0000 */ TArray<FProblemIndicatorData> problems;
    /* 0x0018 */ UWidgetComponent* Render;
    /* 0x0020 */ bool ShowDetails;
    /* 0x0028 */ FVector position;
};

// Size: 0x28
class IProblemIndicatorInterface : public UInterface {
};

// Size: 0x28
struct FProblemIndicatorMessage : public FTableRowBase {
    /* 0x0008 */ UTexture2D* Icon;
    /* 0x0010 */ FColor TintColor;
    /* 0x0018 */ FString detailString;
};

// Size: 0x428
class UProblemIndicatorWidget : public UArcoWidgetBase {

    void SetOpacity(float Opacity);
    void ShowDetails(bool expand);
    void UpdateData(const TArray<FProblemIndicatorData>& problems);
};

// Size: 0x18
struct FProblemSummaries_UI {
    /* 0x0000 */ TArray<FProblemSummary> problems;
};

// Size: 0x78
struct FProblemSummary {
    /* 0x0001 */ EProblemSummaryType problemType;
    /* 0x0008 */ FHudAction hudActionOnClick;
    /* 0x0060 */ bool shouldPulseVisual;
    /* 0x0064 */ FName modifierKey;
    /* 0x006c */ int32_t Instances;
    /* 0x0070 */ int32_t nConstructions;
};

// Size: 0xc0
struct FProductionControlState_UI {
    /* 0x0000 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory_foods;
    /* 0x0050 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory_drygoods;
    /* 0x00a0 */ bool isGlobal;
    /* 0x00a8 */ FWorkerAssignmentData agentsInfo;
    /* 0x00b8 */ bool controlsUnlocked;
};

// Size: 0x448
class UProductionControls : public UArcoView {

    FProductionControlState_UI CalcState();
};

// Size: 0x378
class AProjectArcoGameModeBase : public AGameModeBase {
    /* 0x0340 */ FDebugCfg m_debugCfg;
    /* 0x0350 */ UClass* m_arcoSystemsClass;
    /* 0x0358 */ AArcoSystems* m_arcoSys;
    /* 0x0360 */ UClass* m_chameleonClass;
    /* 0x0368 */ AActor* m_chameleon;

    EInitPhase CurrentInitPhase();
    void SetHighlightMode(EHighlightMode highlightMode);
};

// Size: 0x28
struct FPropCategory : public FTableRowBase {
    /* 0x0008 */ TArray<FName> optionsInCategory;
    /* 0x0018 */ TArray<FName> debug_fakedisabled;
};

// Size: 0x590
class APropTool : public AActor {
    /* 0x0398 */ UWidgetComponent* m_placementUiWidget;
    /* 0x03a0 */ UChildActorComponent* m_previewComponent;

    void Event_BuildingPlaced(const TArray<FIntVector>& footprintFloorPositions);
    void HandleSimSpeedChanged(int32_t simSpeed);
};

// Size: 0xae0
class APrototype_Agent : public AActor {
    /* 0x02a8 */ float cullDistanceSquared;
    /* 0x02b0 */ FVector haul_rootPos;
    /* 0x02c8 */ FColor pathColorNormal;
    /* 0x02cc */ FColor pathColorDestination;
    /* 0x02d0 */ FColor pathColorTraversable;
    /* 0x02d4 */ FColor pathColorEnterable;
    /* 0x02d8 */ FColor unemployedHoodColor;
    /* 0x02dc */ bool m_isWandering;
    /* 0x02dd */ bool debugHeat;
    /* 0x02e0 */ FAgentState m_state;
    /* 0x0740 */ FAgentCharacteristics m_characteristics;
    /* 0x0878 */ TArray<EBehaviorType> m_behaviorTypesDebug;
    /* 0x08a0 */ TMap<FName, int32_t> m_activeNotifications;
    /* 0x08f0 */ UStaticMeshComponent* m_model;
    /* 0x08f8 */ USkeletalMeshComponent* m_skeletalMesh;
    /* 0x0900 */ UStaticMeshComponent* m_cartMesh;
    /* 0x0908 */ USceneComponent* m_cartResourceAnchor;
    /* 0x0910 */ UInstancedStaticMeshComponent* m_instancedHaulMesh;
    /* 0x0918 */ UWidgetComponent* m_tempWidget;
    /* 0x0920 */ UAgentTemperatureWidget* m_tempWidgetRef;
    /* 0x0928 */ UStaticMeshComponent* m_handToolMesh;
    /* 0x0930 */ UStaticMeshComponent* m_offhandToolMesh;
    /* 0x0938 */ UStaticMeshComponent* m_beltToolMesh;
    /* 0x0940 */ UStaticMeshComponent* m_hatMesh;
    /* 0x0948 */ UMaterialInstanceDynamic* m_meshMatInstance;
    /* 0x0968 */ UHeatRecipientComponent* m_heatComponent;
    /* 0x0970 */ FResourceCollection m_currentlyRenderedResources;
    /* 0x0a10 */ float m_pollutionMeterResposiveness;

    void BreakOnNextTick();
    bool CanPickupAgent();
    static TArray<FAgentCharacteristics> GenerateNewAgentGroup(const UObject* Context, int32_t randSeed, TArray<FName> forcedTraits, int32_t WhiskerCountOverride);
    int32_t GetCarryCapacity(ECarryMode carryMode, ECheckCarryApproval checkPolicyAfford) const;
    uint8_t GetHeat() const;
    FName GetKeyForTemperatureState(EHeatRecipientState State) const;
    EHeatRecipientState GetTemperatureState() const;
    AGridActor* GetWorkplace() const;
    void RenderPath();
    void _dayPhaseBegan(EDayPhase dayPhase);
    void _dayPhaseEnded(EDayPhase endedPhase);
};

// Size: 0x14
struct FPublicOpinionBreakdown {
    /* 0x0000 */ int32_t totalPositiveThought;
    /* 0x0004 */ int32_t totalNegativeThought;
    /* 0x0008 */ int32_t totalApproval;
    /* 0x000c */ int32_t totalApprovalCapacity;
    /* 0x0010 */ int32_t expectedGain;
};

// Size: 0x140
struct FPurchaseableColonist {
    /* 0x0000 */ FAgentCharacteristics characteristics;
    /* 0x0138 */ bool alreadyAccepted;
    /* 0x0139 */ bool alreadyRejected;
    /* 0x013a */ bool canAfford;
};

// Size: 0xc8
struct FQuestBatchDef {
    /* 0x0000 */ EQuestType questType;
    /* 0x0008 */ FString questTitle;
    /* 0x0018 */ FString questDescription;
    /* 0x0028 */ FString acceptText;
    /* 0x0038 */ FString declineText;
    /* 0x0048 */ FName issuingFaction;
    /* 0x0050 */ UTexture2D* Icon;
    /* 0x0058 */ USoundBase* SoundCue;
    /* 0x0060 */ TArray<FQuestGoal> goals;
    /* 0x0070 */ TArray<FActionResult> successResults;
    /* 0x0080 */ TArray<FActionResult> failureResults;
    /* 0x0090 */ int32_t daysToComplete;
    /* 0x0094 */ bool pushCompletionPromptEvent;
    /* 0x0098 */ FName failureMessage;
    /* 0x00a0 */ FName successMessage;
    /* 0x00a8 */ bool demoLocked;
    /* 0x00b0 */ TArray<FName> m_unlocksOnStart;
    /* 0x00c0 */ FName m_worldEffectOnStart;
};

// Size: 0x3a0
struct FQuestBatchState {
    /* 0x0000 */ int32_t questId;
    /* 0x0004 */ FName questDefKey;
    /* 0x0010 */ FQuestBatchDef questDef;
    /* 0x00d8 */ TArray<FQuestProgress> subQuestProgresses;
    /* 0x00e8 */ int32_t daysRemaining;
    /* 0x00ec */ bool subquestsComplete;
    /* 0x00f0 */ FQuestWorldState worldState_postQuestStart;
};

// Size: 0xf8
struct FQuestDef_MasterSyncFormat : public FTableRowBase {
    /* 0x0008 */ FString questTitle;
    /* 0x0018 */ FString questDesc;
    /* 0x0028 */ bool demoLocked;
    /* 0x0030 */ FString acceptText;
    /* 0x0040 */ FString declineText;
    /* 0x0050 */ UTexture2D* Icon;
    /* 0x0058 */ USoundBase* SoundCue;
    /* 0x0060 */ int32_t daysToComplete;
    /* 0x0064 */ bool useLocalTracking;
    /* 0x0068 */ FName issuingFaction;
    /* 0x0070 */ FName goal1_type;
    /* 0x0078 */ FName goal1_key;
    /* 0x0080 */ int32_t goal1_count;
    /* 0x0084 */ FName goal2_type;
    /* 0x008c */ FName goal2_key;
    /* 0x0094 */ int32_t goal2_count;
    /* 0x0098 */ FName successAction1;
    /* 0x00a0 */ FName successAction2;
    /* 0x00a8 */ FName successAction3;
    /* 0x00b0 */ FName failureAction1;
    /* 0x00b8 */ FName failureAction2;
    /* 0x00c0 */ FName failureAction3;
    /* 0x00c8 */ FName questType;
    /* 0x00d0 */ TArray<FName> questStartUnlocks;
    /* 0x00e0 */ FName questStartWorldEffect;
    /* 0x00e8 */ FName failureMessage;
    /* 0x00f0 */ FName successMessage;
};

// Size: 0x14
struct FQuestGoal {
    /* 0x0000 */ EGoalType goalType;
    /* 0x0004 */ FName Key;
    /* 0x000c */ int32_t countGoal;
    /* 0x0010 */ bool useGlobalRecord;
};

// Size: 0xc
struct FQuestHudState {
    /* 0x0000 */ bool questLogEnabled;
    /* 0x0004 */ int32_t nPendingCompletions;
    /* 0x0008 */ int32_t nTotalMissions;
};

// Size: 0x10
struct FQuestLogHudData {
    /* 0x0000 */ TArray<int32_t> m_activeQuestIds;
};

// Size: 0x8
struct FQuestProgress {
    /* 0x0000 */ int32_t counter;
    /* 0x0004 */ bool isComplete;
};

// Size: 0x378
class UQuestTracker : public UObject {
    /* 0x0028 */ FQuestWorldState m_questWorldState;
    /* 0x02d0 */ TMap<int32_t, FQuestBatchState> m_activeQuests;
    /* 0x0320 */ TSet<FName> m_startedQuests;

    int32_t GetNCompletableQuests() const;
    FQuestUiState GetQuestUiData(int32_t questId);
    FQuestUiState GetQuestUiData_FromDef(const FQuestBatchDef& def);
    bool IsQuestUiStateDifferent(const FQuestUiState& A, const FQuestUiState& B) const;
};

// Size: 0xe8
struct FQuestUiState {
    /* 0x0000 */ int32_t questId;
    /* 0x0008 */ FQuestBatchDef questDef;
    /* 0x00d0 */ TArray<FSubquestUiState> subquestStates;
    /* 0x00e0 */ int32_t daysRemaining;
    /* 0x00e4 */ bool subquestsComplete;
};

// Size: 0x2a8
struct FQuestWorldState {
    /* 0x0000 */ int32_t totalPopulation;
    /* 0x0008 */ TMap<FName, int32_t> buildingCounts;
    /* 0x0058 */ int32_t totalInfluence;
    /* 0x005c */ int32_t influenceToday;
    /* 0x0060 */ FResourceCollection playerResources;
    /* 0x00b0 */ TMap<FName, int32_t> resourceNodesDestroyed;
    /* 0x0100 */ TMap<FName, int32_t> productionTotal;
    /* 0x0150 */ TMap<FName, int32_t> productionToday;
    /* 0x01a0 */ TMap<FName, int32_t> consumptionTotal;
    /* 0x01f0 */ TMap<FName, int32_t> consumptionToday;
    /* 0x0240 */ TMap<FName, int32_t> farmYields;
    /* 0x0290 */ int32_t piratesIgnored;
    /* 0x0294 */ int32_t nDecoratives;
    /* 0x0298 */ int32_t nSlotDecoratives;
    /* 0x029c */ int32_t dayQuestStarted;
    /* 0x02a0 */ int32_t nFullTaxPayments;
};

// Size: 0x50
struct FRadialToolbarCfg {
    /* 0x0000 */ TMap<FName, FToolbarRow_Live> m_toolbars;
};

// Size: 0x28
struct FRadiusData {
    /* 0x0000 */ FIntVector centerPos;
    /* 0x0010 */ UStaticMeshComponent* MeshComponent;
    /* 0x0018 */ int32_t xyRadius;
    /* 0x001c */ int32_t zRadius;
    /* 0x0020 */ ERadiusHighlightRule Rule;
    /* 0x0024 */ FColor Tint;
};

// Size: 0x360
class ARadiusOfEffectRenderer : public AActor {
    /* 0x02a8 */ UMaterialInterface* m_radiusMaterial;
    /* 0x02b0 */ UStaticMesh* m_radiusCube;
    /* 0x02b8 */ TMap<int32_t, FRadiusData> m_data;

    int32_t AddRadiusRender(FIntVector initialPos, int32_t xyRadius, int32_t zRadius, ERadiusHighlightRule Rule, FColor Tint);
    void ClearAllRenders();
    int32_t RemoveRadiusRender(int32_t ID);
};

// Size: 0x280
class URadiusVisualizer : public USceneComponent {
    /* 0x0240 */ UMaterialInterface* m_radiusMaterial;
    /* 0x0248 */ UStaticMeshComponent* m_radiusCube;
};

// Size: 0x10
struct FRailConnectionPoint {
    /* 0x0000 */ FIntVector Pos;
    /* 0x000c */ FDir outDir;
};

// Size: 0x168
class URailStation : public UActorComponent {
    /* 0x00c8 */ float m_dockDuration;
    /* 0x00cc */ float m_passengerExchangeInterval;
    /* 0x00d0 */ FTrainBoostParams m_departureBoostParams;
    /* 0x00dc */ float pathfinderPenalty_5Waiting;
    /* 0x0108 */ FIntVector m_railCell;
    /* 0x0114 */ FIntVector m_platformCell;
    /* 0x0148 */ FMulticastInlineDelegate launchEvent;

    int32_t GetAgentsWaiting() const;
};

// Size: 0xe8
class URailSteamBooster : public UActorComponent {
    /* 0x00b8 */ int32_t steamPerLaunch;
    /* 0x00bc */ FTrainBoostParams boostParams;
    /* 0x00d0 */ FMulticastInlineDelegate boostEvent;
    /* 0x00e0 */ FDir m_boostDir;
};

// Size: 0x430
class ARailSystem : public AActor {
    /* 0x0420 */ UClass* m_debugTrainTemplate;
    /* 0x0428 */ UClass* m_debugTrainCarTemplate;
};

// Size: 0x110
class URailTile : public UActorComponent {
    /* 0x00c0 */ TArray<FRailConnectionPoint> m_connections;
    /* 0x00d0 */ FSimpleSpline m_segmentSpline;
};

// Size: 0x650
class ARailroadTool : public AActor {
    /* 0x03a8 */ bool isDragging;
    /* 0x03ac */ FIntVector dragStartPos;
    /* 0x03b8 */ FIntVector dragEndPos;
    /* 0x03c4 */ FDir m_cursorFacing_player;
    /* 0x03d8 */ FDetailedResourceCost currentCost;
    /* 0x0570 */ UWidgetComponent* m_placementUiWidget;
    /* 0x0578 */ UStaticMesh* m_railPreviewMesh;
    /* 0x05d0 */ UStaticMesh* m_arrowMesh_oneDir;
    /* 0x05d8 */ UStaticMeshComponent* m_arrowViz;
};

// Size: 0x2d8
class ARandomCodeTester : public AActor {
    /* 0x02a8 */ UInstancedStaticMeshComponent* m_ismc;
    /* 0x02b0 */ int32_t SizeX;
    /* 0x02b4 */ int32_t SizeY;
    /* 0x02b8 */ int32_t SizeZ;
    /* 0x02bc */ int32_t xSpace;
    /* 0x02c0 */ int32_t ySpace;
    /* 0x02c4 */ int32_t zSpace;
    /* 0x02c8 */ int32_t perTick;
    /* 0x02cc */ bool runUpdates;
    /* 0x02d0 */ float Scalar;
};

// Size: 0xc
struct FRecentPolicyCost {
    /* 0x0000 */ FName policyKey;
    /* 0x0008 */ int32_t Cost;
};

// Size: 0x430
class URecipeSelectorBox : public UArcoWidgetBase {
    /* 0x0428 */ bool m_isAgentSelectOpen;

    void CloseRecipeSelect();
};

// Size: 0x8
struct FRelaxAgent {
};

// Size: 0x28
struct FRelaxBuildingConfig {
    /* 0x0000 */ FName statToReport;
    /* 0x0008 */ FString agentActionDescription;
    /* 0x0018 */ FName buffToProvide;
    /* 0x0020 */ FName animationToPlay;
};

// Size: 0x140
class URelaxSpot : public UActorComponent {
    /* 0x00f0 */ TArray<FRelaxAgent> m_agentsControlled;
    /* 0x0100 */ int32_t uses;
};

// Size: 0x38
struct FReplayHudState {
    /* 0x0000 */ bool showWindow;
    /* 0x0001 */ bool IsReplaying;
    /* 0x0002 */ bool IsPaused;
    /* 0x0004 */ int32_t currReplayFrame;
    /* 0x0008 */ int32_t maxReplayFrame;
    /* 0x000c */ float replaySpeed;
    /* 0x0010 */ FString replayName;
    /* 0x0020 */ float CurrentTime;
    /* 0x0024 */ float totalTime;
    /* 0x0028 */ bool autoLoadReplay;
    /* 0x0029 */ bool autoFinishReplay;
    /* 0x002a */ bool autoSkipToFrame;
    /* 0x002c */ int32_t skipFrameGoal;
    /* 0x0030 */ bool badReplay;
    /* 0x0031 */ bool skipFlyIn;
    /* 0x0032 */ ELoadBehavior loadBehavior;
};

// Size: 0x150
struct FReportedDeath {
    /* 0x0000 */ FAgentCharacteristics killedAgent;
    /* 0x0138 */ EAgentDeleteReason causeOfDeath;
    /* 0x013c */ FName prevEmployerType;
    /* 0x0144 */ int32_t prevEmployerId;
    /* 0x0148 */ int32_t dayArrived;
    /* 0x014c */ int32_t dayDied;
};

// Size: 0x278
class UResearchLab : public UActorComponent {
    /* 0x00f8 */ FStockpile m_inputStockpile;
    /* 0x0150 */ UWorkerViz* m_workerViz;
    /* 0x0190 */ FWorkerAssignment m_workers;
    /* 0x01d0 */ float m_agentDispatchCooldown;
    /* 0x01e8 */ FMulticastInlineDelegate runningChangedEvent;
    /* 0x01f8 */ FScienceState m_scienceState;
    /* 0x0268 */ float m_powerDrawPerSecond;

    void GlobalResearchStateChanged();
};

// Size: 0x450
class UResearchLabDetails : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FLabHudState ComputeState();
    void CycleTabs(bool tabRight);
    void EndRecipeSelection();
    void EndStockpileSelection();
};

// Size: 0x60
struct FResearchState {
    /* 0x0000 */ FName activeResearch;
    /* 0x0008 */ int32_t activeResearchTier;
    /* 0x000c */ int32_t activeResearchRequiredProgress;
};

// Size: 0x78
struct FResearchSummaryState {
    /* 0x0000 */ int32_t nLabs;
    /* 0x0004 */ int32_t nActiveLabs;
    /* 0x0008 */ float progress;
    /* 0x0010 */ FResearchState ResearchState;
    /* 0x0070 */ int32_t currentTierCycleTime;
};

// Size: 0x10
struct FResidentData_UiData {
    /* 0x0000 */ bool bedAssigned;
    /* 0x0001 */ bool agentPresent;
    /* 0x0002 */ bool isPermanent;
    /* 0x0008 */ APrototype_Agent* agentRef;
};

// Size: 0x260
class UResourceBuilding : public UActorComponent {
    /* 0x00d8 */ bool m_agentsCanPull;
    /* 0x00d9 */ bool m_agentsCanPush;
    /* 0x00da */ bool m_aimCanPull;
    /* 0x00db */ bool m_aimCanPush;
    /* 0x00dc */ bool m_whiteListReceiving;
    /* 0x00e0 */ TSet<FName> m_whitelist;
    /* 0x0130 */ bool m_allowPlayerAccess;
    /* 0x0131 */ bool m_forceEmpty;
    /* 0x0132 */ bool m_allowDropoff;
    /* 0x0133 */ bool m_assignedDropoffOnly;
    /* 0x0138 */ TSet<FName> m_supportedResourceCategories;
    /* 0x0188 */ int32_t m_defaultStorageCapacity;
    /* 0x018c */ int32_t m_scienceCapacity;
    /* 0x0190 */ FIntVector m_entranceInternalCell;
    /* 0x01a0 */ FStockpile m_stockpile;
    /* 0x01f8 */ UWorkerViz* m_workerViz;
    /* 0x0200 */ FWorkerAssignment m_workers;
    /* 0x0220 */ UStockpileRender* m_stockpileVisual;

    FResourceBuilding_HudState CalcHudStruct() const;
    FResourceBuilding_LogisticsTab CalcLogisticsTab() const;
    FResourceBuilding_StorageTab CalcStorageTab() const;
    FResourceCollection GetLogisticsDeficitsAsCollection() const;
};

// Size: 0x70
struct FResourceBuilding_HudState {
    /* 0x0000 */ bool allowReserve;
    /* 0x0008 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory;
    /* 0x0058 */ int32_t m_scienceCapacity;
    /* 0x005c */ int32_t m_totalScience;
    /* 0x0060 */ FWorkerAssignmentData workerInfo;
};

// Size: 0xc0
struct FResourceBuilding_LogisticsTab {
    /* 0x0000 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory_foods;
    /* 0x0050 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory_drygoods;
    /* 0x00a0 */ FWorkerAssignmentData workerInfo;
    /* 0x00b0 */ bool unlockedLogistics;
    /* 0x00b4 */ FName logisticsRequirementCategory;
    /* 0x00bc */ bool m_forceEmpty;
    /* 0x00bd */ bool m_allowDropoff;
    /* 0x00be */ bool m_explicitSourcesOnly;
};

// Size: 0xb8
struct FResourceBuilding_StorageTab {
    /* 0x0000 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory;
    /* 0x0050 */ bool useTotalCapacity;
    /* 0x0054 */ int32_t totalCapacity;
    /* 0x0058 */ int32_t usedCapacity;
    /* 0x0060 */ FResourceCollection inbound;
    /* 0x00b0 */ int32_t totalInbound;
};

// Size: 0x10
struct FResourceCategoryInfo : public FTableRowBase {
    /* 0x0008 */ int32_t SortPriority;
};

// Size: 0x50
struct FResourceCollection {
    /* 0x0000 */ TMap<FName, int32_t> counts;
};

// Size: 0x14
struct FResourceCostDisplay {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ int32_t Cost;
    /* 0x000c */ int32_t bankAmount;
    /* 0x0010 */ bool canAfford;
};

// Size: 0x50
struct FResourceCostDisplayGroup {
    /* 0x0000 */ TArray<FResourceCostDisplay> m_costs;
    /* 0x0010 */ TArray<FResourceCostDisplay> m_constructionPreview;
    /* 0x0020 */ TArray<FResourceCostDisplay> m_supportCosts;
    /* 0x0030 */ TArray<FResourceCostDisplay> m_lostResources;
    /* 0x0040 */ TArray<FResourceCostDisplay> m_salvageResources;
};

// Size: 0x50
struct FResourceDef : public FTableRowBase {
    /* 0x0008 */ FName stringKey;
    /* 0x0010 */ FName descriptionKey;
    /* 0x0018 */ FName Category;
    /* 0x0020 */ FName subCategory;
    /* 0x0028 */ UTexture2D* Icon;
    /* 0x0030 */ UStaticMesh* haulMesh;
    /* 0x0038 */ float stackingHeight;
    /* 0x003c */ int32_t storageVisualWidth;
    /* 0x0040 */ bool isNonPhysical;
    /* 0x0044 */ int32_t baseTradeValue;
    /* 0x0048 */ bool questItem;
    /* 0x004c */ int32_t SortOrder;
};

// Size: 0x60
struct FResourceDelivery {
    /* 0x0000 */ FResourceCollection Resources;
    /* 0x0050 */ FIntVector fallbackSourcePos;
    /* 0x005c */ int32_t fallbackSourceId;
};

// Size: 0x2c8
class AResourceFling : public AActor {

    void HandleSimSpeedChanged(int32_t simSpeed);
};

// Size: 0x60
struct FResourceFlowTracker {
    /* 0x0000 */ TMap<FName, FCircularAverage> m_runningAverages;
    /* 0x0050 */ int32_t m_averagingBucketSizeSeconds;
    /* 0x0054 */ int32_t m_nAverageBuckets;
};

// Size: 0x110
struct FResourceHudState {
    /* 0x0000 */ FResourceCollection playerTrackedResources;
    /* 0x0050 */ int32_t totalFood;
    /* 0x0054 */ int32_t totalRawFood;
    /* 0x0058 */ int32_t totalCookedFood;
    /* 0x005c */ int32_t estimatedFoodConsumption;
    /* 0x0060 */ int32_t totalDrink;
    /* 0x0064 */ int32_t estimatedDrinkConsumption;
    /* 0x0068 */ TMap<FName, int32_t> baseResourceCounts;
    /* 0x00b8 */ TMap<FName, float> resourceRecentDeltas;
    /* 0x0108 */ bool bCopperUnlocked;
    /* 0x0109 */ bool bIronUnlocked;
};

// Size: 0x3d8
class AResourceMarkingTool : public AActor {
    /* 0x02b0 */ EResourceMarkingType m_resourceType;
    /* 0x02b8 */ UClass* m_overlayWidgetClass;
};

// Size: 0x490
class UResourceMarkingViz : public USceneComponent {
    /* 0x0240 */ FGridInstaMesh m_resourceMarkingToolMeshes;
    /* 0x0360 */ UMaterialInstance* m_matChoppingToolAdd;
    /* 0x0368 */ UMaterialInstance* m_matChoppingToolRemove;
    /* 0x0370 */ UMaterialInstance* m_matForagingToolAdd;
    /* 0x0378 */ UMaterialInstance* m_matForagingToolRemove;
    /* 0x0380 */ UStaticMesh* ToolMesh;
};

// Size: 0x340
class UResourceSpendMsgBlip : public UUserWidget {

    void SetOpacity(float Opacity);
    void SetResources(FResourceCollection Resources);
};

// Size: 0x1c
struct FResourceStockpileSlot {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t capacity;
    /* 0x0008 */ int32_t minHold;
    /* 0x000c */ int32_t playerReserveCount;
    /* 0x0010 */ int32_t reservedForPickup;
    /* 0x0014 */ int32_t reservedSpaceForDropoff;
    /* 0x0018 */ bool whitelisted;
};

// Size: 0x60
struct FResourceStockpileSubcategory {
    /* 0x0000 */ FName owningCategory;
    /* 0x0008 */ TMap<FName, FResourceStockpileSlot> Slots;
    /* 0x0058 */ int32_t totalCount;
};

// Size: 0x10
struct FRestroomAgent {
};

// Size: 0x620
class URoofMeshComponent : public UStaticMeshComponent {
};

// Size: 0x368
class ARoofSystem : public AActor {
    /* 0x02a8 */ UMaterialInterface* m_transparentRoofMat;
};

// Size: 0x18
struct FSavedGridActor {
    /* 0x0000 */ FName Actor;
    /* 0x0008 */ FIntVector Pos;
    /* 0x0014 */ uint8_t Facing;
};

// Size: 0x520
class AScaffoldRenderer : public AActor {
    /* 0x02a8 */ UStaticMesh* m_standardSupportMesh;
    /* 0x02b0 */ UMaterialParameterCollection* m_sliceParamsRef;
    /* 0x02b8 */ UInstancedStaticMeshComponent* m_meshes;
    /* 0x02c0 */ UInstancedStaticMeshComponent* m_burnedMeshes;
    /* 0x02c8 */ float m_renderedSliceHeight;
    /* 0x02cc */ float m_targetRenderheight;

    void HandleSimSpeedChanged(int32_t simSpeed);
};

// Size: 0x90
struct FScenarioDefinitionRow : public FTableRowBase {
    /* 0x0008 */ FArcoScenario scenarioData;
};

// Size: 0x20
struct FScenarioEventCalendar {
    /* 0x0000 */ TArray<FEventBatch> Days;
    /* 0x0010 */ TArray<FScenarioQuestStart> initialQuests;
};

// Size: 0xc
struct FScenarioQuestStart {
    /* 0x0000 */ FName Quest;
    /* 0x0008 */ float TimeDelay;
};

// Size: 0x448
class USchoolDetails : public UArcoView {

    FSchoolHudState ComputeState();
    void UpdateEducationRequirement(EAgentEducation newRequirement);
};

// Size: 0x30
struct FSchoolHudState {
    /* 0x0000 */ FWorkerAssignmentData agentsInfo;
    /* 0x0010 */ bool bGiftedTeacher;
    /* 0x0011 */ EAgentEducation teacherEducation;
    /* 0x0012 */ EAgentEducation educationTarget;
    /* 0x0013 */ bool bTeachingGuild;
    /* 0x0014 */ FName teacherGuild;
    /* 0x001c */ bool disabledByPlayer;
    /* 0x001d */ bool overtimeHours;
    /* 0x0020 */ int32_t overtimeCost;
    /* 0x0024 */ bool canAffordOvertime;
    /* 0x0028 */ float remainingOvertime;
};

// Size: 0x14
struct FScienceResourceSlot {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ int32_t hpLeft;
    /* 0x000c */ int32_t hpMax;
    /* 0x0010 */ bool Active;
};

// Size: 0x70
struct FScienceState {
    /* 0x0000 */ TArray<FScienceResourceSlot> tierResourceSlots;
    /* 0x0010 */ bool isResearchActive;
    /* 0x0018 */ FResourceCollection m_currentTierResourceRequests;
    /* 0x0068 */ int32_t tierIndexRequired;
    /* 0x006c */ float productionInterval_timePassed;
};

// Size: 0x10
struct FScrollClickSoundState {
    /* 0x0000 */ int32_t nTotalTickDelta;
    /* 0x0004 */ float cooldownTimer;
    /* 0x0008 */ float secondsPerCooldown;
    /* 0x000c */ float pitchShiftScale;
};

// Size: 0x38
struct FSeasonDefinition : public FTableRowBase {
    /* 0x0008 */ FString Label;
    /* 0x0018 */ UTexture2D* Icon;
    /* 0x0020 */ FName SeasonLengthDaysSystemTune;
    /* 0x0028 */ FLinearColor associatedUiColor;
};

// Size: 0x50
struct FSeasonSummary {
    /* 0x0000 */ int32_t daysIntoSeason;
    /* 0x0004 */ int32_t daysInSeason;
    /* 0x0008 */ FName season;
    /* 0x0010 */ FSeasonDefinition seasonData;
    /* 0x0048 */ int32_t currentTemp;
    /* 0x004c */ int32_t currentHeat;
};

// Size: 0x630
class ASelectTool : public AActor {
    /* 0x02b0 */ UClass* m_assignableDockWidgetClass;
    /* 0x0308 */ UClass* m_workshipAssignmentOverlayClass;
    /* 0x0318 */ UClass* m_houseAssignmentOverlayClass;
    /* 0x0320 */ UClass* m_indAssignmentOverlayClass;
    /* 0x0338 */ UClass* m_housingWidgetClass;
    /* 0x03a8 */ UClass* m_industryWidgetClass;
    /* 0x0418 */ FMulticastInlineDelegate OnHudActionDelegate;
    /* 0x0428 */ UClass* m_agentDetailsClass;
    /* 0x0430 */ UContextualHoverWidgetComponent* m_buildingDetailsHoverWidget;
    /* 0x0438 */ AGridActor* m_gridActorAtGridPos;
    /* 0x0440 */ APrototype_Agent* m_agentAtPos;
    /* 0x0448 */ AActor* m_currentlyHighlightedActor;
    /* 0x0450 */ AGridActor* m_currentlySelectedGridActor;
    /* 0x0458 */ APrototype_Agent* m_currentlySelectedAgent;
    /* 0x0480 */ APrototype_Agent* m_currentlyPickedUpAgent;
    /* 0x0498 */ UArcoView* m_activeDetailWidget;
    /* 0x04a0 */ FIntVector m_gridPos;
    /* 0x0510 */ FMulticastInlineDelegate OnHousingSelectEnded;
    /* 0x0520 */ FMulticastInlineDelegate OnIndustrySelectEnded;

    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0x2c0
class UServiceRange : public USceneComponent {
    /* 0x0240 */ int32_t m_gridRadius;
    /* 0x0244 */ int32_t m_maxGridRadius;
    /* 0x0248 */ int32_t m_minGridRadius;
    /* 0x0250 */ TSet<FName> m_associatedServices;
    /* 0x02a0 */ UClass* m_rangeVizActorClass;
};

// Size: 0xc
struct FServiceRangeCfg {
    /* 0x0000 */ int32_t gridRadius;
    /* 0x0004 */ int32_t maxGridRadius;
    /* 0x0008 */ int32_t minGridRadius;
};

// Size: 0x10
struct FSettings_AudioTab {
    /* 0x0000 */ TArray<FOptionChoice> optionChoices;
};

// Size: 0x10
struct FSettings_GameplayTab {
    /* 0x0000 */ TArray<FOptionChoice> optionChoices;
};

// Size: 0x10
struct FSettings_GraphicsTab {
    /* 0x0000 */ TArray<FOptionChoice> optionChoices;
};

// Size: 0x10
struct FSettings_KeybindsTab {
    /* 0x0000 */ TArray<FOptionChoice> optionChoices;
};

// Size: 0x10
struct FSettings_ModTab {
    /* 0x0000 */ TArray<FOptionChoice> optionChoices;
};

// Size: 0x18
struct FShipData_Colonists {
    /* 0x0000 */ TArray<FPurchaseableColonist> arrivalsData;
    /* 0x0010 */ int32_t extraCostPerAcceptance;
};

// Size: 0x58
struct FShipData_EmbarkResources {
    /* 0x0000 */ FResourceCollection reward;
    /* 0x0050 */ int32_t supplyCost;
};

// Size: 0x60
struct FShipData_PirateShip {
    /* 0x0000 */ int32_t totalCanonballs;
    /* 0x0004 */ int32_t totalDue;
    /* 0x0008 */ FPaymentBreakdown paymentState;
};

// Size: 0x60
struct FShipData_SmugglerTraderShip {
    /* 0x0000 */ FPaymentBreakdown paymentState;
    /* 0x0058 */ int32_t totalGoldAvailable;
};

// Size: 0x58
struct FShipData_TaxShip {
    /* 0x0000 */ FPaymentBreakdown paymentState;
};

// Size: 0x60
struct FShipExportCfg {
    /* 0x0000 */ bool Enabled;
    /* 0x0004 */ int32_t percentThreshold;
    /* 0x0008 */ int32_t maxThreshold;
    /* 0x0010 */ TMap<FName, FAutoExportResourceCfg> m_perResourceConfigs;
};

// Size: 0x14
struct FShipScheduleConfig {
    /* 0x0000 */ int32_t dayFirstArrival;
    /* 0x0004 */ int32_t baseDayInterval;
    /* 0x0008 */ int32_t maxRandomDayDelay;
    /* 0x000c */ float baseTimeOfDay;
    /* 0x0010 */ bool skipWinters;
};

// Size: 0xc0
struct FShipTracker {
    /* 0x0000 */ int32_t m_dayIndexThatArrivalVariancesCanBegin;
    /* 0x0008 */ TMap<EShipType, FShipScheduleConfig> m_shipSpawnScheduleConfig;
};

// Size: 0x28
struct FShipWithVisual {
};

// Size: 0x10
struct FShipsForDay {
    /* 0x0000 */ TArray<FDockableShipData> m_shipsArrivingToday;
};

// Size: 0x50
struct FSimAction {
    /* 0x0000 */ ESimAction SimAction;
    /* 0x0004 */ FName nameKey;
    /* 0x000c */ FIntVector gridPos;
    /* 0x0018 */ FVector worldPos;
    /* 0x0030 */ int32_t IntValue;
    /* 0x0034 */ float FloatValue;
    /* 0x0038 */ FString StringValue;
    /* 0x0048 */ bool boolValue;
};

// Size: 0x20
struct FSimFrame {
    /* 0x0000 */ float timeSinceLastFrame;
    /* 0x0008 */ TArray<FSimAction> actionsForFrame;
    /* 0x0018 */ int32_t debug_currentSeed;
};

// Size: 0x28
struct FSimHistory {
    /* 0x0000 */ TArray<FSimFrame> Frames;
    /* 0x0010 */ float replayLen;
    /* 0x0014 */ uint32_t replayVersion;
};

// Size: 0x20
struct FSimLoadCfg {
    /* 0x0000 */ FString replayName;
    /* 0x0010 */ bool autoFinishReplay;
    /* 0x0011 */ bool autoSkipToFrame;
    /* 0x0014 */ int32_t frameToSkipTo;
    /* 0x0018 */ EArcoGameType gameTypeToLoad;
    /* 0x0019 */ ESaveLocation saveLocation;
    /* 0x001a */ bool skipIntro;
};

// Size: 0x30
struct FSimpleSpline {
    /* 0x0000 */ TArray<FSimpleSplinePoint> m_points;
    /* 0x0014 */ bool m_looping;
};

// Size: 0x20
struct FSimpleSplinePoint {
    /* 0x0000 */ FVector position;
};

// Size: 0x390
class ASimpleTerrainPropRenderer : public AActor {
    /* 0x02a8 */ UStaticMesh* GrassMesh;
    /* 0x02b0 */ FInstaMeshConfig m_meshCfg;
    /* 0x02c0 */ bool m_enabled;
    /* 0x02c8 */ FVector m_propScale;
};

// Size: 0x58
struct FSlideAgentState {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0028 */ FVector destination;
};

// Size: 0x78
struct FSlideData {
    /* 0x0000 */ FIntVector topCell;
    /* 0x0010 */ FVector topCellPassPoint;
    /* 0x0028 */ FIntVector topCellLanding;
    /* 0x0034 */ FIntVector bottomCell;
    /* 0x0040 */ FVector bottomCellPassPoint;
    /* 0x0058 */ FIntVector bottomCellLanding;
    /* 0x0068 */ TArray<FSlideAgentState> ownedAgents;
};

// Size: 0x28
struct FSlotDecorative : public FTableRowBase {
    /* 0x0008 */ FString LocKey;
    /* 0x0018 */ UClass* decorativeActor;
    /* 0x0020 */ EDecorativeSlotPos desiredSubSlot;
    /* 0x0021 */ ENodeBoundary pathingEffect;
};

// Size: 0x230
struct FSmugglerTraderShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ TArray<FTradeRow> tradeRows;
    /* 0x01c8 */ FResourceCollection loadedResources;
    /* 0x0218 */ int32_t goldEarned;
    /* 0x021c */ int32_t totalLoadedValue;
    /* 0x0220 */ int32_t goldBarValue;
    /* 0x0224 */ float valueLoadedAsFractionalGoldBars;
    /* 0x0228 */ bool canShip;
};

// Size: 0x10
struct FSoundLookupRow : public FTableRowBase {
    /* 0x0008 */ USoundBase* Sound;
};

// Size: 0x2b8
class ASpatialCursor : public AActor {
    /* 0x02a8 */ UStaticMeshComponent* cursorMeshRenderer;
    /* 0x02b0 */ UHeightVisualizer* m_heightVisualizer;
};

// Size: 0x2d0
class ASpatialTextPool : public AActor {
    /* 0x02a8 */ UClass* WidgetClass;
};

// Size: 0x340
class USpatialTextWidget : public UUserWidget {

    void SetAsNumber(float Number, FColor Color);
    void SetAsString(FString String, FColor Color);
};

// Size: 0x18
struct FStairAgentState {
    /* 0x0000 */ APrototype_Agent* Agent;
};

// Size: 0x20
struct FStairConfig {
    /* 0x0000 */ int32_t m_horizontalLength;
    /* 0x0004 */ float m_stairBaseSpeed;
    /* 0x0008 */ float m_bounceAnimationRange;
    /* 0x000c */ bool m_allowCarts;
    /* 0x0010 */ float m_entryCooldown;
    /* 0x0014 */ float m_rightHandTravelOffset;
    /* 0x0018 */ float traversalCostUpward;
    /* 0x001c */ float traversalCostDownward;
};

// Size: 0xd8
struct FStairData {
    /* 0x0000 */ FIntVector topCell;
    /* 0x0010 */ FVector topCellPassPoint;
    /* 0x0028 */ FIntVector topCellLanding;
    /* 0x0050 */ FIntVector bottomCell;
    /* 0x0060 */ FVector bottomCellPassPoint;
    /* 0x0078 */ FIntVector bottomCellLanding;
    /* 0x00a0 */ TArray<FStairAgentState> travellingAgents;
    /* 0x00b0 */ TArray<FStairAgentState> pendingAscendingAgents;
    /* 0x00c0 */ TArray<FStairAgentState> pendingDescendingAgents;
};

// Size: 0xb0
struct FStatEntity {
    /* 0x0000 */ FEntityStatsForDay liveStats;
    /* 0x00a0 */ TArray<FEntityStatsForDay> historicStats;
};

// Size: 0x10
struct FStaticMeshLookupRow : public FTableRowBase {
    /* 0x0008 */ UStaticMesh* Mesh;
};

// Size: 0x20
struct FStationNode {
};

// Size: 0x88
class UStatisticsTracker : public UObject {
    /* 0x0028 */ TMap<int32_t, FStatEntity> m_entities;
    /* 0x0078 */ TArray<FCombinedStatsForDay> m_combinedStatsHistory;

    FEntityStatsForDay GetEntityStatsForDay(int32_t EntityID, int32_t daysAgo) const;
    FCombinedStatsForDay GetStatsForDaysIntoPast(int32_t nDaysAgo) const;
};

// Size: 0x38
struct FStats_approvalInfo {
    /* 0x0000 */ FPublicOpinionBreakdown ApprovalBreakdown;
    /* 0x0018 */ TArray<FThoughtTracker> sortedPosThoughts;
    /* 0x0028 */ TArray<FThoughtTracker> sortedNegThoughts;
};

// Size: 0x18
struct FStats_debtInfo {
    /* 0x0000 */ TArray<FTax> debts;
    /* 0x0010 */ int32_t totalDebt;
    /* 0x0014 */ int32_t daysUntilTax;
};

// Size: 0x50
struct FStats_resourcesInfo {
    /* 0x0000 */ TMap<EStatResourceFlowType, FResourceCollection> m_resourceFlows;
};

// Size: 0x58
struct FStockpile {
    /* 0x0008 */ TMap<FName, FResourceStockpileSlot> Slots;
};

// Size: 0x28
class IStockpileInterface : public UInterface {
};

// Size: 0x158
class UStockpileLinker : public UActorComponent {
    /* 0x00b8 */ TSet<int32_t> m_sourceStockpileIds;
    /* 0x0108 */ TSet<int32_t> m_destStockpileIds;
};

// Size: 0x40
struct FStockpileLinkerUiStruct {
    /* 0x0000 */ FString sourcelinkageString;
    /* 0x0010 */ TArray<int32_t> sourceStockpileIds;
    /* 0x0020 */ FString destLinkageString;
    /* 0x0030 */ TArray<int32_t> destStockpileIds;
};

// Size: 0x2c0
class UStockpileRender : public USceneComponent {
    /* 0x0240 */ bool alwaysRenderOnAssign;
    /* 0x029c */ int32_t nSlotsX;
    /* 0x02a0 */ int32_t nSlotsY;
    /* 0x02a4 */ int32_t nSlotsZ;

    void DebugDrawSpaces();
};

// Size: 0x18
struct FStringRow : public FTableRowBase {
    /* 0x0008 */ FString String;
};

// Size: 0x568
class AStructureDoorwayRenderer : public AActor {
    /* 0x02a8 */ UInstancedStaticMeshComponent* m_doorwayRenderer;
    /* 0x0358 */ UInstancedStaticMeshComponent* m_waterAdapterRenderer;
    /* 0x0408 */ UInstancedStaticMeshComponent* m_steamAdapterRenderer;
    /* 0x04b8 */ TMap<AGridActor*, FGridActorDoorwayRender> m_renders;
    /* 0x0558 */ float m_entrancVisOffset;
    /* 0x055c */ float m_entranceVisOffset_Z;
};

// Size: 0x30
struct FSubquestUiState {
    /* 0x0000 */ int32_t Count;
    /* 0x0004 */ int32_t countGoal;
    /* 0x0008 */ EGoalType goalType;
    /* 0x0010 */ FString translatedUnitKey;
    /* 0x0020 */ UTexture2D* Icon;
    /* 0x0028 */ bool showProgress;
    /* 0x0029 */ bool completed;
};

// Size: 0x28
class ISunlightListener : public UInterface {
};

// Size: 0x60
struct FSupplyShipChoice {
    /* 0x0000 */ FResourceCollection Resources;
    /* 0x0050 */ int32_t Cost;
    /* 0x0054 */ bool isRejectChoice;
    /* 0x0058 */ int32_t rejectionCost;
};

// Size: 0x18
struct FSupplyShipState {
    /* 0x0000 */ TArray<FSupplyShipChoice> choices;
    /* 0x0010 */ int32_t choiceIdx;
    /* 0x0014 */ bool winterPenalty;
};

// Size: 0x1c0
struct FSupplyShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ bool isEmbarkMode;
};

// Size: 0x1b8
struct FSupplyTradeShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
};

// Size: 0x3
struct FSupportedImprovements {
    /* 0x0000 */ bool usesPowerBox;
    /* 0x0001 */ bool usesVentilation;
    /* 0x0002 */ bool usesPlumbing;
};

// Size: 0x3
struct FSupportedImprovementsState {
    /* 0x0000 */ bool hasPowerBox;
    /* 0x0001 */ bool hasVentilation;
    /* 0x0002 */ bool hasPlumbing;
};

// Size: 0xc
struct FSurveyButton {
    /* 0x0000 */ FName oreType;
    /* 0x0008 */ int32_t oreIdx;
};

// Size: 0x18
struct FSurveyInfo {
    /* 0x0000 */ TArray<FSurveyButton> surveyButtons;
    /* 0x0010 */ int32_t currentButtonIdx;
};

// Size: 0x10
struct FSystemTuneRow : public FTableRowBase {
    /* 0x0008 */ float FloatValue;
};

// Size: 0x10
struct FTax {
    /* 0x0000 */ FName nameKey;
    /* 0x0008 */ int32_t amount;
    /* 0x000c */ int32_t pendingDelta;
};

// Size: 0x58
struct FTaxExportResult : public FTableRowBase {
    /* 0x0008 */ float percentForReward;
    /* 0x000c */ int32_t trustDelta;
    /* 0x0010 */ int32_t diplomacyDelta;
    /* 0x0014 */ FName giftPoolKey;
    /* 0x001c */ int32_t nGifts;
    /* 0x0020 */ FString binLabel;
    /* 0x0030 */ FString binAcceptKey;
    /* 0x0040 */ UTexture2D* binIcon;
    /* 0x004c */ float startPercentage;
    /* 0x0050 */ float percentageSpan;
};

// Size: 0x150
class UTaxOffice : public UActorComponent {
    /* 0x00e0 */ FWorkerAssignment m_workers;
    /* 0x0100 */ UWorkerViz* m_workerViz;

    bool AssignWorkerToSlot(int32_t Slot, APrototype_Agent* Agent);
    bool FireSpecificWorker(APrototype_Agent* Agent);
};

// Size: 0x100
struct FTaxOfficeUiState {
    /* 0x0000 */ FWorkerAssignmentData agentsInfo;
    /* 0x0010 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x0050 */ bool controlsUnlocked;
    /* 0x0058 */ FAutoExportState taxExportsState;
    /* 0x00a8 */ TMap<FName, int32_t> liveCounts;
    /* 0x00f8 */ bool anyTaxResourcesEnabled;
    /* 0x00f9 */ bool anyPirateResourcesEnabled;
};

// Size: 0x2f0
struct FTaxShip_UiState {
    /* 0x0000 */ FDockableShipData dockedShipState;
    /* 0x01b8 */ TArray<FTradeRow> warehouseTradeRows;
    /* 0x01c8 */ FResourceCollection loadedResources;
    /* 0x0218 */ TArray<FTax> debts;
    /* 0x0228 */ int32_t totalDebt;
    /* 0x022c */ bool allowOverpayment;
    /* 0x0230 */ int32_t currentStanding;
    /* 0x0234 */ int32_t maxStanding;
    /* 0x0238 */ bool dangerOfLosing;
    /* 0x0240 */ FString standingString;
    /* 0x0250 */ bool canShip;
    /* 0x0254 */ int32_t nTradeBin;
    /* 0x0258 */ FString currentTradeBinKey;
    /* 0x0268 */ FString currentTradeBin_ButtonKey;
    /* 0x0278 */ int32_t trustToGain;
    /* 0x027c */ int32_t diplomacyToGain;
    /* 0x0280 */ int32_t nGiftsGiven;
    /* 0x0288 */ TArray<FTaxExportResult> progressBins;
    /* 0x0298 */ bool autopayEnabled;
    /* 0x029c */ int32_t autopayPercentGoal;
    /* 0x02a0 */ FResourceCollection inboundResources;
};

// Size: 0x58
struct FTaxState {
    /* 0x0054 */ bool m_taxesPaidToday;
};

// Size: 0xd0
struct FTaxTradeInformation {
    /* 0x0000 */ TArray<FName> supportedResources;
    /* 0x0010 */ TSet<FName> highDemandResources;
    /* 0x0060 */ TSet<FName> lowDemandResources;
    /* 0x00b0 */ TArray<FName> supportedResources_pirates;
    /* 0x00c0 */ TArray<FName> supportedResources_smuggler;
};

// Size: 0x40
struct FTechCardState {
    /* 0x0000 */ FName techKey;
    /* 0x0008 */ FString nameKey;
    /* 0x0018 */ int32_t Cost;
    /* 0x001c */ int32_t tier;
    /* 0x0020 */ ETechCardSlotType cardType;
    /* 0x0028 */ TArray<FString> missingPrerequisites;
    /* 0x0038 */ bool isActiveResearch;
};

// Size: 0x30
struct FTechCategoryState {
    /* 0x0000 */ UTexture2D* headerIcon;
    /* 0x0008 */ FString headerKey;
    /* 0x0018 */ TArray<FTechCardState> columnData;
};

// Size: 0xc
struct FTechSummary {
    /* 0x0000 */ FName currentResearch;
    /* 0x0008 */ float percentComplete;
};

// Size: 0x18
struct FTechTier {
    /* 0x0000 */ TArray<FName> associatedInputs;
    /* 0x0010 */ float timerPerFullCycle;
};

// Size: 0x20
struct FTechTreeCategory_Hud {
    /* 0x0000 */ FString categoryTitle;
    /* 0x0010 */ TArray<FTechTreeRowData_Hud> techs;
};

// Size: 0x48
struct FTechTreeLayout {
    /* 0x0000 */ FTechCategoryState tiers;
    /* 0x0030 */ TArray<FTechCategoryState> Categories;
    /* 0x0040 */ int32_t scienceCount;
    /* 0x0044 */ int32_t scienceCapacity;
};

// Size: 0x38
struct FTechTreeRowData_Hud {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ FString Description;
    /* 0x0020 */ FName Category;
    /* 0x0028 */ int32_t Cost;
    /* 0x002c */ bool isUnlocked;
    /* 0x002d */ bool canBuy;
    /* 0x0030 */ FName unlockKey;
};

// Size: 0x68
struct FTechTreeState_Hud {
    /* 0x0000 */ int32_t nScienceFacilities;
    /* 0x0004 */ int32_t nScienceArchives;
    /* 0x0008 */ FResearchState ResearchState;
};

// Size: 0xa8
struct FTechUnlock_V2 : public FTableRowBase {
    /* 0x0008 */ bool useGridActorForLoc;
    /* 0x0010 */ FString Title;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ bool demoLocked;
    /* 0x0031 */ bool isHidden;
    /* 0x0038 */ FString faction;
    /* 0x0048 */ FString subCategory;
    /* 0x0058 */ bool giftableInDemo;
    /* 0x0059 */ bool giftable;
    /* 0x005c */ int32_t giftPool;
    /* 0x0060 */ bool researchable;
    /* 0x0064 */ int32_t scienceCost;
    /* 0x0068 */ int32_t researchTier;
    /* 0x006c */ bool unlockedByDefault;
    /* 0x0070 */ TArray<FName> childUnlocks;
    /* 0x0080 */ FName associatedGridActor;
    /* 0x0088 */ TArray<FName> prerequisiteUnlocks;
    /* 0x0098 */ int32_t tierSortOrder;
    /* 0x009c */ FName associatedRecipe;
    /* 0x00a4 */ bool isQuestRelated;
};

// Size: 0xc
struct FTemperatureWidgetState {
    /* 0x0000 */ uint8_t heat;
    /* 0x0004 */ int32_t temp;
    /* 0x0008 */ EBuildingHeatThreshold heatThreshold;
};

// Size: 0x278
class UTerraformBuilding : public UActorComponent {
    /* 0x00d8 */ FResourceCollection m_costPerCell;
    /* 0x0134 */ float m_timeToMakeBlock;
    /* 0x0138 */ float m_buildTimeRemaining;
    /* 0x0178 */ FWorkerAssignment m_workers;
    /* 0x0198 */ UWorkerViz* m_workerViz;
    /* 0x01a0 */ FStockpile m_storageStockpile;
    /* 0x0238 */ UStockpileRender* m_stockpileVisual;
    /* 0x0250 */ FMulticastInlineDelegate m_terraformCompletedEvent;
};

// Size: 0x138
struct FTerraformBuildingUIState {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FStockpile Stockpile;
    /* 0x0068 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x00a8 */ ETerraformerState terraformerState;
    /* 0x00ac */ float timePerPlace;
    /* 0x00b0 */ float TimeRemaining;
    /* 0x00b8 */ FResourceCollection Cost;
    /* 0x0108 */ FVector targetCell;
    /* 0x0120 */ float productivity;
    /* 0x0124 */ bool disabledByPlayer;
    /* 0x0125 */ bool overtimeHours;
    /* 0x0128 */ int32_t overtimeCost;
    /* 0x012c */ bool canAffordOvertime;
    /* 0x0130 */ float remainingOvertime;
};

// Size: 0xc8
struct FTerraformCampUIState {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FStockpile Stockpile;
    /* 0x0068 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x00a8 */ bool m_overtimeEnabled;
    /* 0x00ac */ int32_t overtimeCost;
    /* 0x00b0 */ bool canAffordOvertime;
    /* 0x00b4 */ float remainingOvertime;
    /* 0x00b8 */ bool disabledByPlayer;
    /* 0x00bc */ FServiceRangeCfg serviceRangeInfo;
};

// Size: 0x1d8
class UTerraformCell : public UActorComponent {
    /* 0x0120 */ bool m_isTopperCell;
    /* 0x0128 */ AGridActor* m_ownerOrChildGridActor;
    /* 0x01b0 */ int32_t nCyclesRequired;
    /* 0x01b4 */ float workTimePerCycle;
    /* 0x01c8 */ FMulticastInlineDelegate progressEvent;
};

// Size: 0x408
class ATerraformTool : public AActor {
    /* 0x02b0 */ UMaterialInterface* startRemovingCursorMat;
    /* 0x02b8 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x02c0 */ UClass* m_terraformOverlayWidgetClass;
    /* 0x02e0 */ UTerraformToolWidgetComponent* m_toolWidget;

    FTerraformToolInfo GetInfo() const;
    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0x4
struct FTerraformToolInfo {
    /* 0x0000 */ int32_t cellCount;
};

// Size: 0x6d0
class UTerraformToolWidgetComponent : public UWidgetComponent {
};

// Size: 0x560
class UTerraformViz : public USceneComponent {
    /* 0x02e0 */ FGridInstaMesh m_TerraformToolMeshes;
    /* 0x0400 */ FGridInstaMesh m_TerraformPlacementMeshes;
    /* 0x0520 */ UMaterialInstance* m_TerraformToolMaterialSet;
    /* 0x0528 */ UMaterialInstance* m_TerraformToolMaterialUnset;
    /* 0x0530 */ UMaterialInstance* m_TerraformToolMaterialInvalid;
    /* 0x0538 */ UMaterialInstance* m_TerraformPlacementMaterial;
    /* 0x0540 */ TArray<UStaticMesh*> Meshes;
};

// Size: 0x408
class ATerrainTool : public AActor {
    /* 0x02b0 */ UStaticMesh* m_terrainMeshClass;
    /* 0x02b8 */ UStaticMesh* m_oreMeshClass;
    /* 0x02c0 */ UClass* m_controlsWidgetClass;
    /* 0x02c8 */ UArcoWidgetBase* m_controlWidget;
    /* 0x02d0 */ UStaticMeshComponent* m_towerMesh;
    /* 0x02d8 */ UStaticMeshComponent* m_brushMesh;

    void ReceiveHudAction(FHudAction HudAction);
};

// Size: 0xc
struct FTerrainToolHudState {
    /* 0x0000 */ FName selectedTerrainType;
    /* 0x0008 */ bool isHeightmapMode;
};

// Size: 0x430
class UThoughtOverviewWidget : public UArcoWidgetBase {
    /* 0x0428 */ FName currentFilter;

    static void DrawLines(UObject* WorldContext, const FThoughtTracker& Info);
    static TArray<FThoughtTracker> GetSortedGlobalThoughts(bool positiveThoughts);
};

// Size: 0xb0
struct FThoughtTracker {
    /* 0x0000 */ FName thoughtKey;
    /* 0x0008 */ FAgentThought thoughtData;
    /* 0x0048 */ int32_t nInstances;
    /* 0x0050 */ TArray<APrototype_Agent*> agentsWithThought;
    /* 0x0060 */ TMap<int32_t, int32_t> ExpectationStars;
};

// Size: 0x38
struct FTimeHudState {
    /* 0x0000 */ float CurrentTime;
    /* 0x0004 */ float TimeUntilNextPhase;
    /* 0x0008 */ float lengthOfCurrentPhase;
    /* 0x000c */ EDayPhase CurrentPhase;
    /* 0x0010 */ float timeOfWorkDay;
    /* 0x0014 */ float timeOfSunset;
    /* 0x0018 */ float timeofSunrise;
    /* 0x001c */ float morningLen;
    /* 0x0020 */ float workdayLen;
    /* 0x0024 */ float nightLen;
    /* 0x0028 */ int32_t day;
    /* 0x002c */ int32_t gameplaySpeed;
    /* 0x0030 */ bool IsPaused;
    /* 0x0031 */ bool isTimeOfDayPaused;
    /* 0x0032 */ bool isPausedByEod;
    /* 0x0034 */ int32_t daysTillNextSeason;
};

// Size: 0x10
struct FTimelineDay {
    /* 0x0000 */ TArray<FLiveTimelineEvent> timelineEvents;
};

// Size: 0x10
struct FTimelineDaySummary {
    /* 0x0000 */ int32_t temperature;
    /* 0x0004 */ uint8_t heat;
    /* 0x0008 */ FName weather;
};

// Size: 0x78
struct FTimelineEventDef : public FTableRowBase {
    /* 0x0008 */ ETimelineEventType EventType;
    /* 0x0010 */ FString Name;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ UTexture2D* Icon;
    /* 0x0038 */ USoundBase* audioCue;
    /* 0x0040 */ TArray<FEventChoiceV2> choices;
    /* 0x0050 */ FName contextualKey;
    /* 0x0058 */ float autoExpireTotal;
    /* 0x005c */ bool autoPresentEvent;
    /* 0x0060 */ FName Quest;
    /* 0x0068 */ int32_t contextualInt;
    /* 0x006c */ float autoExpireRemaining;
};

// Size: 0x20
struct FTimelineSummary {
    /* 0x0000 */ FTimelineDaySummary currentDay;
    /* 0x0010 */ TArray<FTimelineDaySummary> forecast;
};

// Size: 0x4b0
class UToolbar : public UArcoWidgetBase {
    /* 0x0428 */ FMulticastInlineDelegate UnselectEvent;

    void ClearToolbarTooltip();
    void SetToolbarTooltip(FToolbarItem_Live correspondingToolbarItem);
    void UpdateUiFromData(const TMap<FName, FToolbarRow_Live>& toolbars, const TArray<FName>& currentHeirarchy);
};

// Size: 0x18
struct FToolbarConfiguration : public FTableRowBase {
    /* 0x0008 */ TArray<FToolbarItemConfiguration> toolbarItems;
};

// Size: 0xc8
struct FToolbarItemConfiguration {
    /* 0x0000 */ EToolbarItemType ItemType;
    /* 0x0004 */ FName itemKey;
    /* 0x0010 */ FString LocKey;
    /* 0x0020 */ UTexture2D* Icon;
    /* 0x0028 */ FHudAction HudAction;
    /* 0x0080 */ FName categoryToOpen;
    /* 0x0088 */ FName gridActorGroup;
    /* 0x0090 */ FName gridActorName;
    /* 0x0098 */ FName RequiredUnlock;
    /* 0x00a0 */ bool hideIfLocked;
    /* 0x00a1 */ bool shouldTintIcon;
    /* 0x00a8 */ FString hotkeyStr;
    /* 0x00b8 */ bool showInWheel;
    /* 0x00bc */ FName customTooltip;
    /* 0x00c4 */ EArco_PlayerVerb associatedShortcutVerb;
};

// Size: 0xd8
struct FToolbarItem_Live {
    /* 0x0000 */ FName toolbarItemKey;
    /* 0x0008 */ FName owningToolbar;
    /* 0x0010 */ EToolbarItemType ItemType;
    /* 0x0011 */ bool Selected;
    /* 0x0018 */ FString LocKey;
    /* 0x0028 */ UTexture2D* Icon;
    /* 0x0030 */ FHudAction HudAction;
    /* 0x0088 */ bool Enabled;
    /* 0x0089 */ bool hidden;
    /* 0x0090 */ FString hotkeyStr;
    /* 0x00a0 */ bool shouldTintIcon;
    /* 0x00a4 */ FName dependentUnlock;
    /* 0x00ac */ bool hasNewIndicator;
    /* 0x00ad */ bool hideIfLocked;
    /* 0x00ae */ bool disabledButResearchable;
    /* 0x00af */ bool showInWheel;
    /* 0x00b0 */ FName customTooltip;
    /* 0x00b8 */ bool demoLocked;
    /* 0x00b9 */ EArco_PlayerVerb associatedShortcutVerb;
    /* 0x00ba */ bool locked_limitOne;
    /* 0x00c0 */ TArray<FName> Variants;
    /* 0x00d0 */ int32_t currVariant;
};

// Size: 0xd8
struct FToolbarRow_Live {
    /* 0x0008 */ TArray<FToolbarItem_Live> toolbarItems;
    /* 0x0018 */ FName owningToolbar;
    /* 0x0020 */ FName SelectedItem;
    /* 0x0028 */ TSet<FName> itemsWithUnlockIndicator;
    /* 0x0078 */ bool showTabHints;
};

// Size: 0x20
struct FTooltipTag : public FTableRowBase {
    /* 0x0008 */ UTexture2D* iconTexture;
    /* 0x0010 */ FName LocKey;
    /* 0x0018 */ FColor textTint;
    /* 0x001c */ FColor iconTint;
};

// Size: 0x330
class ATowerGrid : public AActor {
};

// Size: 0x40
struct FTrackedWorkplace {
    /* 0x0000 */ FIntVector Location;
    /* 0x000c */ int32_t workerCount;
    /* 0x0010 */ int32_t maxWorkerCount;
    /* 0x0014 */ bool bPaused;
    /* 0x0015 */ bool bOvertime;
    /* 0x0018 */ int32_t overtimeCost;
    /* 0x001c */ bool bOvertimeAffordable;
    /* 0x0020 */ float remainingOvertime;
    /* 0x0028 */ TArray<FTrackedWorkplaceRecipe> recipes;
    /* 0x0038 */ int32_t chosenRecipe;
};

// Size: 0xc
struct FTrackedWorkplaceRecipe {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ bool bValid;
};

// Size: 0x18
struct FTradeBreakdown {
    /* 0x0000 */ TArray<FInvoiceRow> fees;
    /* 0x0010 */ int32_t totalCost;
};

// Size: 0x248
class UTradePort : public UActorComponent {
    /* 0x00d0 */ TSet<FName> m_supportedResourceCategories;
    /* 0x0120 */ TSet<FName> m_supportedResourceSubCategories;
    /* 0x01a8 */ FStockpile m_stockpile;
    /* 0x0200 */ FWorkerAssignment m_workers;
    /* 0x0220 */ UWorkerViz* m_workerViz;
    /* 0x0228 */ FIntVector m_entranceExternalCell;
    /* 0x0234 */ FIntVector m_entranceInternalCell;
};

// Size: 0x14
struct FTradeRow {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ int32_t countAvailable;
    /* 0x000c */ int32_t loadedCount;
    /* 0x0010 */ int32_t goldVal;
};

// Size: 0xb8
struct FTradeView_UIData {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ TMap<FName, FResourceStockpileSubcategory> m_resourcesByCategory;
    /* 0x0060 */ FStockpile Stockpile;
};

// Size: 0x368
class ATrain : public AActor {
    /* 0x02b0 */ TArray<ATrainCar*> m_childCars;
    /* 0x02c0 */ UAudioComponent* m_railAudio;
    /* 0x02cc */ float m_brake_acceleration;
    /* 0x02d0 */ float gravityStrength;
    /* 0x02d4 */ float m_windResistanceCoeff;
    /* 0x02d8 */ ETrainState m_state;
    /* 0x02dc */ float m_currentVelocity;
    /* 0x02e0 */ int32_t m_owningRailNetwork;
    /* 0x02e4 */ float m_trainSplinePos_center;
    /* 0x0300 */ FTrainBoostParams m_activeBoostParams;
    /* 0x030c */ float m_boostTimeRemaining;
    /* 0x0310 */ bool m_boostIsForward;
    /* 0x0314 */ int32_t m_stationDestCandidateId;
    /* 0x0324 */ bool debug_isBraking;
    /* 0x0328 */ float debug_frameAccel;
    /* 0x032c */ float debug_avgSlope;
    /* 0x0330 */ ARailSystem* m_railSystemRef;
};

// Size: 0xc
struct FTrainBoostParams {
    /* 0x0000 */ float accelerationBonus;
    /* 0x0004 */ float accelerationFalloffTime;
    /* 0x0008 */ float instantVelocityBoost;
};

// Size: 0x320
class ATrainCar : public AActor {
    /* 0x02a8 */ ATrain* owningTrain;
    /* 0x02b4 */ float lastTurnRate;
    /* 0x02b8 */ float visualRoll;
    /* 0x02bc */ float m_radius;
    /* 0x02c0 */ float m_bogeyRadius;
    /* 0x02c4 */ float m_rollSensitivity;
    /* 0x02c8 */ float m_rollSpeed;
    /* 0x02d0 */ float springConstant;
    /* 0x02d4 */ float DampingFactor;
    /* 0x02d8 */ float shakeFrequency;
    /* 0x02dc */ float maxShakeAmount;
    /* 0x02e0 */ float turnRateSparkThreshold;
    /* 0x02e4 */ int32_t passengerCapacity;
};

// Size: 0x30
struct FTrainPassenger {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ FTraversal desiredTraversal;
};

// Size: 0x410
class ATrainPlacementTool : public AActor {
    /* 0x02b0 */ UWidgetComponent* m_placementUiWidget;
    /* 0x02b8 */ FSimpleSpline m_previewSpline;
    /* 0x02e8 */ UClass* m_previewTrainClass;
    /* 0x02f0 */ TArray<UClass*> m_previewTrainCars;
    /* 0x0300 */ ATrain* m_previewTrain;
};

// Size: 0x20
struct FTraversal {
    /* 0x0000 */ FIntVector entryCell;
    /* 0x000c */ FDir entryDir;
    /* 0x0010 */ FIntVector exitCell;
    /* 0x001c */ FDir exitDir;
};

// Size: 0x28
struct FTriageBedState_UI {
    /* 0x0000 */ float healProgress;
    /* 0x0004 */ bool agentPresent;
    /* 0x0008 */ FString agentName;
    /* 0x0018 */ int32_t agentId;
    /* 0x001c */ FName portraitKey;
};

// Size: 0x1e8
class UTriageBuilding : public UActorComponent {
    /* 0x00d8 */ FWorkerAssignment m_workers;
    /* 0x00f8 */ TArray<FTriageResourceSlot> m_activeConsumables;
    /* 0x0108 */ TArray<FTriagePatient> m_patients;
    /* 0x0118 */ int32_t m_maxAgentsHealing;
    /* 0x011c */ float m_baseHealTime;
    /* 0x0120 */ float m_selfHealMultiplier;
    /* 0x0128 */ FStockpile m_stockpile;
    /* 0x0180 */ FName modifierForVisitors;
    /* 0x0188 */ UWorkerViz* m_workerViz;
};

// Size: 0x10
struct FTriagePatient {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ float timeLeftToHeal;
};

// Size: 0x14
struct FTriageResourceSlot {
    /* 0x0000 */ FName Resource;
    /* 0x0008 */ float TimeRemaining;
    /* 0x000c */ float timeMax;
    /* 0x0010 */ int32_t prodBonusIfActive;
};

// Size: 0xd8
struct FTriageView_UiData {
    /* 0x0000 */ FStockpile Stockpile;
    /* 0x0058 */ TArray<FTriageResourceSlot> m_activeConsumables;
    /* 0x0068 */ int32_t nMaxAgentsEating;
    /* 0x0070 */ TArray<FTriageBedState_UI> chairs;
    /* 0x0080 */ FWorkerAssignmentData workerData;
    /* 0x0090 */ FStockpileLinkerUiStruct linkerInfo;
    /* 0x00d0 */ bool disabledByPlayer;
};

// Size: 0x448
class UUI_AimBoxDetails : public UArcoView {

    FAimBoxHudData CalcHudState() const;
};

// Size: 0x448
class UUI_BathhouseView : public UArcoView {

    FBathhouseView_UiData CalcHudState();
};

// Size: 0x448
class UUI_ColonySignView : public UArcoView {

    FContractEmbarkHudState CalcState();
};

// Size: 0x458
class UUI_ConstructionDetails : public UArcoView {

    FConstructionDetailsState CalcState();
    void ReopenFinishedBuildingDetails();
};

// Size: 0x608
class UUI_CostRow : public UArcoWidgetBase {
    /* 0x0428 */ FResourceCollection m_resources;
    /* 0x0478 */ FResourceCollection m_supportsCost;
    /* 0x04c8 */ FResourceCollection m_constructionCost;
    /* 0x0518 */ FResourceCollection m_lostResources;
    /* 0x0568 */ FResourceCollection m_salvageResources;
    /* 0x05b8 */ FResourceCostDisplayGroup m_costs;

    void ResourceCostsChanged(const FResourceCostDisplayGroup costs);
    void SetConstructionCost(FResourceCollection Collection);
    void SetLostResources(FResourceCollection Collection);
    void SetResources(FResourceCollection Collection);
    void SetSalvageResources(FResourceCollection Collection);
    void SetSupportsCost(FResourceCollection Collection);
    void UpdateAffordability();
};

// Size: 0x448
class UUI_DayOverviewPanel : public UArcoView {
};

// Size: 0x448
class UUI_DebtsView : public UArcoView {

    FDebtsViewHudData CalcState();
    void CycleTabs(bool tabRight);
};

// Size: 0x448
class UUI_DeveloperToolView : public UArcoView {

    FDeveloperToolState ComputeState() const;
    bool IsStatEnabled(FString stat);
};

// Size: 0x450
class UUI_EateryView : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FEateryView_UiData CalcHudState();
    void EndStockpileSelection();
};

// Size: 0x448
class UUI_EmbarkIntroView : public UArcoView {
};

// Size: 0x450
class UUI_EndOfDaySummary : public UArcoView {

    FDaySummary_UI ComputeState();
    void CycleTabs(bool tabRight);
    void DisplayModeUpdated();
};

// Size: 0x428
class UUI_ExpeditionPanel : public UArcoWidgetBase {
};

// Size: 0x448
class UUI_FactionDock2 : public UArcoView {

    FFactionDock_UiState CalcState();
};

// Size: 0x450
class UUI_FarmDetails : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;
    /* 0x0449 */ bool bFieldAssignmentMode;

    FFarmUIState ComputeState();
    void CycleTabs(bool tabRight);
    void EndStockpileSelection();
    void ShiftUiForPickup(bool Hide);
};

// Size: 0x450
class UUI_FarmFieldDetails : public UArcoView {

    FFarmFieldUIState ComputeState() const;
    void SetActiveSeeds(FName seeds);
    void SetEarlyHarvestActive(bool bNewActive);
    void SetFertilizerActive(bool bNewActive);
    void SetRemovingRocksActive(bool bNewActive);
};

// Size: 0x448
class UUI_FluidValve : public UArcoView {

    FValveUiState ComputeState();
};

// Size: 0x448
class UUI_GlossaryView : public UArcoView {

    void OpenEntry(FName Entry);
};

// Size: 0x448
class UUI_GranaryView : public UArcoView {

    FGranaryViewState CalcHudState();
};

// Size: 0x450
class UUI_HarvestCamp : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FHarvestCampUIState ComputeState();
    void CycleTabs(bool tabRight);
    void EndStockpileSelection();
};

// Size: 0x448
class UUI_HeaterView : public UArcoView {

    FFueledHeaterHudInfo CalcHudState();
};

// Size: 0x448
class UUI_HousingDetails : public UArcoView {

    FHousingDetails_UiData CalcHudState();
};

// Size: 0x448
class UUI_IntroView : public UArcoView {
};

// Size: 0x448
class UUI_IslandBadge : public UArcoView {

    FIslandBadgeState ComputeState();
    void DisplayModeUpdated();
};

// Size: 0x448
class UUI_JobTicketDispenserBuilding : public UArcoView {

    FJobDispenserUIState ComputeState();
};

// Size: 0x450
class UUI_JumpPad : public UArcoView {
    /* 0x0448 */ bool m_assigningDest;

    void BeginAssigningMode();
    FJumpPadUiState ComputeState();
    void EndAssigningMode();
};

// Size: 0x4a0
class UUI_LevelEditorPropTool : public UArcoView {

    FLevelEditorPropToolState ComputeState();
};

// Size: 0x448
class UUI_LogisticsBuilding : public UArcoView {

    FLogisticsView_UIData CalcHudState();
};

// Size: 0x428
class UUI_NotificationPanel : public UArcoWidgetBase {
};

// Size: 0x450
class UUI_PackageDeliveryView : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FPackageDelivery_UiData CalcHudState();
    void CycleTabs(bool tabRight);
    void EndStockpileSelection();
};

// Size: 0x448
class UUI_PlayerResources_View : public UArcoView {

    FPlayerResourcesView_UiData CalcHudState();
};

// Size: 0x500
class UUI_PolicyView : public UArcoView {

    void AnimateCard(int32_t activeCardIdx);
    void AnimateCategorySelect();
    FPolicy_UiData CalcHudState();
    void CycleTabs(bool tabRight);
};

// Size: 0x458
class UUI_QuestLogView : public UArcoView {
    /* 0x0448 */ FQuestLogHudData Data;

    void ComputeState();
    void PlayerCompletedQuest();
    void SelectQuest(int32_t questId);
};

// Size: 0x4a0
class UUI_SettingsView : public UArcoView {
    /* 0x0448 */ bool remappingKey;

    FSettings_AudioTab CalcAudioTab();
    FSettings_GameplayTab CalcGameplayTab();
    FSettings_GraphicsTab CalcGraphicsTab();
    FSettings_KeybindsTab CalcKeybindsTab();
    FSettings_ModTab CalcModTab();
    void CycleTabs(bool tabRight);
    FString GetOptionValueAsShown(FString optionId) const;
    bool HasPendingChanges() const;
    void RemapperClosed(bool success);
    void RemapperInvalidBindAttempt(FKey Key);
    void RemapperKeyPressed(FKey Key);
    void RemapperOpened(FString remapId, FString CurrentKey);
};

// Size: 0x428
class UUI_SignpostSpatial : public UArcoWidgetBase {

    void SetMessage(FString Message);
};

// Size: 0x428
class UUI_SpatialDockNotification : public UArcoWidgetBase {

    void UpdateShipInfo(EShipType shipType, float percentTimeLeft);
};

// Size: 0x448
class UUI_StorageBuilding_View : public UArcoView {

    void CycleTabs(bool tabRight);
};

// Size: 0x450
class UUI_TaxOffice : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FTaxOfficeUiState CalcState();
    void EndStockpileSelection();
};

// Size: 0x498
class UUI_TechTreeView : public UArcoView {
    /* 0x0448 */ TMap<FName, int32_t> techCategorySortOrder;

    FTechTreeState_Hud CalcHudState();
    FTechTreeLayout CalcTechTreeState();
};

// Size: 0x450
class UUI_TerraformBuilding : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FTerraformBuildingUIState ComputeState();
    void CycleTabs(bool tabRight);
    void EndStockpileSelection();
};

// Size: 0x450
class UUI_TerraformCamp : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FTerraformCampUIState ComputeState();
    void CycleTabs(bool tabRight);
    void EndStockpileSelection();
};

// Size: 0x448
class UUI_TerrainTool_View : public UArcoView {

    FTerrainToolHudState ComputeState();
};

// Size: 0x450
class UUI_TradeDockView : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FTradeView_UIData CalcHudState();
    void EndStockpileSelection();
};

// Size: 0x450
class UUI_TriageView : public UArcoView {
    /* 0x0448 */ bool m_stockpileSelectorOpen;

    FTriageView_UiData CalcHudState();
    void EndStockpileSelection();
};

// Size: 0x448
class UUI_WorkDockView : public UArcoView {

    FWorkDock_UIData CalcHudState();
};

// Size: 0x428
class UUI_embarkPregameUi : public UArcoWidgetBase {

    FEmbarkHudState CalcState();
};

// Size: 0xc
struct FUdsTimePair {
    /* 0x0000 */ float percentIntoDay;
    /* 0x0004 */ float udsTime;
    /* 0x0008 */ float sunOffset;
};

// Size: 0x10
struct FUnlockSubCategory {
    /* 0x0000 */ TArray<FName> unlocks;
};

// Size: 0x50
struct FUnlockTopLevelCategory {
    /* 0x0000 */ TMap<FName, FUnlockSubCategory> unlockSubcategories;
};

// Size: 0x50
struct FUnlockTree {
    /* 0x0000 */ TMap<FName, FUnlockTopLevelCategory> unlockCategories;
};

// Size: 0x24
struct FValveUiState {
    /* 0x0000 */ int32_t outputFluid;
    /* 0x0004 */ int32_t outputFluidCapacity;
    /* 0x0008 */ int32_t inputFluid;
    /* 0x000c */ int32_t inputFluidCapacity;
    /* 0x0010 */ int32_t percentInput;
    /* 0x0014 */ bool closed;
    /* 0x0018 */ int32_t percentThreshold;
    /* 0x001c */ FName fluidResource;
};

// Size: 0x20
struct FVendingAgent {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ float timeLeftToEat;
    /* 0x000c */ bool isFood;
    /* 0x0010 */ FName currentMeal;
    /* 0x0018 */ int32_t additionalMeals;
    /* 0x001c */ bool hasHadPolicyExtraMeal;
};

// Size: 0x448
class UVictoryView : public UArcoView {

    FGameOverInfo CalcData();
};

// Size: 0x70
struct FWaitingElevatorAgent {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ FTraversal desiredTraversal;
    /* 0x0028 */ FName animationPreWait;
    /* 0x0030 */ bool animatingIn;
};

// Size: 0x2e8
class AWallTool : public AActor {
    /* 0x02a8 */ bool isBulldoze;
    /* 0x02a9 */ bool isDragging;
    /* 0x02ac */ FIntVector dragStartPos;
    /* 0x02b8 */ FIntVector dragEndPos;
    /* 0x02d8 */ UClass* wallSeg;
    /* 0x02e0 */ int32_t categoryIdx;
};

// Size: 0x80
struct FWandererData {
};

// Size: 0x320
class AWandererSystem : public AActor {
    /* 0x02a8 */ int32_t m_numWanderers;
    /* 0x02b0 */ FVector custScale;
    /* 0x02c8 */ float moveSpeed;
    /* 0x02cc */ float chanceContinueForward;
    /* 0x02d0 */ FVector spawnRangeCornerMin;
    /* 0x02e8 */ FVector spawnRangeCornerMax;
    /* 0x0300 */ UInstancedStaticMeshComponent* m_wandererMeshes;
    /* 0x0308 */ int32_t m_numUpdateGroups;

    void calcPrime();
};

// Size: 0x30
struct FWeatherPreset : public FTableRowBase {
    /* 0x0008 */ UPrimaryDataAsset* udsWeatherPreset;
    /* 0x0010 */ UTexture2D* forecastIcon;
    /* 0x0018 */ FName associatedWorldEvent;
    /* 0x0020 */ float oceanWindSpeed;
    /* 0x0024 */ float terrainWindSpeed;
    /* 0x0028 */ float terrainWindIntensity;
    /* 0x002c */ float sunIntensity;
};

// Size: 0x288
class UWorkDock : public UActorComponent {
    /* 0x00d8 */ TSet<FName> m_supportedResourceCategories;
    /* 0x0128 */ TSet<FName> m_supportedResourceSubCategories;
    /* 0x01b8 */ FStockpile m_stockpile;
    /* 0x0210 */ FWorkerAssignment m_workers;
    /* 0x0230 */ UWorkerViz* m_workerViz;
    /* 0x0268 */ FIntVector m_entranceExternalCell;
    /* 0x0274 */ FIntVector m_entranceInternalCell;

    void DockSlotChanged(int32_t newBoatId, EWorkShipState NewState);
};

// Size: 0xb0
struct FWorkDock_UIData {
    /* 0x0000 */ FWorkerAssignmentData workerData;
    /* 0x0010 */ FStockpile Stockpile;
    /* 0x0068 */ FArcoWorkShip assignedShipInfo;
};

// Size: 0x20
struct FWorkerAssignment {
    /* 0x0000 */ TArray<FWorkerSlot> m_workerSlots;
    /* 0x0010 */ bool bDisabled;
    /* 0x0011 */ bool bOvertime;
    /* 0x0014 */ FWorldTimeStamp m_overtimeTimeStamp;
    /* 0x001c */ bool bOvertimeToggled;
};

// Size: 0x10
struct FWorkerAssignmentData {
    /* 0x0000 */ TArray<FWorkerSlotData> m_slots;
};

// Size: 0x430
class UWorkerAssignmentPanel : public UArcoWidgetBase {
    /* 0x0428 */ bool m_isAgentSelectOpen;

    void CloseAgentSelect();
    void UpdateData(FWorkerAssignmentData Data);
};

// Size: 0x10
struct FWorkerSlot {
    /* 0x0000 */ APrototype_Agent* Agent;
    /* 0x0008 */ bool present;
    /* 0x0009 */ EAgentEducation educationRequirement;
    /* 0x000a */ bool bIsRequiredToRun;
    /* 0x000b */ bool bGivesBonus;
};

// Size: 0x50
struct FWorkerSlotData {
    /* 0x0000 */ EWorkerSlotType slotType;
    /* 0x0001 */ bool isAgentAssigned;
    /* 0x0004 */ int32_t agentId;
    /* 0x0008 */ APrototype_Agent* agentRef;
    /* 0x0010 */ FString agentActivityKey;
    /* 0x0020 */ int32_t percentEff;
    /* 0x0024 */ int32_t percentSpeed;
    /* 0x0028 */ FString workerName;
    /* 0x0038 */ EAgentEducation educationRequirement;
    /* 0x0039 */ bool bIsLocked;
    /* 0x003a */ bool bIsRequired;
    /* 0x003b */ bool bGivesBonus;
    /* 0x003c */ int32_t bonusEff;
    /* 0x0040 */ float educationProgress;
    /* 0x0044 */ EAgentEducation nextEducation;
    /* 0x0048 */ FName nextGuild;
};

// Size: 0x2a0
class UWorkerViz : public USceneComponent {
    /* 0x0240 */ TArray<FWorkerVizPosState> m_workPositions;
    /* 0x0250 */ TSet<APrototype_Agent*> m_overflowHiddenAgents;
};

// Size: 0x270
class UWorkerVizPos : public USceneComponent {
    /* 0x0240 */ FName associatedAnimationKey;
    /* 0x0248 */ FName associatedHandToolMesh;
    /* 0x0250 */ bool offHand;
    /* 0x0254 */ FName associatedWorkerIntent;
    /* 0x0260 */ USkeletalMeshComponent* dev_preview;
};

// Size: 0x10
struct FWorkerVizPosState {
    /* 0x0000 */ UWorkerVizPos* vizPosComponent;
    /* 0x0008 */ APrototype_Agent* occupyingAgent;
};

// Size: 0x38
struct FWorkplaceInfo {
    /* 0x0000 */ TArray<FName> Keys;
    /* 0x0010 */ TArray<FWorkplaceRecipeInfo> recipes;
    /* 0x0020 */ int32_t capacity;
    /* 0x0024 */ int32_t workerCount;
    /* 0x0028 */ TArray<FTrackedWorkplace> workplaces;
};

// Size: 0x20
struct FWorkplaceRecipeInfo {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ int32_t capacity;
    /* 0x000c */ int32_t workerCount;
    /* 0x0010 */ TArray<FTrackedWorkplace> workplaces;
};

// Size: 0x60
struct FWorldEffectDefinition : public FTableRowBase {
    /* 0x0008 */ int32_t nDays;
    /* 0x0010 */ FString Name;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ UTexture2D* iconTexture;
    /* 0x0038 */ FString EffectType;
    /* 0x0048 */ FName associatedModifier;
    /* 0x0050 */ FName associatedSystemFlag;
    /* 0x0058 */ bool informExpired;
    /* 0x0059 */ bool negative;
};

// Size: 0x10
struct FWorldEffectState_FoodDraining {
    /* 0x0000 */ float timeUntilTrigger;
    /* 0x0004 */ float interval;
    /* 0x0008 */ int32_t foodToLose;
    /* 0x000c */ int32_t i_warehouseToCheck;
};

// Size: 0xc8
class UWorldEffects : public UObject {
    /* 0x0028 */ TMap<FName, FActiveEffect> m_activeWorldEffects;
    /* 0x0078 */ TSet<FName> m_effectFlags;
};

// Size: 0x1d08
struct FWorldMeta {
    /* 0x0050 */ TSet<AGridActor*> constructions;
    /* 0x00a0 */ TSet<AGridActor*> houses;
    /* 0x00f0 */ TSet<UHouse*> houses_components;
    /* 0x0140 */ TSet<AGridActor*> docks;
    /* 0x0190 */ TSet<AGridActor*> stairs;
    /* 0x01e0 */ TSet<Ustairs*> stairs_components;
    /* 0x0230 */ TSet<AGridActor*> jumpPads;
    /* 0x0280 */ TSet<AGridActor*> ladders;
    /* 0x02d0 */ TSet<ULadder*> ladders_components;
    /* 0x0320 */ TSet<ULadder*> ladders_components_ticking;
    /* 0x0370 */ TSet<AGridActor*> slides;
    /* 0x03c0 */ TSet<AGridActor*> railTiles;
    /* 0x0410 */ TSet<AGridActor*> stationTiles;
    /* 0x0460 */ TSet<AGridActor*> steamEngines;
    /* 0x04b0 */ TSet<AGridActor*> vendings;
    /* 0x0500 */ TSet<AGridActor*> granaries;
    /* 0x0550 */ TSet<UGranaryResourceBuilding*> granaryComponents;
    /* 0x05a0 */ TSet<UResourceBuilding*> resourceBuildingComponents;
    /* 0x05f0 */ TSet<AGridActor*> jobTicketBuildings;
    /* 0x0640 */ TSet<AGridActor*> resourceBuildings;
    /* 0x0690 */ int32_t nDryWarehouses;
    /* 0x0694 */ int32_t nGranaries;
    /* 0x0698 */ TSet<AGridActor*> industries;
    /* 0x06e8 */ TSet<UIndustry*> industries_components;
    /* 0x0738 */ TSet<AGridActor*> schools;
    /* 0x0788 */ TSet<UResearchLab*> lab_components;
    /* 0x07d8 */ TSet<AGridActor*> factionPorts;
    /* 0x0828 */ TSet<AGridActor*> choppables;
    /* 0x0878 */ TSet<UChoppable*> harvestableComponents;
    /* 0x08c8 */ TSet<UChoppable*> mineHarvestables;
    /* 0x0918 */ TSet<UChoppable*> choppables_all_ticking;
    /* 0x0968 */ TSet<Ugrave*> graves;
    /* 0x09b8 */ TSet<Ugrave*> unclaimedGraves;
    /* 0x0a08 */ TSet<AGridActor*> harvestCamps;
    /* 0x0a58 */ TSet<AGridActor*> m_restrooms;
    /* 0x0aa8 */ TSet<AGridActor*> m_farmBuildings;
    /* 0x0af8 */ TSet<AGridActor*> m_farmLand;
    /* 0x0b48 */ TSet<UFarmland*> m_farmland_components;
    /* 0x0b98 */ TSet<AGridActor*> m_townHalls;
    /* 0x0be8 */ TSet<AGridActor*> m_signPosts;
    /* 0x0c38 */ TSet<AGridActor*> m_aimMachines;
    /* 0x0c88 */ TSet<UAimAutoReplacementListener*> m_aimReplacementListeners;
    /* 0x0cd8 */ TSet<AGridActor*> m_aimStockpileInterfaces;
    /* 0x0d28 */ TSet<AGridActor*> m_generators;
    /* 0x0d78 */ TSet<AGridActor*> m_fueledHeaters;
    /* 0x0dc8 */ TSet<AGridActor*> m_deliveryBuildings;
    /* 0x0e18 */ TSet<AGridActor*> m_logisticsBuilding;
    /* 0x0e68 */ TSet<AGridActor*> m_waterFountains;
    /* 0x0eb8 */ TSet<AGridActor*> m_boilers;
    /* 0x0f08 */ TSet<AGridActor*> m_bathhouses;
    /* 0x0f58 */ TSet<AGridActor*> m_triageBuildings;
    /* 0x0fa8 */ TSet<AGridActor*> m_tradePorts;
    /* 0x0ff8 */ TSet<AGridActor*> m_offices;
    /* 0x1048 */ TSet<AGridActor*> m_elevatorSegments;
    /* 0x1098 */ TSet<AGridActor*> m_infiniteResourceSourceOrDrains;
    /* 0x10e8 */ TSet<Ucoordinationoffice*> m_coordinationOffices;
    /* 0x1138 */ TSet<UDecorativeSlot*> m_decorativeSlots;
    /* 0x1188 */ TSet<AGridActor*> m_decoratives;
    /* 0x11d8 */ TSet<Uoceanvoid*> m_oceanVoids;
    /* 0x1228 */ TSet<UTerraformBuilding*> m_stoneDumps;
    /* 0x1278 */ TSet<Uterraformcamp*> m_terraformCamps;
    /* 0x12c8 */ TSet<UTerraformCell*> m_terraformCells;
    /* 0x1318 */ TSet<UTaxOffice*> m_taxOffices;
    /* 0x1368 */ TSet<UDecorative*> m_tickableDecorativeComponents;
    /* 0x13b8 */ TSet<AGridActor*> m_fluidValves;
    /* 0x1408 */ TSet<AGridActor*> m_railBoosters;
    /* 0x1818 */ FPopulation Population;
    /* 0x1ca0 */ int32_t maxPopulation;
    /* 0x1ca4 */ int32_t sessionLoadTimestamp;
    /* 0x1ca8 */ int32_t historicPlayPeriodSeconds;
    /* 0x1d00 */ UGranaryResourceBuilding* primaryWarehouse;
};

// Size: 0x420
class AWorldTime : public AActor {
    /* 0x02a8 */ UMaterialParameterCollection* commonTerrainParams;
    /* 0x02b0 */ TArray<FName> m_seasonProgression;
    /* 0x02c0 */ FName m_startingSeason;
    /* 0x0328 */ UClass* m_skyClass;
    /* 0x0330 */ UClass* m_weatherClass;
    /* 0x0338 */ TArray<FUdsTimePair> m_udsDaytimeLightingThresholds;
    /* 0x0348 */ float udstime_nighttime;
    /* 0x034c */ float m_morningToDayTransitionSpeed;
    /* 0x0354 */ float m_eodThreshold;
    /* 0x035c */ int32_t m_day;
    /* 0x0360 */ int32_t m_year;
    /* 0x03d0 */ float m_timeOfDay;
    /* 0x03d4 */ bool m_paused;
    /* 0x03d5 */ bool m_instantAnimation;
    /* 0x03d6 */ EDayPhase m_currentPhase;
    /* 0x03d8 */ AActor* m_skyRef;
    /* 0x03e0 */ AActor* m_weatherRef;
    /* 0x03e8 */ FName m_currentWeather;
    /* 0x03f0 */ TArray<FName> m_weatherForecast;
    /* 0x0400 */ float m_totalWorldTimeElapsed;
    /* 0x0408 */ TArray<FDayEventData> m_dayEvents;
    /* 0x041c */ float m_basePhaseChangeAnimSpan;

    EDayPhase GetDayPhase() const;
    float GetDayTimeRemaining() const;
    float GetLengthOfPhase() const;
    float GetLiveTime() const;
    void SetDesiredVisualTimeOfDay(float udsTime, float sunOffset, bool instant, bool resetLerpProgress, float lerpSpeed);
    void SetSunIntensity(float Intensity);
    void SetWeather_UDW(UPrimaryDataAsset* WeatherPreset);
    float TimeUntilNextPhase() const;
};

// Size: 0x8
struct FWorldTimeStamp {
    /* 0x0000 */ int32_t day;
    /* 0x0004 */ float timeOfDay;
};

// Size: 0x2d0
class Ubathhouse : public UActorComponent {
    /* 0x00d0 */ TArray<FBathingAgent> m_agentsBathing;
    /* 0x00e0 */ int32_t m_baseQuality;
    /* 0x00e4 */ int32_t m_maxAgentsBathing;
    /* 0x00e8 */ FResourceCollection m_fluidUsedPerBath;
    /* 0x0138 */ int32_t m_fluidStockpileCount;
    /* 0x013c */ int32_t m_soapStockpileCount;
    /* 0x0140 */ float m_bathTime;
    /* 0x0144 */ float m_searchPenalty;
    /* 0x0148 */ FStockpile m_supplyStockpile;
    /* 0x01a0 */ int32_t m_soapChargesUsed;
    /* 0x01a4 */ bool m_requestSoap;
    /* 0x01a8 */ FName thoughtForVisitors;
    /* 0x01b0 */ UWorkerViz* m_workerViz;
    /* 0x01c8 */ FStockpile m_inputFluidStockpile;
    /* 0x0238 */ FMulticastInlineDelegate m_stockChangeDelegate;
    /* 0x0248 */ TSet<int32_t> m_inboundAgents;
};

// Size: 0xb8
class UcivicOffice : public UActorComponent {
};

// Size: 0x138
class Ucoordinationoffice : public UActorComponent {
    /* 0x00e0 */ FWorkerAssignment m_workers;
    /* 0x0100 */ UWorkerViz* m_workerViz;

    bool AssignWorkerToSlot(int32_t Slot, APrototype_Agent* Agent);
    bool FireSpecificWorker(APrototype_Agent* Agent);
};

// Size: 0x580
class Aelevator : public AGridActor {
    /* 0x0408 */ UClass* m_platformActorClass;
    /* 0x0410 */ AElevatorPlatform* m_platformActor;
    /* 0x0418 */ TMap<FIntVector, UElevatorSegment*> m_ownedSegments;
    /* 0x0470 */ float m_platformStopInterval;
    /* 0x0474 */ float m_platformMaxSpeed;
    /* 0x0478 */ float m_platformAccel;
    /* 0x047c */ int32_t m_maxAgentsOnPlatform;
    /* 0x04b8 */ TMap<int32_t, FElevatorLandingData> m_landings;
    /* 0x0508 */ bool wakeupFlag;
    /* 0x0510 */ TArray<int32_t> m_ascendingLandingHeights;
    /* 0x0520 */ TArray<FWaitingElevatorAgent> m_agentsOnMovingPlatform;
    /* 0x0530 */ FColor m_debugColor;
};

// Size: 0x230
class Ugrave : public UActorComponent {
    /* 0x00b8 */ FMulticastInlineDelegate assignEvent;
    /* 0x00c8 */ FMulticastInlineDelegate initEvent;
    /* 0x00d8 */ bool hasAssignedDeath;
    /* 0x00e0 */ FReportedDeath associatedDeath;
};

// Size: 0x138
class Ujumppad : public UActorComponent {
    /* 0x00c8 */ int32_t maxHorizDistance;
    /* 0x00cc */ int32_t maxZDistance;
    /* 0x00d0 */ int32_t maxSteam;
    /* 0x00d8 */ FMulticastInlineDelegate padLaunched;
    /* 0x0104 */ int32_t storedSteam;
    /* 0x0108 */ int32_t steamPerLaunch;
    /* 0x0120 */ UInstancedStaticMeshComponent* m_previewLandingPositions;
};

// Size: 0x138
class Ulogisticshub : public UActorComponent {
    /* 0x00c8 */ FWorkerAssignment m_workers;
    /* 0x00e8 */ UWorkerViz* m_workerViz;
};

// Size: 0x118
class Uoceanvoid : public UActorComponent {
    /* 0x00ec */ float m_secondsPerWaterDrain;
    /* 0x0100 */ FMulticastInlineDelegate drainStateChanged;
};

// Size: 0x118
class Urestroom : public UActorComponent {
    /* 0x00c8 */ TArray<FRestroomAgent> m_agentsControlled;
    /* 0x00d8 */ int32_t uses;
};

// Size: 0x170
class Uschool : public UActorComponent {
    /* 0x00d0 */ UWorkerViz* m_workerViz;
    /* 0x0140 */ FWorkerAssignment m_workers;
    /* 0x0160 */ EAgentEducation m_educationTarget;
    /* 0x0161 */ bool m_isTeachingGuild;
};

// Size: 0xf8
class Usignpost : public UActorComponent {
    /* 0x00b8 */ FComponentReference desiredSignpostWidget;
    /* 0x00e0 */ FString shownMessage;
    /* 0x00f0 */ UWidgetComponent* linkedSignpostWidget;
};

// Size: 0x188
class Uslide : public UActorComponent {
    /* 0x00c8 */ float slidePitch;
    /* 0x00cc */ float VerticalOffset;
    /* 0x00d0 */ float traversalCost;
    /* 0x00d8 */ FSlideData m_data;
    /* 0x0150 */ float m_maxSpeed;
    /* 0x0154 */ float m_accel;
};

// Size: 0x1f8
class Ustairs : public UActorComponent {
    /* 0x00c8 */ USplineComponent* m_travelSpline;
    /* 0x00d0 */ FStairData m_data;
    /* 0x01a8 */ FStairConfig m_config;
};

// Size: 0x140
class Usteamengine : public UActorComponent {
    /* 0x00c0 */ float m_powerRemaining;
    /* 0x00c8 */ float m_powerDrawPerSecond;
    /* 0x00d0 */ FMulticastInlineDelegate animateDelegate;

    int32_t GetNConnections() const;
};

// Size: 0x1e0
class Uterraformcamp : public UActorComponent {
    /* 0x00e0 */ FWorkerAssignment m_workers;
    /* 0x0100 */ UStockpileRender* m_stockpileVisual;
    /* 0x0108 */ float m_pathfindingMaxSearchCost;
    /* 0x010c */ int32_t m_pathfindingMaxCellDistance;
    /* 0x0110 */ UWorkerViz* m_workerViz;
    /* 0x0118 */ FStockpile m_storageStockpile;
    /* 0x0198 */ UServiceRange* m_serviceRange;
};

// Size: 0xb8
class Utownhall : public UActorComponent {
};

// Size: 0x138
class Uwaterfountain : public UActorComponent {
    /* 0x00c8 */ TArray<FDrinkingAgent> m_agentsDrinking;
    /* 0x00d8 */ FMulticastInlineDelegate m_waterChangeDelegate;

    int32_t GetGoalWeight(FName Context, int32_t contextIntParam);
    bool PassControlToEnterable(APrototype_Agent* Agent, FEntryContext Context);
    bool ReleaseControlToAgent(APrototype_Agent* Agent);
    void SimTick(float deltaTime);
};

enum class EPropertyBindingAccessType {
    Offset = 0,
    Object = 1,
    WeakObject = 2,
    SoftObject = 3,
    ObjectInstance = 4,
    StructInstance = 5,
    IndexArray = 6,
    EPropertyBindingAccessType_MAX = 7,
};

enum class EPropertyBindingPropertyAccessType {
    Offset = 0,
    Object = 1,
    WeakObject = 2,
    SoftObject = 3,
    ObjectInstance = 4,
    StructInstance = 5,
    IndexArray = 6,
    SharedStruct = 7,
    StructInstanceContainer = 8,
    Unset = 9,
    EPropertyBindingPropertyAccessType_MAX = 10,
};

enum class EPropertyCopyType {
    None = 0,
    CopyPlain = 1,
    CopyComplex = 2,
    CopyBool = 3,
    CopyStruct = 4,
    CopyObject = 5,
    CopyName = 6,
    CopyFixedArray = 7,
    StructReference = 8,
    PromoteBoolToByte = 9,
    PromoteBoolToInt32 = 10,
    PromoteBoolToUInt32 = 11,
    PromoteBoolToInt64 = 12,
    PromoteBoolToFloat = 13,
    PromoteBoolToDouble = 14,
    PromoteByteToInt32 = 15,
    PromoteByteToUInt32 = 16,
    PromoteByteToInt64 = 17,
    PromoteByteToFloat = 18,
    PromoteByteToDouble = 19,
    PromoteInt32ToInt64 = 20,
    PromoteInt32ToFloat = 21,
    PromoteInt32ToDouble = 22,
    PromoteUInt32ToInt64 = 23,
    PromoteUInt32ToFloat = 24,
    PromoteUInt32ToDouble = 25,
    PromoteFloatToInt32 = 26,
    PromoteFloatToInt64 = 27,
    PromoteFloatToDouble = 28,
    DemoteDoubleToInt32 = 29,
    DemoteDoubleToInt64 = 30,
    DemoteDoubleToFloat = 31,
    EPropertyCopyType_MAX = 32,
};

// Size: 0x18
struct FPropertyBindingBindableStructDescriptor {
    /* 0x0008 */ UStruct* Struct;
    /* 0x0010 */ FName Name;
};

// Size: 0x28
struct FPropertyBindingBinding {
    /* 0x0008 */ FPropertyBindingPath SourcePropertyPath;
    /* 0x0018 */ FPropertyBindingPath TargetPropertyPath;
};

// Size: 0xc0
struct FPropertyBindingBindingCollection {
    /* 0x0010 */ TArray<FPropertyBindingCopyInfoBatch> CopyBatches;
    /* 0x0020 */ TArray<FPropertyBindingCopyInfo> PropertyCopies;
    /* 0x0030 */ TArray<FPropertyBindingPropertyIndirection> PropertyIndirections;
    /* 0x0048 */ TScriptInterface<IPropertyBindingBindingCollectionOwner> BindingsOwner;
};

// Size: 0x28
class IPropertyBindingBindingCollectionOwner : public UInterface {
};

// Size: 0x68
struct FPropertyBindingCopyInfo {
    /* 0x0000 */ FPropertyBindingPropertyIndirection SourceIndirection;
    /* 0x0018 */ FPropertyBindingPropertyIndirection TargetIndirection;
    /* 0x0040 */ UStruct* SourceStructType;
    /* 0x0048 */ int32_t CopySize;
    /* 0x0050 */ FInstancedStruct SourceDataHandle;
    /* 0x0060 */ EPropertyCopyType Type;
};

// Size: 0x18
struct FPropertyBindingCopyInfoBatch {
    /* 0x0000 */ FInstancedStruct TargetStruct;
    /* 0x0010 */ FPropertyBindingIndex16 BindingsBegin;
    /* 0x0012 */ FPropertyBindingIndex16 BindingsEnd;
    /* 0x0014 */ FPropertyBindingIndex16 PropertyFunctionsBegin;
    /* 0x0016 */ FPropertyBindingIndex16 PropertyFunctionsEnd;
};

// Size: 0x2
struct FPropertyBindingIndex16 {
    /* 0x0000 */ uint16_t Value;
};

// Size: 0x10
struct FPropertyBindingPath {
    /* 0x0000 */ TArray<FPropertyBindingPathSegment> Segments;
};

// Size: 0x20
struct FPropertyBindingPathSegment {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t ArrayIndex;
    /* 0x0010 */ UStruct* InstanceStruct;
    /* 0x0018 */ EPropertyBindingPropertyAccessType InstancedStructAccessType;
};

// Size: 0x18
struct FPropertyBindingPropertyIndirection {
    /* 0x0000 */ FPropertyBindingIndex16 ArrayIndex;
    /* 0x0002 */ uint16_t Offset;
    /* 0x0004 */ FPropertyBindingIndex16 NextIndex;
    /* 0x0006 */ EPropertyBindingPropertyAccessType Type;
    /* 0x0008 */ UStruct* InstanceStruct;
};

// Size: 0x38
struct FCachedPropertyPath {
    /* 0x0000 */ TArray<FPropertyPathSegment> Segments;
    /* 0x0018 */ UFunction* CachedFunction;
};

enum class EPropertyPathTestEnum {
    One = 0,
    Two = 1,
    Three = 2,
    Four = 3,
    EPropertyPathTestEnum_MAX = 4,
};

// Size: 0x20
struct FPropertyPathSegment {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t ArrayIndex;
    /* 0x0010 */ UStruct* Struct;
};

// Size: 0x8
struct FPropertyPathTestBaseStruct {
};

// Size: 0xd0
struct FPropertyPathTestBed {
    /* 0x0000 */ UPropertyPathTestObject* Object;
    /* 0x0008 */ UPropertyPathTestObject* ModifiedObject;
    /* 0x0010 */ FPropertyPathTestStruct ModifiedStruct;
    /* 0x0070 */ FPropertyPathTestStruct DefaultStruct;
};

// Size: 0x28
struct FPropertyPathTestInnerStruct : public FPropertyPathTestBaseStruct {
    /* 0x0008 */ float float;
    /* 0x000c */ bool bool;
    /* 0x000d */ uint8_t EnumOne;
    /* 0x000e */ uint8_t EnumTwo;
    /* 0x000f */ uint8_t EnumThree;
    /* 0x0010 */ uint8_t EnumFour;
    /* 0x0014 */ int32_t Integer;
    /* 0x0018 */ FString String;
};

// Size: 0x180
class UPropertyPathTestObject : public UObject {
    /* 0x0028 */ bool bool;
    /* 0x0029 */ uint8_t EnumOne;
    /* 0x002a */ uint8_t EnumTwo;
    /* 0x002b */ uint8_t EnumThree;
    /* 0x002c */ uint8_t EnumFour;
    /* 0x0030 */ int32_t Integer;
    /* 0x0038 */ FString String;
    /* 0x0048 */ float float;
    /* 0x0050 */ FPropertyPathTestStruct Struct;
    /* 0x00b0 */ FPropertyPathTestStruct StructRef;
    /* 0x0110 */ FPropertyPathTestStruct StructConstRef;
    /* 0x0170 */ UPropertyPathTestObject* InnerObject;

    float GetFloat() const;
    FPropertyPathTestStruct GetStruct() const;
    FPropertyPathTestStruct GetStructConstRef() const;
    FPropertyPathTestStruct GetStructRef() const;
    void SetFloat(float InFloat);
    void SetStruct(FPropertyPathTestStruct InStruct);
    void SetStructConstRef(FPropertyPathTestStruct InStruct);
    void SetStructRef(FPropertyPathTestStruct InStruct);
};

// Size: 0x60
struct FPropertyPathTestStruct : public FPropertyPathTestBaseStruct {
    /* 0x0008 */ bool bool;
    /* 0x000c */ int32_t Integer;
    /* 0x0010 */ uint8_t EnumOne;
    /* 0x0011 */ uint8_t EnumTwo;
    /* 0x0012 */ uint8_t EnumThree;
    /* 0x0013 */ uint8_t EnumFour;
    /* 0x0018 */ FString String;
    /* 0x0028 */ float float;
    /* 0x0030 */ FPropertyPathTestInnerStruct InnerStruct;
    /* 0x0058 */ UPropertyPathTestObject* InnerObject;
};

enum class EVTInvalidatePriority {
    Normal = 0,
    High = 1,
    Count = 2,
    EVTInvalidatePriority_MAX = 3,
};

enum class EVTProducerPriority {
    Lowest = 0,
    Lower = 1,
    Low = 2,
    BelowNormal = 3,
    Normal = 4,
    AboveNormal = 5,
    High = 6,
    Highest = 7,
    Count = 8,
    EVTProducerPriority_MAX = 9,
};

enum class ESparseVolumeTexturePreviewAttribute {
    ESVTPA_AttributesA_R = 0,
    ESVTPA_AttributesA_G = 1,
    ESVTPA_AttributesA_B = 2,
    ESVTPA_AttributesA_A = 3,
    ESVTPA_AttributesB_R = 4,
    ESVTPA_AttributesB_G = 5,
    ESVTPA_AttributesB_B = 6,
    ESVTPA_AttributesB_A = 7,
    ESVTPA_MAX = 8,
};

// Size: 0x28
class UMaterialCacheStackProvider : public UObject {
};

// Size: 0x160
class UMaterialCacheVirtualTexture : public UTexture {
    /* 0x0140 */ TWeakObjectPtr<UPrimitiveComponent> OwningComponent;
    /* 0x0148 */ TWeakObjectPtr<UMaterialCacheStackProvider> MaterialStackProvider;
    /* 0x0150 */ FIntPoint TileCount;
};

// Size: 0x2b0
class ASparseVolumeTextureViewer : public AInfo {
    /* 0x02a8 */ USparseVolumeTextureViewerComponent* SparseVolumeTextureViewerComponent;
};

// Size: 0x560
class USparseVolumeTextureViewerComponent : public UPrimitiveComponent {
    /* 0x0520 */ USparseVolumeTexture* SparseVolumeTexturePreview;
    /* 0x0528 */ float Frame;
    /* 0x052c */ float FrameRate;
    /* 0x0530 */ bool bPlaying;
    /* 0x0530 */ bool bLooping;
    /* 0x0530 */ bool bReversePlayback;
    /* 0x0530 */ bool bBlockingStreamingRequests;
    /* 0x0530 */ bool bApplyPerFrameTransforms;
    /* 0x0530 */ bool bPivotAtCentroid;
    /* 0x0534 */ float VoxelSize;
    /* 0x0538 */ uint8_t PreviewAttribute;
    /* 0x053c */ int32_t MipLevel;
    /* 0x0540 */ float Extinction;
};

// Size: 0x70
struct FAnimNode_RigLogic : public FAnimNode_Base {
    /* 0x0010 */ FPoseLink AnimSequence;
    /* 0x0020 */ bool CacheAnimCurveNames;
    /* 0x0024 */ int32_t LODThreshold;
};

// Size: 0x18
struct FBoneIndexControlAttributeMapping {
};

// Size: 0x3
struct FCoordinateSystem {
    /* 0x0000 */ EDirection XAxis;
    /* 0x0001 */ EDirection YAxis;
    /* 0x0002 */ EDirection ZAxis;
};

// Size: 0x140
class UDNAAsset : public UAssetUserData {
    /* 0x0028 */ FString DnaFileName;
    /* 0x0038 */ bool bKeepDNAAfterInitialization;
    /* 0x0040 */ TMap<FString, FString> MetaData;
    /* 0x0090 */ FRigLogicConfiguration RigLogicConfiguration;
};

// Size: 0x28
class UDNAIndexMapping : public UAssetUserData {
};

enum class EActivationFunction {
    Linear = 0,
    ReLU = 1,
    LeakyReLU = 2,
    Tanh = 3,
    Sigmoid = 4,
    EActivationFunction_MAX = 5,
};

enum class EArchetype {
    Asian = 0,
    Black = 1,
    Caucasian = 2,
    Hispanic = 3,
    Alien = 4,
    Other = 5,
    EArchetype_MAX = 6,
};

enum class EAutomaticRadius {
    On = 0,
    Off = 1,
    EAutomaticRadius_MAX = 2,
};

enum class EDNADataLayer {
    None = 0,
    Descriptor = 1,
    Definition = 3,
    Behavior = 7,
    Geometry = 11,
    GeometryWithoutBlendShapes = 19,
    MachineLearnedBehavior = 35,
    RBFBehavior = 71,
    All = 111,
    EDNADataLayer_MAX = 112,
};

enum class EDirection {
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
    Front = 4,
    Back = 5,
    EDirection_MAX = 6,
};

enum class EGender {
    Male = 0,
    Female = 1,
    Other = 2,
    EGender_MAX = 3,
};

enum class ELodUpdateOption {
    LOD0Only = 0,
    LOD1AndHigher = 1,
    All = 2,
    ELodUpdateOption_MAX = 3,
};

enum class ERigLogicCalculationType {
    Scalar = 0,
    SSE = 1,
    AVX = 2,
    NEON = 3,
    AnyVector = 4,
    ERigLogicCalculationType_MAX = 5,
};

enum class ERigLogicRotationOrder {
    XYZ = 0,
    XZY = 1,
    YXZ = 2,
    YZX = 3,
    ZXY = 4,
    ZYX = 5,
    ERigLogicRotationOrder_MAX = 6,
};

enum class ERigLogicRotationType {
    None = 0,
    EulerAngles = 3,
    Quaternions = 4,
    ERigLogicRotationType_MAX = 5,
};

enum class ERigLogicScaleType {
    None = 0,
    Vector = 3,
    ERigLogicScaleType_MAX = 4,
};

enum class ERigLogicTranslationType {
    None = 0,
    Vector = 3,
    ERigLogicTranslationType_MAX = 4,
};

enum class ERotationRepresentation {
    EulerAngles = 0,
    Quaternion = 1,
    ERotationRepresentation_MAX = 2,
};

enum class ERotationUnit {
    Degrees = 0,
    Radians = 1,
    ERotationUnit_MAX = 2,
};

enum class EScaleRepresentation {
    Vector = 0,
    EScaleRepresentation_MAX = 1,
};

enum class ETranslationRepresentation {
    Vector = 0,
    ETranslationRepresentation_MAX = 1,
};

enum class ETranslationUnit {
    CM = 0,
    M = 1,
    ETranslationUnit_MAX = 2,
};

enum class ETwistAxis {
    X = 0,
    Y = 1,
    Z = 2,
    ETwistAxis_MAX = 3,
};

// Size: 0x8
struct FMeshBlendShapeChannelMapping {
    /* 0x0000 */ int32_t MeshIndex;
    /* 0x0004 */ int32_t BlendShapeChannelIndex;
};

// Size: 0x18
struct FRigLogicConfiguration {
    /* 0x0000 */ ERigLogicCalculationType CalculationType;
    /* 0x0001 */ bool LoadJoints;
    /* 0x0002 */ bool LoadBlendShapes;
    /* 0x0003 */ bool LoadAnimatedMaps;
    /* 0x0004 */ bool LoadMachineLearnedBehavior;
    /* 0x0005 */ bool LoadRBFBehavior;
    /* 0x0006 */ bool LoadTwistSwingBehavior;
    /* 0x0007 */ ERigLogicTranslationType TranslationType;
    /* 0x0008 */ ERigLogicRotationType RotationType;
    /* 0x0009 */ ERigLogicRotationOrder RotationOrder;
    /* 0x000a */ ERigLogicScaleType ScaleType;
    /* 0x000c */ float TranslationPruningThreshold;
    /* 0x0010 */ float RotationPruningThreshold;
    /* 0x0014 */ float ScalePruningThreshold;
};

// Size: 0xc0
struct FRigUnit_RigLogic : public FRigUnitMutable {
    /* 0x0010 */ FRigUnit_RigLogic_Data Data;
    /* 0x00b8 */ bool bIsInitialized;
};

// Size: 0xa8
struct FRigUnit_RigLogic_Data {
    /* 0x0000 */ TWeakObjectPtr<USkeletalMeshComponent> SkelMeshComponent;
    /* 0x0020 */ TArray<int32_t> InputCurveIndices;
    /* 0x0030 */ TArray<int32_t> NeuralNetMaskCurveIndices;
    /* 0x0040 */ TArray<int32_t> HierarchyBoneIndices;
    /* 0x0050 */ TArray<FBoneIndexControlAttributeMapping> DriverJointsToControlAttributesMap;
    /* 0x0060 */ TArray<FRigUnit_RigLogic_IntArray> MorphTargetCurveIndices;
    /* 0x0070 */ TArray<FRigUnit_RigLogic_IntArray> BlendShapeIndices;
    /* 0x0080 */ TArray<FRigUnit_RigLogic_IntArray> CurveElementIndicesForAnimMaps;
    /* 0x0090 */ TArray<FRigUnit_RigLogic_IntArray> RigLogicIndicesForAnimMaps;
    /* 0x00a0 */ uint32_t CurrentLOD;
};

// Size: 0x10
struct FRigUnit_RigLogic_IntArray {
    /* 0x0000 */ TArray<int32_t> Values;
};

// Size: 0x28
class USkelMeshDNAUtils : public UObject {
};

// Size: 0x8
struct FTextureCoordinate {
    /* 0x0000 */ float U;
    /* 0x0004 */ float V;
};

// Size: 0xc
struct FVertexLayout {
    /* 0x0000 */ int32_t position;
    /* 0x0004 */ int32_t TextureCoordinate;
    /* 0x0008 */ int32_t Normal;
};

// Size: 0x130
class UDataAssetLink : public UNameSpacedUserData {
    /* 0x0100 */ TSoftObjectPtr<UDataAsset> DataAsset;
    /* 0x0128 */ UDataAsset* DataAssetCached;

    TSoftObjectPtr<UDataAsset> GetDataAsset() const;
    void SetDataAsset(TSoftObjectPtr<UDataAsset> InDataAsset);
};

enum class ERBFKernelType {
    Gaussian = 0,
    Exponential = 1,
    Linear = 2,
    Cubic = 3,
    Quintic = 4,
    ERBFKernelType_MAX = 5,
};

enum class ERBFQuatDistanceType {
    Euclidean = 0,
    ArcLength = 1,
    SwingAngle = 2,
    TwistAngle = 3,
    ERBFQuatDistanceType_MAX = 4,
};

enum class ERBFVectorDistanceType {
    Euclidean = 0,
    Manhattan = 1,
    ArcLength = 2,
    ERBFVectorDistanceType_MAX = 3,
};

enum class ERigUnitDebugPointMode {
    Point = 0,
    Vector = 1,
    Max = 2,
};

enum class ERigUnitDebugTransformMode {
    Point = 0,
    Axes = 1,
    Box = 2,
    Max = 3,
};

enum class ERigUnitVisualDebugPointMode {
    Point = 0,
    Vector = 1,
    Max = 2,
};

enum class ERigVMAnimEasingType {
    Linear = 0,
    QuadraticEaseIn = 1,
    QuadraticEaseOut = 2,
    QuadraticEaseInOut = 3,
    CubicEaseIn = 4,
    CubicEaseOut = 5,
    CubicEaseInOut = 6,
    QuarticEaseIn = 7,
    QuarticEaseOut = 8,
    QuarticEaseInOut = 9,
    QuinticEaseIn = 10,
    QuinticEaseOut = 11,
    QuinticEaseInOut = 12,
    SineEaseIn = 13,
    SineEaseOut = 14,
    SineEaseInOut = 15,
    CircularEaseIn = 16,
    CircularEaseOut = 17,
    CircularEaseInOut = 18,
    ExponentialEaseIn = 19,
    ExponentialEaseOut = 20,
    ExponentialEaseInOut = 21,
    ElasticEaseIn = 22,
    ElasticEaseOut = 23,
    ElasticEaseInOut = 24,
    BackEaseIn = 25,
    BackEaseOut = 26,
    BackEaseInOut = 27,
    BounceEaseIn = 28,
    BounceEaseOut = 29,
    BounceEaseInOut = 30,
    ERigVMAnimEasingType_MAX = 31,
};

enum class ERigVMBreakpointAction {
    None = 0,
    Resume = 1,
    StepOver = 2,
    StepInto = 3,
    StepOut = 4,
    Max = 5,
};

enum class ERigVMClampSpatialMode {
    Plane = 0,
    Cylinder = 1,
    Sphere = 2,
    Capsule = 3,
    ERigVMClampSpatialMode_MAX = 4,
};

enum class ERigVMCopyType {
    Default = 0,
    FloatToDouble = 1,
    DoubleToFloat = 2,
    ERigVMCopyType_MAX = 3,
};

enum class ERigVMDrawSettings {
    Points = 0,
    Lines = 1,
    LineStrip = 2,
    DynamicMesh = 3,
    ERigVMDrawSettings_MAX = 4,
};

enum class ERigVMFunctionArgumentDirection {
    Input = 0,
    Output = 1,
    Invalid = 2,
    ERigVMFunctionArgumentDirection_MAX = 3,
};

enum class ERigVMMemoryType {
    Work = 0,
    Literal = 1,
    External = 2,
    Debug = 3,
    Invalid = 4,
    ERigVMMemoryType_MAX = 5,
};

enum class ERigVMOpCode {
    Execute_0_Operands = 0,
    Execute_1_Operands = 1,
    Execute_2_Operands = 2,
    Execute_3_Operands = 3,
    Execute_4_Operands = 4,
    Execute_5_Operands = 5,
    Execute_6_Operands = 6,
    Execute_7_Operands = 7,
    Execute_8_Operands = 8,
    Execute_9_Operands = 9,
    Execute_10_Operands = 10,
    Execute_11_Operands = 11,
    Execute_12_Operands = 12,
    Execute_13_Operands = 13,
    Execute_14_Operands = 14,
    Execute_15_Operands = 15,
    Execute_16_Operands = 16,
    Execute_17_Operands = 17,
    Execute_18_Operands = 18,
    Execute_19_Operands = 19,
    Execute_20_Operands = 20,
    Execute_21_Operands = 21,
    Execute_22_Operands = 22,
    Execute_23_Operands = 23,
    Execute_24_Operands = 24,
    Execute_25_Operands = 25,
    Execute_26_Operands = 26,
    Execute_27_Operands = 27,
    Execute_28_Operands = 28,
    Execute_29_Operands = 29,
    Execute_30_Operands = 30,
    Execute_31_Operands = 31,
    Execute_32_Operands = 32,
    Execute_33_Operands = 33,
    Execute_34_Operands = 34,
    Execute_35_Operands = 35,
    Execute_36_Operands = 36,
    Execute_37_Operands = 37,
    Execute_38_Operands = 38,
    Execute_39_Operands = 39,
    Execute_40_Operands = 40,
    Execute_41_Operands = 41,
    Execute_42_Operands = 42,
    Execute_43_Operands = 43,
    Execute_44_Operands = 44,
    Execute_45_Operands = 45,
    Execute_46_Operands = 46,
    Execute_47_Operands = 47,
    Execute_48_Operands = 48,
    Execute_49_Operands = 49,
    Execute_50_Operands = 50,
    Execute_51_Operands = 51,
    Execute_52_Operands = 52,
    Execute_53_Operands = 53,
    Execute_54_Operands = 54,
    Execute_55_Operands = 55,
    Execute_56_Operands = 56,
    Execute_57_Operands = 57,
    Execute_58_Operands = 58,
    Execute_59_Operands = 59,
    Execute_60_Operands = 60,
    Execute_61_Operands = 61,
    Execute_62_Operands = 62,
    Execute_63_Operands = 63,
    Execute_64_Operands = 64,
    Zero = 65,
    BoolFalse = 66,
    BoolTrue = 67,
    Copy = 68,
    Increment = 69,
    Decrement = 70,
    Equals = 71,
    NotEquals = 72,
    JumpAbsolute = 73,
    JumpForward = 74,
    JumpBackward = 75,
    JumpAbsoluteIf = 76,
    JumpForwardIf = 77,
    JumpBackwardIf = 78,
    ChangeType = 79,
    Exit = 80,
    BeginBlock = 81,
    EndBlock = 82,
    ArrayReset = 83,
    ArrayGetNum = 84,
    ArraySetNum = 85,
    ArrayGetAtIndex = 86,
    ArraySetAtIndex = 87,
    ArrayAdd = 88,
    ArrayInsert = 89,
    ArrayRemove = 90,
    ArrayFind = 91,
    ArrayAppend = 92,
    ArrayClone = 93,
    ArrayIterator = 94,
    ArrayUnion = 95,
    ArrayDifference = 96,
    ArrayIntersection = 97,
    ArrayReverse = 98,
    InvokeEntry = 99,
    JumpToBranch = 100,
    Execute = 101,
    RunInstructions = 102,
    SetupTraits = 103,
    Invalid = 104,
    FirstArrayOpCode = 83,
    LastArrayOpCode = 98,
    ERigVMOpCode_MAX = 105,
};

enum class ERigVMParameterType {
    Input = 0,
    Output = 1,
    Invalid = 2,
    ERigVMParameterType_MAX = 3,
};

enum class ERigVMPinDirection {
    Input = 0,
    Output = 1,
    IO = 2,
    Visible = 3,
    Hidden = 4,
    Invalid = 5,
    ERigVMPinDirection_MAX = 6,
};

enum class ERigVMRegisterType {
    Plain = 0,
    String = 1,
    Name = 2,
    Struct = 3,
    Invalid = 4,
    ERigVMRegisterType_MAX = 5,
};

enum class ERigVMSimPointIntegrateType {
    Verlet = 0,
    SemiExplicitEuler = 1,
    ERigVMSimPointIntegrateType_MAX = 2,
};

enum class ERigVMTransformSpace {
    LocalSpace = 0,
    GlobalSpace = 1,
    Max = 2,
};

enum class ERigVMUserWorkflowType {
    Invalid = 0,
    NodeContext = 1,
    PinContext = 2,
    OnPinDefaultChanged = 4,
    NodeContextButton = 8,
    All = 15,
    ERigVMUserWorkflowType_MAX = 16,
};

// Size: 0x30
struct FMathRBFInterpolateQuatColor_Target {
    /* 0x0000 */ FQuat Target;
    /* 0x0020 */ FLinearColor Value;
};

// Size: 0x30
struct FMathRBFInterpolateQuatFloat_Target {
    /* 0x0000 */ FQuat Target;
    /* 0x0020 */ float Value;
};

// Size: 0x40
struct FMathRBFInterpolateQuatQuat_Target {
    /* 0x0000 */ FQuat Target;
    /* 0x0020 */ FQuat Value;
};

// Size: 0x40
struct FMathRBFInterpolateQuatVector_Target {
    /* 0x0000 */ FQuat Target;
    /* 0x0020 */ FVector Value;
};

// Size: 0x80
struct FMathRBFInterpolateQuatXform_Target {
    /* 0x0000 */ FQuat Target;
    /* 0x0020 */ FTransform Value;
};

// Size: 0x28
struct FMathRBFInterpolateVectorColor_Target {
    /* 0x0000 */ FVector Target;
    /* 0x0018 */ FLinearColor Value;
};

// Size: 0x20
struct FMathRBFInterpolateVectorFloat_Target {
    /* 0x0000 */ FVector Target;
    /* 0x0018 */ float Value;
};

// Size: 0x40
struct FMathRBFInterpolateVectorQuat_Target {
    /* 0x0000 */ FVector Target;
    /* 0x0020 */ FQuat Value;
};

// Size: 0x30
struct FMathRBFInterpolateVectorVector_Target {
    /* 0x0000 */ FVector Target;
    /* 0x0018 */ FVector Value;
};

// Size: 0x80
struct FMathRBFInterpolateVectorXform_Target {
    /* 0x0000 */ FVector Target;
    /* 0x0020 */ FTransform Value;
};

// Size: 0x100
class UNameSpacedUserData : public UAssetUserData {
    /* 0x0028 */ FString Namespace;
};

// Size: 0x70
struct FRigDispatch_FromString : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigDispatch_ToString : public FRigVMDispatchFactory {
};

// Size: 0x388
class URigVM : public UObject {
    /* 0x0028 */ FRigVMMemoryStorageStruct LiteralMemoryStorage;
    /* 0x0078 */ FRigVMMemoryStorageStruct DefaultWorkMemoryStorage;
    /* 0x00c8 */ FRigVMMemoryStorageStruct DefaultDebugMemoryStorage;
    /* 0x0138 */ FRigVMByteCode ByteCodeStorage;
    /* 0x01f0 */ FRigVMInstructionArray Instructions;
    /* 0x0200 */ TArray<FName> FunctionNamesStorage;
    /* 0x0248 */ TArray<FRigVMParameter> Parameters;
    /* 0x0330 */ uint32_t CachedVMHash;

    int32_t AddRigVMFunction(UScriptStruct* InRigVMStruct, const FName& InMethodName);
    bool Execute(FRigVMExtendedExecuteContext& Context, const FName& InEntryName);
    bool GetParameterValueBool(const FName& InParameterName, int32_t InArrayIndex);
    double GetParameterValueDouble(const FName& InParameterName, int32_t InArrayIndex);
    float GetParameterValueFloat(const FName& InParameterName, int32_t InArrayIndex);
    int32_t GetParameterValueInt(const FName& InParameterName, int32_t InArrayIndex);
    FName GetParameterValueName(const FName& InParameterName, int32_t InArrayIndex);
    FQuat GetParameterValueQuat(const FName& InParameterName, int32_t InArrayIndex);
    FString GetParameterValueString(const FName& InParameterName, int32_t InArrayIndex);
    FTransform GetParameterValueTransform(const FName& InParameterName, int32_t InArrayIndex);
    FVector GetParameterValueVector(const FName& InParameterName, int32_t InArrayIndex);
    FVector2D GetParameterValueVector2D(const FName& InParameterName, int32_t InArrayIndex);
    FString GetRigVMFunctionName(int32_t InFunctionIndex) const;
    FRigVMStatistics GetStatistics() const;
    void SetParameterValueBool(const FName& InParameterName, bool InValue, int32_t InArrayIndex);
    void SetParameterValueDouble(const FName& InParameterName, double InValue, int32_t InArrayIndex);
    void SetParameterValueFloat(const FName& InParameterName, float InValue, int32_t InArrayIndex);
    void SetParameterValueInt(const FName& InParameterName, int32_t InValue, int32_t InArrayIndex);
    void SetParameterValueName(const FName& InParameterName, const FName& InValue, int32_t InArrayIndex);
    void SetParameterValueQuat(const FName& InParameterName, const FQuat& InValue, int32_t InArrayIndex);
    void SetParameterValueString(const FName& InParameterName, FString InValue, int32_t InArrayIndex);
    void SetParameterValueTransform(const FName& InParameterName, const FTransform& InValue, int32_t InArrayIndex);
    void SetParameterValueVector(const FName& InParameterName, const FVector& InValue, int32_t InArrayIndex);
    void SetParameterValueVector2D(const FName& InParameterName, const FVector2D& InValue, int32_t InArrayIndex);
};

// Size: 0x1
struct FRigVMBaseOp {
};

// Size: 0xe
struct FRigVMBinaryOp : public FRigVMBaseOp {
};

// Size: 0x388
class URigVMBlueprintGeneratedClass : public UBlueprintGeneratedClass {
    /* 0x0368 */ FRigVMGraphFunctionStore GraphFunctionStore;
};

// Size: 0x1c
struct FRigVMBranchInfo {
    /* 0x0000 */ int32_t Index;
    /* 0x0004 */ FName Label;
    /* 0x000c */ int32_t InstructionIndex;
    /* 0x0010 */ int32_t ArgumentIndex;
    /* 0x0014 */ int32_t FirstInstruction;
    /* 0x0018 */ int32_t LastInstruction;
};

// Size: 0x24
struct FRigVMBreakpoint {
};

// Size: 0xb0
struct FRigVMByteCode {
    /* 0x0000 */ TArray<uint8_t> ByteCode;
    /* 0x0010 */ int32_t NumInstructions;
    /* 0x0018 */ TArray<FRigVMByteCodeEntry> Entries;
    /* 0x0028 */ TArray<FRigVMBranchInfo> BranchInfos;
    /* 0x0038 */ TArray<FRigVMPredicateBranch> PredicateBranches;
    /* 0x0048 */ FTopLevelAssetPath PublicContextAssetPath;
};

// Size: 0xc
struct FRigVMByteCodeEntry {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t InstructionIndex;
};

// Size: 0x8
struct FRigVMByteCodeStatistics {
    /* 0x0000 */ int32_t InstructionCount;
    /* 0x0004 */ int32_t DataBytes;
};

// Size: 0x8
struct FRigVMChangeTypeOp : public FRigVMUnaryOp {
};

// Size: 0x14
struct FRigVMComparisonOp : public FRigVMBaseOp {
};

// Size: 0x10
struct FRigVMCopyOp : public FRigVMBaseOp {
};

// Size: 0x8
struct FRigVMDebugDrawSettings {
    /* 0x0000 */ uint8_t DepthPriority;
    /* 0x0004 */ float Lifetime;
};

// Size: 0x140
struct FRigVMDebugInfo {
};

// Size: 0x70
struct FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_ArrayAdd : public FRigVMDispatch_ArraySetAtIndex {
};

// Size: 0x70
struct FRigVMDispatch_ArrayAppend : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayBase : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayBaseMutable : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayClone : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayDifference : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayFind : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayGetAtIndex : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayGetNum : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayInit : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayInsert : public FRigVMDispatch_ArraySetAtIndex {
};

// Size: 0x70
struct FRigVMDispatch_ArrayIntersection : public FRigVMDispatch_ArrayDifference {
};

// Size: 0x70
struct FRigVMDispatch_ArrayIterator : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayMake : public FRigVMDispatch_ArrayBase {
};

// Size: 0x70
struct FRigVMDispatch_ArrayRemove : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayReset : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayReverse : public FRigVMDispatch_ArrayReset {
};

// Size: 0x70
struct FRigVMDispatch_ArraySetAtIndex : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArraySetNum : public FRigVMDispatch_ArrayBaseMutable {
};

// Size: 0x70
struct FRigVMDispatch_ArrayUnion : public FRigVMDispatch_ArrayAppend {
};

// Size: 0x70
struct FRigVMDispatch_BreakStruct : public FRigVMDispatch_MakeStruct {
};

// Size: 0x70
struct FRigVMDispatch_CastEnumToInt : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_CastIntToEnum : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_CastObject : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_Constant : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_CoreBase : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_CoreEquals : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_CoreNotEquals : public FRigVMDispatch_CoreEquals {
};

// Size: 0x70
struct FRigVMDispatch_If : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_MakeStruct : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_Print : public FRigVMDispatchFactory {
};

// Size: 0x70
struct FRigVMDispatch_SelectInt32 : public FRigVMDispatch_CoreBase {
};

// Size: 0x70
struct FRigVMDispatch_SwitchInt32 : public FRigVMDispatch_CoreBase {
};

// Size: 0x18
struct FRigVMDrawContainer {
    /* 0x0008 */ TArray<FRigVMDrawInstruction> Instructions;
};

// Size: 0xd0
struct FRigVMDrawInstruction {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ uint8_t PrimitiveType;
    /* 0x0010 */ TArray<FVector> Positions;
    /* 0x0020 */ FLinearColor Color;
    /* 0x0030 */ float Thickness;
    /* 0x0040 */ FTransform Transform;
    /* 0x00a0 */ uint8_t DepthPriority;
    /* 0x00a4 */ float Lifetime;
};

// Size: 0x18
struct FRigVMDrawInterface : public FRigVMDrawContainer {
};

// Size: 0x38
class URigVMEditorSettings : public UDeveloperSettings {
};

// Size: 0x110
struct FRigVMExecuteContext : public FRigVMExecutePin {
};

// Size: 0xa
struct FRigVMExecuteOp : public FRigVMBaseOp {
};

// Size: 0x8
struct FRigVMExecutePin {
};

// Size: 0x240
struct FRigVMExtendedExecuteContext {
};

// Size: 0x30
struct FRigVMExternalVariable : public FRigVMExternalVariableDef {
};

// Size: 0x28
struct FRigVMExternalVariableDef {
};

// Size: 0x60
struct FRigVMFourPointBezier {
    /* 0x0000 */ FVector A;
    /* 0x0018 */ FVector B;
    /* 0x0030 */ FVector C;
    /* 0x0048 */ FVector D;
};

// Size: 0x238
struct FRigVMFunctionCompilationData {
    /* 0x0000 */ FRigVMByteCode ByteCode;
    /* 0x00b0 */ TArray<FName> FunctionNames;
    /* 0x00c0 */ TArray<FRigVMFunctionCompilationPropertyDescription> WorkPropertyDescriptions;
    /* 0x00d0 */ TArray<FRigVMFunctionCompilationPropertyPath> WorkPropertyPathDescriptions;
    /* 0x00e0 */ TArray<FRigVMFunctionCompilationPropertyDescription> LiteralPropertyDescriptions;
    /* 0x00f0 */ TArray<FRigVMFunctionCompilationPropertyPath> LiteralPropertyPathDescriptions;
    /* 0x0100 */ TArray<FRigVMFunctionCompilationPropertyDescription> DebugPropertyDescriptions;
    /* 0x0110 */ TArray<FRigVMFunctionCompilationPropertyPath> DebugPropertyPathDescriptions;
    /* 0x0120 */ TArray<FRigVMFunctionCompilationPropertyDescription> ExternalPropertyDescriptions;
    /* 0x0130 */ TArray<FRigVMFunctionCompilationPropertyPath> ExternalPropertyPathDescriptions;
    /* 0x0140 */ TMap<int32_t, FName> ExternalRegisterIndexToVariable;
    /* 0x0190 */ TMap<FString, FRigVMOperand> Operands;
    /* 0x01e0 */ uint32_t Hash;
    /* 0x01e4 */ bool bEncounteredSurpressedErrors;
};

// Size: 0x50
struct FRigVMFunctionCompilationPropertyDescription {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FString CPPType;
    /* 0x0018 */ TSoftObjectPtr<UObject> CPPTypeObject;
    /* 0x0040 */ FString DefaultValue;
};

// Size: 0x28
struct FRigVMFunctionCompilationPropertyPath {
    /* 0x0000 */ int32_t PropertyIndex;
    /* 0x0008 */ FString HeadCPPType;
    /* 0x0018 */ FString SegmentPath;
};

// Size: 0x8
struct FRigVMFunction_AccumulateBase : public FRigVMFunction_SimBase {
};

// Size: 0x20
struct FRigVMFunction_AccumulateFloatAdd : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ float Increment;
    /* 0x000c */ float InitialValue;
    /* 0x0010 */ bool bIntegrateDeltaTime;
    /* 0x0014 */ float Result;
    /* 0x0018 */ float AccumulatedValue;
    /* 0x001c */ bool bIsInitialized;
};

// Size: 0x28
struct FRigVMFunction_AccumulateFloatLerp : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ float TargetValue;
    /* 0x000c */ float InitialValue;
    /* 0x0010 */ float Blend;
    /* 0x0014 */ bool bIntegrateDeltaTime;
    /* 0x0018 */ float Result;
    /* 0x001c */ float AccumulatedValue;
    /* 0x0020 */ bool bIsInitialized;
};

// Size: 0x20
struct FRigVMFunction_AccumulateFloatMul : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ float Multiplier;
    /* 0x000c */ float InitialValue;
    /* 0x0010 */ bool bIntegrateDeltaTime;
    /* 0x0014 */ float Result;
    /* 0x0018 */ float AccumulatedValue;
    /* 0x001c */ bool bIsInitialized;
};

// Size: 0x20
struct FRigVMFunction_AccumulateFloatRange : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Minimum;
    /* 0x0010 */ float Maximum;
    /* 0x0014 */ float AccumulatedMinimum;
    /* 0x0018 */ float AccumulatedMaximum;
    /* 0x001c */ bool bIsInitialized;
};

// Size: 0xb0
struct FRigVMFunction_AccumulateQuatLerp : public FRigVMFunction_AccumulateBase {
    /* 0x0010 */ FQuat TargetValue;
    /* 0x0030 */ FQuat InitialValue;
    /* 0x0050 */ float Blend;
    /* 0x0054 */ bool bIntegrateDeltaTime;
    /* 0x0060 */ FQuat Result;
    /* 0x0080 */ FQuat AccumulatedValue;
    /* 0x00a0 */ bool bIsInitialized;
};

// Size: 0xb0
struct FRigVMFunction_AccumulateQuatMul : public FRigVMFunction_AccumulateBase {
    /* 0x0010 */ FQuat Multiplier;
    /* 0x0030 */ FQuat InitialValue;
    /* 0x0050 */ bool bFlipOrder;
    /* 0x0051 */ bool bIntegrateDeltaTime;
    /* 0x0060 */ FQuat Result;
    /* 0x0080 */ FQuat AccumulatedValue;
    /* 0x00a0 */ bool bIsInitialized;
};

// Size: 0x1b0
struct FRigVMFunction_AccumulateTransformLerp : public FRigVMFunction_AccumulateBase {
    /* 0x0010 */ FTransform TargetValue;
    /* 0x0070 */ FTransform InitialValue;
    /* 0x00d0 */ float Blend;
    /* 0x00d4 */ bool bIntegrateDeltaTime;
    /* 0x00e0 */ FTransform Result;
    /* 0x0140 */ FTransform AccumulatedValue;
    /* 0x01a0 */ bool bIsInitialized;
};

// Size: 0x1b0
struct FRigVMFunction_AccumulateTransformMul : public FRigVMFunction_AccumulateBase {
    /* 0x0010 */ FTransform Multiplier;
    /* 0x0070 */ FTransform InitialValue;
    /* 0x00d0 */ bool bFlipOrder;
    /* 0x00d1 */ bool bIntegrateDeltaTime;
    /* 0x00e0 */ FTransform Result;
    /* 0x0140 */ FTransform AccumulatedValue;
    /* 0x01a0 */ bool bIsInitialized;
};

// Size: 0x78
struct FRigVMFunction_AccumulateVectorAdd : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ FVector Increment;
    /* 0x0020 */ FVector InitialValue;
    /* 0x0038 */ bool bIntegrateDeltaTime;
    /* 0x0040 */ FVector Result;
    /* 0x0058 */ FVector AccumulatedValue;
    /* 0x0070 */ bool bIsInitialized;
};

// Size: 0x78
struct FRigVMFunction_AccumulateVectorLerp : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ FVector TargetValue;
    /* 0x0020 */ FVector InitialValue;
    /* 0x0038 */ float Blend;
    /* 0x003c */ bool bIntegrateDeltaTime;
    /* 0x0040 */ FVector Result;
    /* 0x0058 */ FVector AccumulatedValue;
    /* 0x0070 */ bool bIsInitialized;
};

// Size: 0x78
struct FRigVMFunction_AccumulateVectorMul : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ FVector Multiplier;
    /* 0x0020 */ FVector InitialValue;
    /* 0x0038 */ bool bIntegrateDeltaTime;
    /* 0x0040 */ FVector Result;
    /* 0x0058 */ FVector AccumulatedValue;
    /* 0x0070 */ bool bIsInitialized;
};

// Size: 0x88
struct FRigVMFunction_AccumulateVectorRange : public FRigVMFunction_AccumulateBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Minimum;
    /* 0x0038 */ FVector Maximum;
    /* 0x0050 */ FVector AccumulatedMinimum;
    /* 0x0068 */ FVector AccumulatedMaximum;
    /* 0x0080 */ bool bIsInitialized;
};

// Size: 0x78
struct FRigVMFunction_AlphaInterp : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Scale;
    /* 0x0010 */ float Bias;
    /* 0x0014 */ bool bMapRange;
    /* 0x0018 */ FInputRange InRange;
    /* 0x0020 */ FInputRange OutRange;
    /* 0x0028 */ bool bClampResult;
    /* 0x002c */ float ClampMin;
    /* 0x0030 */ float ClampMax;
    /* 0x0034 */ bool bInterpResult;
    /* 0x0038 */ float InterpSpeedIncreasing;
    /* 0x003c */ float InterpSpeedDecreasing;
    /* 0x0040 */ float Result;
    /* 0x0044 */ FInputScaleBiasClamp ScaleBiasClamp;
};

// Size: 0xc0
struct FRigVMFunction_AlphaInterpQuat : public FRigVMFunction_SimBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ float Scale;
    /* 0x0034 */ float Bias;
    /* 0x0038 */ bool bMapRange;
    /* 0x003c */ FInputRange InRange;
    /* 0x0044 */ FInputRange OutRange;
    /* 0x004c */ bool bClampResult;
    /* 0x0050 */ float ClampMin;
    /* 0x0054 */ float ClampMax;
    /* 0x0058 */ bool bInterpResult;
    /* 0x005c */ float InterpSpeedIncreasing;
    /* 0x0060 */ float InterpSpeedDecreasing;
    /* 0x0070 */ FQuat Result;
    /* 0x0090 */ FInputScaleBiasClamp ScaleBiasClamp;
};

// Size: 0xa0
struct FRigVMFunction_AlphaInterpVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Scale;
    /* 0x0024 */ float Bias;
    /* 0x0028 */ bool bMapRange;
    /* 0x002c */ FInputRange InRange;
    /* 0x0034 */ FInputRange OutRange;
    /* 0x003c */ bool bClampResult;
    /* 0x0040 */ float ClampMin;
    /* 0x0044 */ float ClampMax;
    /* 0x0048 */ bool bInterpResult;
    /* 0x004c */ float InterpSpeedIncreasing;
    /* 0x0050 */ float InterpSpeedDecreasing;
    /* 0x0058 */ FVector Result;
    /* 0x0070 */ FInputScaleBiasClamp ScaleBiasClamp;
};

// Size: 0x8
struct FRigVMFunction_AnimBase : public FRigVMStruct {
};

// Size: 0x28
struct FRigVMFunction_AnimEasing : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ ERigVMAnimEasingType Type;
    /* 0x0010 */ float SourceMinimum;
    /* 0x0014 */ float SourceMaximum;
    /* 0x0018 */ float TargetMinimum;
    /* 0x001c */ float TargetMaximum;
    /* 0x0020 */ float Result;
};

// Size: 0x10
struct FRigVMFunction_AnimEasingType : public FRigVMFunction_AnimBase {
    /* 0x0008 */ ERigVMAnimEasingType Type;
};

// Size: 0xb0
struct FRigVMFunction_AnimEvalRichCurve : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float Value;
    /* 0x0010 */ FRuntimeFloatCurve Curve;
    /* 0x0098 */ float SourceMinimum;
    /* 0x009c */ float SourceMaximum;
    /* 0x00a0 */ float TargetMinimum;
    /* 0x00a4 */ float TargetMaximum;
    /* 0x00a8 */ float Result;
};

// Size: 0x90
struct FRigVMFunction_AnimRichCurve : public FRigVMFunction_AnimBase {
    /* 0x0008 */ FRuntimeFloatCurve Curve;
};

// Size: 0x20
struct FRigVMFunction_Contains : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName search;
    /* 0x0018 */ bool Result;
};

// Size: 0x8
struct FRigVMFunction_ControlFlowBase : public FRigVMStruct {
};

// Size: 0x470
struct FRigVMFunction_ControlFlowBranch : public FRigVMFunction_ControlFlowBase {
    /* 0x0010 */ FRigVMExecuteContext ExecuteContext;
    /* 0x0120 */ bool Condition;
    /* 0x0130 */ FRigVMExecuteContext TRUE;
    /* 0x0240 */ FRigVMExecuteContext FALSE;
    /* 0x0350 */ FRigVMExecuteContext completed;
    /* 0x0460 */ FName BlockToRun;
};

// Size: 0x120
struct FRigVMFunction_DebugArc : public FRigVMFunction_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Radius;
    /* 0x0094 */ float MinimumDegrees;
    /* 0x0098 */ float MaximumDegrees;
    /* 0x009c */ float Thickness;
    /* 0x00a0 */ int32_t Detail;
    /* 0x00a4 */ FName Space;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x120
struct FRigVMFunction_DebugArcNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Radius;
    /* 0x0094 */ float MinimumDegrees;
    /* 0x0098 */ float MaximumDegrees;
    /* 0x009c */ float Thickness;
    /* 0x00a0 */ int32_t Detail;
    /* 0x00b0 */ FTransform worldOffset;
    /* 0x0110 */ bool bEnabled;
};

// Size: 0x10
struct FRigVMFunction_DebugBase : public FRigVMStruct {
    /* 0x0008 */ FRigVMDebugDrawSettings DebugDrawSettings;
};

// Size: 0x18
struct FRigVMFunction_DebugBaseMutable : public FRigVMStructMutable {
    /* 0x0010 */ FRigVMDebugDrawSettings DebugDrawSettings;
};

// Size: 0xe0
struct FRigVMFunction_DebugBoxNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FBox Box;
    /* 0x0050 */ FLinearColor Color;
    /* 0x0060 */ float Thickness;
    /* 0x0070 */ FTransform worldOffset;
    /* 0x00d0 */ bool bEnabled;
};

// Size: 0xd0
struct FRigVMFunction_DebugLineNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FVector A;
    /* 0x0030 */ FVector B;
    /* 0x0048 */ FLinearColor Color;
    /* 0x0058 */ float Thickness;
    /* 0x0060 */ FTransform worldOffset;
    /* 0x00c0 */ bool bEnabled;
};

// Size: 0xb0
struct FRigVMFunction_DebugLineStripNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ TArray<FVector> points;
    /* 0x0028 */ FLinearColor Color;
    /* 0x0038 */ float Thickness;
    /* 0x0040 */ FTransform worldOffset;
    /* 0x00a0 */ bool bEnabled;
};

// Size: 0xc0
struct FRigVMFunction_DebugPoint : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FVector Vector;
    /* 0x0028 */ ERigUnitDebugPointMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Scale;
    /* 0x0040 */ float Thickness;
    /* 0x0044 */ FName Space;
    /* 0x0050 */ FTransform worldOffset;
    /* 0x00b0 */ bool bEnabled;
};

// Size: 0xd0
struct FRigVMFunction_DebugPointMutable : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FVector Vector;
    /* 0x0030 */ ERigUnitDebugPointMode Mode;
    /* 0x0034 */ FLinearColor Color;
    /* 0x0044 */ float Scale;
    /* 0x0048 */ float Thickness;
    /* 0x004c */ FName Space;
    /* 0x0060 */ FTransform worldOffset;
    /* 0x00c0 */ bool bEnabled;
};

// Size: 0x110
struct FRigVMFunction_DebugRectangle : public FRigVMFunction_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Scale;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ FName Space;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0x110
struct FRigVMFunction_DebugRectangleNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ FLinearColor Color;
    /* 0x0090 */ float Scale;
    /* 0x0094 */ float Thickness;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0xd0
struct FRigVMFunction_DebugTransformArrayMutableNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ TArray<FTransform> Transforms;
    /* 0x0028 */ TArray<int32_t> ParentIndices;
    /* 0x0038 */ ERigUnitDebugTransformMode Mode;
    /* 0x003c */ FLinearColor Color;
    /* 0x004c */ float Thickness;
    /* 0x0050 */ float Scale;
    /* 0x0060 */ FTransform worldOffset;
    /* 0x00c0 */ bool bEnabled;
};

// Size: 0x10
struct FRigVMFunction_DebugTransformArrayMutable_WorkData {
    /* 0x0000 */ TArray<FTransform> DrawTransforms;
};

// Size: 0x110
struct FRigVMFunction_DebugTransformMutableNoSpace : public FRigVMFunction_DebugBaseMutable {
    /* 0x0020 */ FTransform Transform;
    /* 0x0080 */ ERigUnitDebugTransformMode Mode;
    /* 0x0084 */ FLinearColor Color;
    /* 0x0094 */ float Thickness;
    /* 0x0098 */ float Scale;
    /* 0x00a0 */ FTransform worldOffset;
    /* 0x0100 */ bool bEnabled;
};

// Size: 0x20
struct FRigVMFunction_DeltaFromPreviousFloat : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Delta;
    /* 0x0010 */ float PreviousValue;
    /* 0x0014 */ float Cache;
    /* 0x0018 */ bool bIsInitialized;
};

// Size: 0xa0
struct FRigVMFunction_DeltaFromPreviousQuat : public FRigVMFunction_SimBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FQuat Delta;
    /* 0x0050 */ FQuat PreviousValue;
    /* 0x0070 */ FQuat Cache;
    /* 0x0090 */ bool bIsInitialized;
};

// Size: 0x1a0
struct FRigVMFunction_DeltaFromPreviousTransform : public FRigVMFunction_SimBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FTransform Delta;
    /* 0x00d0 */ FTransform PreviousValue;
    /* 0x0130 */ FTransform Cache;
    /* 0x0190 */ bool bIsInitialized;
};

// Size: 0x70
struct FRigVMFunction_DeltaFromPreviousVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Delta;
    /* 0x0038 */ FVector PreviousValue;
    /* 0x0050 */ FVector Cache;
    /* 0x0068 */ bool bIsInitialized;
};

// Size: 0x20
struct FRigVMFunction_EndsWith : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName Ending;
    /* 0x0018 */ bool Result;
};

// Size: 0x140
struct FRigVMFunction_ForLoopCount : public FRigVMStructMutable {
    /* 0x0010 */ FName BlockToRun;
    /* 0x0018 */ int32_t Count;
    /* 0x001c */ int32_t Index;
    /* 0x0020 */ float Ratio;
    /* 0x0030 */ FRigVMExecuteContext completed;
};

// Size: 0x10
struct FRigVMFunction_FramesToSeconds : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float Frames;
    /* 0x000c */ float Seconds;
};

// Size: 0x10
struct FRigVMFunction_GetDeltaTime : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float Result;
};

// Size: 0x28
struct FRigVMFunction_GetWorldTime : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float year;
    /* 0x000c */ float Month;
    /* 0x0010 */ float day;
    /* 0x0014 */ float WeekDay;
    /* 0x0018 */ float Hours;
    /* 0x001c */ float Minutes;
    /* 0x0020 */ float Seconds;
    /* 0x0024 */ float OverallSeconds;
};

// Size: 0x10
struct FRigVMFunction_IsHostBeingDebugged : public FRigVMStruct {
    /* 0x0008 */ bool Result;
};

// Size: 0x30
struct FRigVMFunction_KalmanFloat : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ int32_t BufferSize;
    /* 0x0010 */ float Result;
    /* 0x0018 */ TArray<float> Buffer;
    /* 0x0028 */ int32_t LastInsertIndex;
};

// Size: 0x100
struct FRigVMFunction_KalmanTransform : public FRigVMFunction_SimBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ int32_t BufferSize;
    /* 0x0080 */ FTransform Result;
    /* 0x00e0 */ TArray<FTransform> Buffer;
    /* 0x00f0 */ int32_t LastInsertIndex;
};

// Size: 0x58
struct FRigVMFunction_KalmanVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ int32_t BufferSize;
    /* 0x0028 */ FVector Result;
    /* 0x0040 */ TArray<FVector> Buffer;
    /* 0x0050 */ int32_t LastInsertIndex;
};

// Size: 0x8
struct FRigVMFunction_MathBase : public FRigVMStruct {
};

// Size: 0x10
struct FRigVMFunction_MathBoolAnd : public FRigVMFunction_MathBoolBinaryAggregateOp {
};

// Size: 0x8
struct FRigVMFunction_MathBoolBase : public FRigVMFunction_MathBase {
};

// Size: 0x10
struct FRigVMFunction_MathBoolBinaryAggregateOp : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool A;
    /* 0x0009 */ bool B;
    /* 0x000a */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathBoolBinaryOp : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool A;
    /* 0x0009 */ bool B;
    /* 0x000a */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathBoolConstFalse : public FRigVMFunction_MathBoolConstant {
};

// Size: 0x10
struct FRigVMFunction_MathBoolConstTrue : public FRigVMFunction_MathBoolConstant {
};

// Size: 0x10
struct FRigVMFunction_MathBoolConstant : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
};

// Size: 0x10
struct FRigVMFunction_MathBoolEquals : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool A;
    /* 0x0009 */ bool B;
    /* 0x000a */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathBoolFlipFlop : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool StartValue;
    /* 0x000c */ float Duration;
    /* 0x0010 */ bool Result;
    /* 0x0011 */ bool LastValue;
    /* 0x0014 */ float TimeLeft;
};

// Size: 0x10
struct FRigVMFunction_MathBoolMake : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
};

// Size: 0x10
struct FRigVMFunction_MathBoolNand : public FRigVMFunction_MathBoolBinaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathBoolNand2 : public FRigVMFunction_MathBoolBinaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathBoolNot : public FRigVMFunction_MathBoolUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathBoolNotEquals : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool A;
    /* 0x0009 */ bool B;
    /* 0x000a */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathBoolOnce : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ float Duration;
    /* 0x000c */ bool Result;
    /* 0x000d */ bool LastValue;
    /* 0x0010 */ float TimeLeft;
};

// Size: 0x10
struct FRigVMFunction_MathBoolOr : public FRigVMFunction_MathBoolBinaryAggregateOp {
};

// Size: 0x10
struct FRigVMFunction_MathBoolToFloat : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
    /* 0x000c */ float Result;
};

// Size: 0x10
struct FRigVMFunction_MathBoolToInteger : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
    /* 0x000c */ int32_t Result;
};

// Size: 0x10
struct FRigVMFunction_MathBoolToggled : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
    /* 0x0009 */ bool Toggled;
    /* 0x000a */ bool Initialized;
    /* 0x000b */ bool LastValue;
};

// Size: 0x10
struct FRigVMFunction_MathBoolUnaryOp : public FRigVMFunction_MathBoolBase {
    /* 0x0008 */ bool Value;
    /* 0x0009 */ bool Result;
};

// Size: 0x8
struct FRigVMFunction_MathBoxBase : public FRigVMFunction_MathBase {
};

// Size: 0x90
struct FRigVMFunction_MathBoxExpand : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector amount;
    /* 0x0058 */ FBox Result;
};

// Size: 0xb0
struct FRigVMFunction_MathBoxFromArray : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ TArray<FVector> Array;
    /* 0x0018 */ FBox Box;
    /* 0x0050 */ FVector Minimum;
    /* 0x0068 */ FVector Maximum;
    /* 0x0080 */ FVector Center;
    /* 0x0098 */ FVector Size;
};

// Size: 0x58
struct FRigVMFunction_MathBoxGetCenter : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector Center;
};

// Size: 0x60
struct FRigVMFunction_MathBoxGetDistance : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector position;
    /* 0x0058 */ bool Square;
    /* 0x0059 */ bool Valid;
    /* 0x005c */ float Distance;
};

// Size: 0x70
struct FRigVMFunction_MathBoxGetSize : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector Size;
    /* 0x0058 */ FVector Extent;
};

// Size: 0x48
struct FRigVMFunction_MathBoxGetVolume : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ float Volume;
};

// Size: 0x60
struct FRigVMFunction_MathBoxIsInside : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector position;
    /* 0x0058 */ bool Result;
};

// Size: 0x48
struct FRigVMFunction_MathBoxIsValid : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ bool Valid;
};

// Size: 0x90
struct FRigVMFunction_MathBoxMoveTo : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector Center;
    /* 0x0058 */ FBox Result;
};

// Size: 0x90
struct FRigVMFunction_MathBoxShift : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FVector amount;
    /* 0x0058 */ FBox Result;
};

// Size: 0xe0
struct FRigVMFunction_MathBoxTransform : public FRigVMFunction_MathBoxBase {
    /* 0x0008 */ FBox Box;
    /* 0x0040 */ FTransform Transform;
    /* 0x00a0 */ FBox Result;
};

// Size: 0x38
struct FRigVMFunction_MathColorAdd : public FRigVMFunction_MathColorBinaryAggregateOp {
};

// Size: 0x8
struct FRigVMFunction_MathColorBase : public FRigVMFunction_MathBase {
};

// Size: 0x38
struct FRigVMFunction_MathColorBinaryAggregateOp : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ FLinearColor A;
    /* 0x0018 */ FLinearColor B;
    /* 0x0028 */ FLinearColor Result;
};

// Size: 0x38
struct FRigVMFunction_MathColorBinaryOp : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ FLinearColor A;
    /* 0x0018 */ FLinearColor B;
    /* 0x0028 */ FLinearColor Result;
};

// Size: 0x20
struct FRigVMFunction_MathColorFromDouble : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ FLinearColor Result;
};

// Size: 0x20
struct FRigVMFunction_MathColorFromFloat : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ FLinearColor Result;
};

// Size: 0x40
struct FRigVMFunction_MathColorLerp : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ FLinearColor A;
    /* 0x0018 */ FLinearColor B;
    /* 0x0028 */ float T;
    /* 0x002c */ FLinearColor Result;
};

// Size: 0x28
struct FRigVMFunction_MathColorMake : public FRigVMFunction_MathColorBase {
    /* 0x0008 */ float R;
    /* 0x000c */ float G;
    /* 0x0010 */ float B;
    /* 0x0014 */ float A;
    /* 0x0018 */ FLinearColor Result;
};

// Size: 0x38
struct FRigVMFunction_MathColorMul : public FRigVMFunction_MathColorBinaryAggregateOp {
};

// Size: 0x38
struct FRigVMFunction_MathColorSub : public FRigVMFunction_MathColorBinaryOp {
};

// Size: 0x70
struct FRigVMFunction_MathDistanceToPlane : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Point;
    /* 0x0020 */ FVector PlanePoint;
    /* 0x0038 */ FVector PlaneNormal;
    /* 0x0050 */ FVector ClosestPointOnPlane;
    /* 0x0068 */ float SignedDistance;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleAbs : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleAcos : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleAdd : public FRigVMFunction_MathDoubleBinaryAggregateOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleArrayAverage : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ TArray<double> Array;
    /* 0x0018 */ double Average;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleArraySum : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ TArray<double> Array;
    /* 0x0018 */ double Sum;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleAsin : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleAtan : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleAtan2 : public FRigVMFunction_MathDoubleBinaryOp {
};

// Size: 0x8
struct FRigVMFunction_MathDoubleBase : public FRigVMFunction_MathBase {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleBinaryAggregateOp : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ double Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleBinaryOp : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ double Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleCeil : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Result;
    /* 0x0018 */ int32_t int;
};

// Size: 0x28
struct FRigVMFunction_MathDoubleClamp : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Minimum;
    /* 0x0018 */ double Maximum;
    /* 0x0020 */ double Result;
};

// Size: 0x10
struct FRigVMFunction_MathDoubleConstE : public FRigVMFunction_MathDoubleConstant {
};

// Size: 0x10
struct FRigVMFunction_MathDoubleConstHalfPi : public FRigVMFunction_MathDoubleConstant {
};

// Size: 0x10
struct FRigVMFunction_MathDoubleConstPi : public FRigVMFunction_MathDoubleConstant {
};

// Size: 0x10
struct FRigVMFunction_MathDoubleConstTwoPi : public FRigVMFunction_MathDoubleConstant {
};

// Size: 0x10
struct FRigVMFunction_MathDoubleConstant : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleCos : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleDeg : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleDiv : public FRigVMFunction_MathDoubleBinaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleEquals : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleExponential : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleFloor : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Result;
    /* 0x0018 */ int32_t int;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleGreater : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleGreaterEqual : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x28
struct FRigVMFunction_MathDoubleIsNearlyEqual : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ double Tolerance;
    /* 0x0020 */ bool Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleIsNearlyZero : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Tolerance;
    /* 0x0018 */ bool Result;
};

// Size: 0x40
struct FRigVMFunction_MathDoubleLawOfCosine : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ double C;
    /* 0x0020 */ double AlphaAngle;
    /* 0x0028 */ double BetaAngle;
    /* 0x0030 */ double GammaAngle;
    /* 0x0038 */ bool bValid;
};

// Size: 0x28
struct FRigVMFunction_MathDoubleLerp : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ double T;
    /* 0x0020 */ double Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleLess : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleLessEqual : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathDoubleMake : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleMax : public FRigVMFunction_MathDoubleBinaryAggregateOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleMin : public FRigVMFunction_MathDoubleBinaryAggregateOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleMod : public FRigVMFunction_MathDoubleBinaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleMul : public FRigVMFunction_MathDoubleBinaryAggregateOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleNegate : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleNotEquals : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double A;
    /* 0x0010 */ double B;
    /* 0x0018 */ bool Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoublePow : public FRigVMFunction_MathDoubleBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleRad : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathDoubleRemap : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double SourceMinimum;
    /* 0x0018 */ double SourceMaximum;
    /* 0x0020 */ double TargetMinimum;
    /* 0x0028 */ double TargetMaximum;
    /* 0x0030 */ bool bClamp;
    /* 0x0038 */ double Result;
};

// Size: 0x20
struct FRigVMFunction_MathDoubleRound : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Result;
    /* 0x0018 */ int32_t int;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleSign : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleSin : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleSqrt : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x20
struct FRigVMFunction_MathDoubleSub : public FRigVMFunction_MathDoubleBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleTan : public FRigVMFunction_MathDoubleUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathDoubleToFloat : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleToInt : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ int32_t Result;
};

// Size: 0x18
struct FRigVMFunction_MathDoubleUnaryOp : public FRigVMFunction_MathDoubleBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatAbs : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatAcos : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatAdd : public FRigVMFunction_MathFloatBinaryAggregateOp {
};

// Size: 0x20
struct FRigVMFunction_MathFloatArrayAverage : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ TArray<float> Array;
    /* 0x0018 */ float Average;
};

// Size: 0x20
struct FRigVMFunction_MathFloatArraySum : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ TArray<float> Array;
    /* 0x0018 */ float Sum;
};

// Size: 0x10
struct FRigVMFunction_MathFloatAsin : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatAtan : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatAtan2 : public FRigVMFunction_MathFloatBinaryOp {
};

// Size: 0x8
struct FRigVMFunction_MathFloatBase : public FRigVMFunction_MathBase {
};

// Size: 0x18
struct FRigVMFunction_MathFloatBinaryAggregateOp : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatBinaryOp : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatCeil : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Result;
    /* 0x0010 */ int32_t int;
};

// Size: 0x18
struct FRigVMFunction_MathFloatClamp : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Minimum;
    /* 0x0010 */ float Maximum;
    /* 0x0014 */ float Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatConstE : public FRigVMFunction_MathFloatConstant {
};

// Size: 0x10
struct FRigVMFunction_MathFloatConstHalfPi : public FRigVMFunction_MathFloatConstant {
};

// Size: 0x10
struct FRigVMFunction_MathFloatConstPi : public FRigVMFunction_MathFloatConstant {
};

// Size: 0x10
struct FRigVMFunction_MathFloatConstTwoPi : public FRigVMFunction_MathFloatConstant {
};

// Size: 0x10
struct FRigVMFunction_MathFloatConstant : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
};

// Size: 0x10
struct FRigVMFunction_MathFloatCos : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatDeg : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatDiv : public FRigVMFunction_MathFloatBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatEquals : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatExponential : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatFloor : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Result;
    /* 0x0010 */ int32_t int;
};

// Size: 0x18
struct FRigVMFunction_MathFloatGreater : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatGreaterEqual : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatIsNearlyEqual : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ float Tolerance;
    /* 0x0014 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatIsNearlyZero : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Tolerance;
    /* 0x0010 */ bool Result;
};

// Size: 0x28
struct FRigVMFunction_MathFloatLawOfCosine : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ float C;
    /* 0x0014 */ float AlphaAngle;
    /* 0x0018 */ float BetaAngle;
    /* 0x001c */ float GammaAngle;
    /* 0x0020 */ bool bValid;
};

// Size: 0x18
struct FRigVMFunction_MathFloatLerp : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ float T;
    /* 0x0014 */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatLess : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatLessEqual : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatMake : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
};

// Size: 0x18
struct FRigVMFunction_MathFloatMax : public FRigVMFunction_MathFloatBinaryAggregateOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatMin : public FRigVMFunction_MathFloatBinaryAggregateOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatMod : public FRigVMFunction_MathFloatBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatMul : public FRigVMFunction_MathFloatBinaryAggregateOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatNegate : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatNotEquals : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float A;
    /* 0x000c */ float B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatPow : public FRigVMFunction_MathFloatBinaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatRad : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x28
struct FRigVMFunction_MathFloatRemap : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float SourceMinimum;
    /* 0x0010 */ float SourceMaximum;
    /* 0x0014 */ float TargetMinimum;
    /* 0x0018 */ float TargetMaximum;
    /* 0x001c */ bool bClamp;
    /* 0x0020 */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathFloatRound : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Result;
    /* 0x0010 */ int32_t int;
};

// Size: 0x18
struct FRigVMFunction_MathFloatSelectBool : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ bool Condition;
    /* 0x000c */ float IfTrue;
    /* 0x0010 */ float IfFalse;
    /* 0x0014 */ float Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatSign : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatSin : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatSqrt : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatSub : public FRigVMFunction_MathFloatBinaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathFloatTan : public FRigVMFunction_MathFloatUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathFloatToDouble : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x0010 */ double Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatToInt : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ int32_t Result;
};

// Size: 0x10
struct FRigVMFunction_MathFloatUnaryOp : public FRigVMFunction_MathFloatBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Result;
};

// Size: 0x10
struct FRigVMFunction_MathIntAbs : public FRigVMFunction_MathIntUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntAdd : public FRigVMFunction_MathIntBinaryAggregateOp {
};

// Size: 0x20
struct FRigVMFunction_MathIntArrayAverage : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ TArray<int32_t> Array;
    /* 0x0018 */ int32_t Average;
};

// Size: 0x20
struct FRigVMFunction_MathIntArraySum : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ TArray<int32_t> Array;
    /* 0x0018 */ int32_t Sum;
};

// Size: 0x8
struct FRigVMFunction_MathIntBase : public FRigVMFunction_MathBase {
};

// Size: 0x18
struct FRigVMFunction_MathIntBinaryAggregateOp : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ int32_t Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntBinaryOp : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ int32_t Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntClamp : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Value;
    /* 0x000c */ int32_t Minimum;
    /* 0x0010 */ int32_t Maximum;
    /* 0x0014 */ int32_t Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntDiv : public FRigVMFunction_MathIntBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntEquals : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntGreater : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntGreaterEqual : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntLess : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntLessEqual : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x10
struct FRigVMFunction_MathIntMake : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Value;
};

// Size: 0x18
struct FRigVMFunction_MathIntMax : public FRigVMFunction_MathIntBinaryAggregateOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntMin : public FRigVMFunction_MathIntBinaryAggregateOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntMod : public FRigVMFunction_MathIntBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntMul : public FRigVMFunction_MathIntBinaryAggregateOp {
};

// Size: 0x10
struct FRigVMFunction_MathIntNegate : public FRigVMFunction_MathIntUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntNotEquals : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t A;
    /* 0x000c */ int32_t B;
    /* 0x0010 */ bool Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntPow : public FRigVMFunction_MathIntBinaryOp {
};

// Size: 0x10
struct FRigVMFunction_MathIntSign : public FRigVMFunction_MathIntUnaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntSub : public FRigVMFunction_MathIntBinaryOp {
};

// Size: 0x18
struct FRigVMFunction_MathIntToDouble : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Value;
    /* 0x0010 */ double Result;
};

// Size: 0x10
struct FRigVMFunction_MathIntToFloat : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Value;
    /* 0x000c */ float Result;
};

// Size: 0x18
struct FRigVMFunction_MathIntToName : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Number;
    /* 0x000c */ int32_t PaddedSize;
    /* 0x0010 */ FName Result;
};

// Size: 0x20
struct FRigVMFunction_MathIntToString : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Number;
    /* 0x000c */ int32_t PaddedSize;
    /* 0x0010 */ FString Result;
};

// Size: 0x10
struct FRigVMFunction_MathIntUnaryOp : public FRigVMFunction_MathIntBase {
    /* 0x0008 */ int32_t Value;
    /* 0x000c */ int32_t Result;
};

// Size: 0x88
struct FRigVMFunction_MathIntersectPlane : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Start;
    /* 0x0020 */ FVector Direction;
    /* 0x0038 */ FVector PlanePoint;
    /* 0x0050 */ FVector PlaneNormal;
    /* 0x0068 */ FVector Result;
    /* 0x0080 */ float Distance;
};

// Size: 0x8
struct FRigVMFunction_MathMatrixBase : public FRigVMFunction_MathBase {
};

// Size: 0x190
struct FRigVMFunction_MathMatrixBinaryAggregateOp : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FMatrix A;
    /* 0x0090 */ FMatrix B;
    /* 0x0110 */ FMatrix Result;
};

// Size: 0x190
struct FRigVMFunction_MathMatrixBinaryOp : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FMatrix A;
    /* 0x0090 */ FMatrix B;
    /* 0x0110 */ FMatrix Result;
};

// Size: 0xf0
struct FRigVMFunction_MathMatrixFromTransform : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FMatrix Result;
};

// Size: 0xf0
struct FRigVMFunction_MathMatrixFromTransformV2 : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FMatrix Result;
};

// Size: 0xf0
struct FRigVMFunction_MathMatrixFromVectors : public FRigVMFunction_MathMatrixBase {
    /* 0x0008 */ FVector Origin;
    /* 0x0020 */ FVector X;
    /* 0x0038 */ FVector Y;
    /* 0x0050 */ FVector Z;
    /* 0x0070 */ FMatrix Result;
};

// Size: 0x110
struct FRigVMFunction_MathMatrixInverse : public FRigVMFunction_MathMatrixUnaryOp {
};

// Size: 0x190
struct FRigVMFunction_MathMatrixMul : public FRigVMFunction_MathMatrixBinaryAggregateOp {
};

// Size: 0xf0
struct FRigVMFunction_MathMatrixToTransform : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FMatrix Value;
    /* 0x0090 */ FTransform Result;
};

// Size: 0xf0
struct FRigVMFunction_MathMatrixToVectors : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FMatrix Value;
    /* 0x0090 */ FVector Origin;
    /* 0x00a8 */ FVector X;
    /* 0x00c0 */ FVector Y;
    /* 0x00d8 */ FVector Z;
};

// Size: 0x110
struct FRigVMFunction_MathMatrixUnaryOp : public FRigVMFunction_MathMatrixBase {
    /* 0x0010 */ FMatrix Value;
    /* 0x0090 */ FMatrix Result;
};

// Size: 0x10
struct FRigVMFunction_MathMutableBase : public FRigVMStructMutable {
};

// Size: 0x8
struct FRigVMFunction_MathQuaternionBase : public FRigVMFunction_MathBase {
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionBinaryAggregateOp : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ FQuat Result;
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionBinaryOp : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ FQuat Result;
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionDot : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ float Result;
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionEquals : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ bool Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionFromAxisAndAngle : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ FVector Axis;
    /* 0x0020 */ float Angle;
    /* 0x0030 */ FQuat Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionFromEuler : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ FVector Euler;
    /* 0x0020 */ EEulerRotationOrder RotationOrder;
    /* 0x0030 */ FQuat Result;
};

// Size: 0x40
struct FRigVMFunction_MathQuaternionFromRotator : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ FRotator Rotator;
    /* 0x0020 */ FQuat Result;
};

// Size: 0x40
struct FRigVMFunction_MathQuaternionFromRotatorV2 : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ FRotator Value;
    /* 0x0020 */ FQuat Result;
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionFromTwoVectors : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0040 */ FQuat Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionGetAxis : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Quaternion;
    /* 0x0030 */ uint8_t Axis;
    /* 0x0038 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionInverse : public FRigVMFunction_MathQuaternionUnaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathQuaternionMake : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ float X;
    /* 0x000c */ float Y;
    /* 0x0010 */ float Z;
    /* 0x0014 */ float W;
    /* 0x0020 */ FQuat Result;
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionMakeAbsolute : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Local;
    /* 0x0030 */ FQuat Parent;
    /* 0x0050 */ FQuat Global;
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionMakeRelative : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Global;
    /* 0x0030 */ FQuat Parent;
    /* 0x0050 */ FQuat Local;
};

// Size: 0xc0
struct FRigVMFunction_MathQuaternionMirrorTransform : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ uint8_t MirrorAxis;
    /* 0x0031 */ uint8_t AxisToFlip;
    /* 0x0040 */ FTransform CentralTransform;
    /* 0x00a0 */ FQuat Result;
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionMul : public FRigVMFunction_MathQuaternionBinaryAggregateOp {
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionNotEquals : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ bool Result;
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionRotateVector : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Transform;
    /* 0x0030 */ FVector Vector;
    /* 0x0048 */ FVector Result;
};

// Size: 0x10
struct FRigVMFunction_MathQuaternionRotationOrder : public FRigVMFunction_MathBase {
    /* 0x0008 */ EEulerRotationOrder RotationOrder;
};

// Size: 0x40
struct FRigVMFunction_MathQuaternionScale : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ float Scale;
};

// Size: 0x60
struct FRigVMFunction_MathQuaternionScaleV2 : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ float Factor;
    /* 0x0040 */ FQuat Result;
};

// Size: 0x70
struct FRigVMFunction_MathQuaternionSelectBool : public FRigVMFunction_MathQuaternionBase {
    /* 0x0008 */ bool Condition;
    /* 0x0010 */ FQuat IfTrue;
    /* 0x0030 */ FQuat IfFalse;
    /* 0x0050 */ FQuat Result;
};

// Size: 0x80
struct FRigVMFunction_MathQuaternionSlerp : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat A;
    /* 0x0030 */ FQuat B;
    /* 0x0050 */ float T;
    /* 0x0060 */ FQuat Result;
};

// Size: 0x90
struct FRigVMFunction_MathQuaternionSwingTwist : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Input;
    /* 0x0030 */ FVector TwistAxis;
    /* 0x0050 */ FQuat Swing;
    /* 0x0070 */ FQuat Twist;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionToAxisAndAngle : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FVector Axis;
    /* 0x0048 */ float Angle;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionToEuler : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ EEulerRotationOrder RotationOrder;
    /* 0x0038 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionToRotator : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FRotator Result;
};

// Size: 0x80
struct FRigVMFunction_MathQuaternionToVectors : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FVector Forward;
    /* 0x0048 */ FVector Right;
    /* 0x0060 */ FVector Up;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionUnaryOp : public FRigVMFunction_MathQuaternionBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ FQuat Result;
};

// Size: 0x50
struct FRigVMFunction_MathQuaternionUnit : public FRigVMFunction_MathQuaternionUnaryOp {
};

// Size: 0x8
struct FRigVMFunction_MathRBFInterpolateBase : public FRigVMFunction_MathBase {
};

// Size: 0xe0
struct FRigVMFunction_MathRBFInterpolateQuatBase : public FRigVMFunction_MathRBFInterpolateBase {
    /* 0x0010 */ FQuat Input;
    /* 0x0030 */ ERBFQuatDistanceType DistanceFunction;
    /* 0x0031 */ ERBFKernelType SmoothingFunction;
    /* 0x0034 */ float SmoothingAngle;
    /* 0x0038 */ bool bNormalizeOutput;
    /* 0x0040 */ FVector TwistAxis;
    /* 0x0060 */ FRigVMFunction_MathRBFInterpolateQuatWorkData WorkData;
};

// Size: 0x100
struct FRigVMFunction_MathRBFInterpolateQuatColor : public FRigVMFunction_MathRBFInterpolateQuatBase {
    /* 0x00e0 */ TArray<FMathRBFInterpolateQuatColor_Target> Targets;
    /* 0x00f0 */ FLinearColor Output;
};

// Size: 0x100
struct FRigVMFunction_MathRBFInterpolateQuatFloat : public FRigVMFunction_MathRBFInterpolateQuatBase {
    /* 0x00e0 */ TArray<FMathRBFInterpolateQuatFloat_Target> Targets;
    /* 0x00f0 */ float Output;
};

// Size: 0x110
struct FRigVMFunction_MathRBFInterpolateQuatQuat : public FRigVMFunction_MathRBFInterpolateQuatBase {
    /* 0x00e0 */ TArray<FMathRBFInterpolateQuatQuat_Target> Targets;
    /* 0x00f0 */ FQuat Output;
};

// Size: 0x110
struct FRigVMFunction_MathRBFInterpolateQuatVector : public FRigVMFunction_MathRBFInterpolateQuatBase {
    /* 0x00e0 */ TArray<FMathRBFInterpolateQuatVector_Target> Targets;
    /* 0x00f0 */ FVector Output;
};

// Size: 0x80
struct FRigVMFunction_MathRBFInterpolateQuatWorkData {
};

// Size: 0x150
struct FRigVMFunction_MathRBFInterpolateQuatXform : public FRigVMFunction_MathRBFInterpolateQuatBase {
    /* 0x00e0 */ TArray<FMathRBFInterpolateQuatXform_Target> Targets;
    /* 0x00f0 */ FTransform Output;
};

// Size: 0xb0
struct FRigVMFunction_MathRBFInterpolateVectorBase : public FRigVMFunction_MathRBFInterpolateBase {
    /* 0x0008 */ FVector Input;
    /* 0x0020 */ ERBFVectorDistanceType DistanceFunction;
    /* 0x0021 */ ERBFKernelType SmoothingFunction;
    /* 0x0024 */ float SmoothingRadius;
    /* 0x0028 */ bool bNormalizeOutput;
    /* 0x0030 */ FRigVMFunction_MathRBFInterpolateVectorWorkData WorkData;
};

// Size: 0xd0
struct FRigVMFunction_MathRBFInterpolateVectorColor : public FRigVMFunction_MathRBFInterpolateVectorBase {
    /* 0x00b0 */ TArray<FMathRBFInterpolateVectorColor_Target> Targets;
    /* 0x00c0 */ FLinearColor Output;
};

// Size: 0xd0
struct FRigVMFunction_MathRBFInterpolateVectorFloat : public FRigVMFunction_MathRBFInterpolateVectorBase {
    /* 0x00b0 */ TArray<FMathRBFInterpolateVectorFloat_Target> Targets;
    /* 0x00c0 */ float Output;
};

// Size: 0xe0
struct FRigVMFunction_MathRBFInterpolateVectorQuat : public FRigVMFunction_MathRBFInterpolateVectorBase {
    /* 0x00b0 */ TArray<FMathRBFInterpolateVectorQuat_Target> Targets;
    /* 0x00c0 */ FQuat Output;
};

// Size: 0xe0
struct FRigVMFunction_MathRBFInterpolateVectorVector : public FRigVMFunction_MathRBFInterpolateVectorBase {
    /* 0x00b0 */ TArray<FMathRBFInterpolateVectorVector_Target> Targets;
    /* 0x00c0 */ FVector Output;
};

// Size: 0x80
struct FRigVMFunction_MathRBFInterpolateVectorWorkData {
};

// Size: 0x120
struct FRigVMFunction_MathRBFInterpolateVectorXform : public FRigVMFunction_MathRBFInterpolateVectorBase {
    /* 0x00b0 */ TArray<FMathRBFInterpolateVectorXform_Target> Targets;
    /* 0x00c0 */ FTransform Output;
};

// Size: 0x8
struct FRigVMFunction_MathRayBase : public FRigVMFunction_MathBase {
};

// Size: 0x58
struct FRigVMFunction_MathRayGetAt : public FRigVMFunction_MathRayBase {
    /* 0x0008 */ FRay Ray;
    /* 0x0038 */ float Ratio;
    /* 0x0040 */ FVector Result;
};

// Size: 0x88
struct FRigVMFunction_MathRayIntersectPlane : public FRigVMFunction_MathRayBase {
    /* 0x0008 */ FRay Ray;
    /* 0x0038 */ FVector PlanePoint;
    /* 0x0050 */ FVector PlaneNormal;
    /* 0x0068 */ FVector Result;
    /* 0x0080 */ float Distance;
    /* 0x0084 */ float Ratio;
};

// Size: 0x90
struct FRigVMFunction_MathRayIntersectRay : public FRigVMFunction_MathRayBase {
    /* 0x0008 */ FRay A;
    /* 0x0038 */ FRay B;
    /* 0x0068 */ FVector Result;
    /* 0x0080 */ float Distance;
    /* 0x0084 */ float RatioA;
    /* 0x0088 */ float RatioB;
};

// Size: 0xd0
struct FRigVMFunction_MathRayTransform : public FRigVMFunction_MathRayBase {
    /* 0x0008 */ FRay Ray;
    /* 0x0040 */ FTransform Transform;
    /* 0x00a0 */ FRay Result;
};

// Size: 0xa0
struct FRigVMFunction_MathTransformAccumulateArray : public FRigVMFunction_MathTransformMutableBase {
    /* 0x0010 */ TArray<FTransform> Transforms;
    /* 0x0020 */ ERigVMTransformSpace TargetSpace;
    /* 0x0030 */ FTransform Root;
    /* 0x0090 */ TArray<int32_t> ParentIndices;
};

// Size: 0x48
struct FRigVMFunction_MathTransformArrayToSRT : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ TArray<FTransform> Transforms;
    /* 0x0018 */ TArray<FVector> Translations;
    /* 0x0028 */ TArray<FQuat> Rotations;
    /* 0x0038 */ TArray<FVector> Scales;
};

// Size: 0x8
struct FRigVMFunction_MathTransformBase : public FRigVMFunction_MathBase {
};

// Size: 0x130
struct FRigVMFunction_MathTransformBinaryAggregateOp : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform A;
    /* 0x0070 */ FTransform B;
    /* 0x00d0 */ FTransform Result;
};

// Size: 0x130
struct FRigVMFunction_MathTransformBinaryOp : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform A;
    /* 0x0070 */ FTransform B;
    /* 0x00d0 */ FTransform Result;
};

// Size: 0x160
struct FRigVMFunction_MathTransformClampSpatially : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ uint8_t Axis;
    /* 0x0071 */ uint8_t Type;
    /* 0x0074 */ float Minimum;
    /* 0x0078 */ float Maximum;
    /* 0x0080 */ FTransform Space;
    /* 0x00e0 */ bool bDrawDebug;
    /* 0x00e4 */ FLinearColor DebugColor;
    /* 0x00f4 */ float DebugThickness;
    /* 0x0100 */ FTransform Result;
};

// Size: 0xb0
struct FRigVMFunction_MathTransformFromEulerTransform : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ FEulerTransform EulerTransform;
    /* 0x0050 */ FTransform Result;
};

// Size: 0xb0
struct FRigVMFunction_MathTransformFromEulerTransformV2 : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ FEulerTransform Value;
    /* 0x0050 */ FTransform Result;
};

// Size: 0x110
struct FRigVMFunction_MathTransformFromSRT : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ FVector Location;
    /* 0x0020 */ FVector Rotation;
    /* 0x0038 */ EEulerRotationOrder RotationOrder;
    /* 0x0040 */ FVector Scale;
    /* 0x0060 */ FTransform Transform;
    /* 0x00c0 */ FEulerTransform EulerTransform;
};

// Size: 0xd0
struct FRigVMFunction_MathTransformInverse : public FRigVMFunction_MathTransformUnaryOp {
};

// Size: 0x140
struct FRigVMFunction_MathTransformLerp : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform A;
    /* 0x0070 */ FTransform B;
    /* 0x00d0 */ float T;
    /* 0x00e0 */ FTransform Result;
};

// Size: 0xc0
struct FRigVMFunction_MathTransformMake : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ FVector Translation;
    /* 0x0020 */ FQuat Rotation;
    /* 0x0040 */ FVector Scale;
    /* 0x0060 */ FTransform Result;
};

// Size: 0x130
struct FRigVMFunction_MathTransformMakeAbsolute : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Local;
    /* 0x0070 */ FTransform Parent;
    /* 0x00d0 */ FTransform Global;
};

// Size: 0x130
struct FRigVMFunction_MathTransformMakeRelative : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Global;
    /* 0x0070 */ FTransform Parent;
    /* 0x00d0 */ FTransform Local;
};

// Size: 0x140
struct FRigVMFunction_MathTransformMirrorTransform : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ uint8_t MirrorAxis;
    /* 0x0071 */ uint8_t AxisToFlip;
    /* 0x0080 */ FTransform CentralTransform;
    /* 0x00e0 */ FTransform Result;
};

// Size: 0x130
struct FRigVMFunction_MathTransformMul : public FRigVMFunction_MathTransformBinaryAggregateOp {
};

// Size: 0x10
struct FRigVMFunction_MathTransformMutableBase : public FRigVMFunction_MathMutableBase {
};

// Size: 0xa0
struct FRigVMFunction_MathTransformRotateVector : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FVector Vector;
    /* 0x0088 */ FVector Result;
};

// Size: 0x130
struct FRigVMFunction_MathTransformSelectBool : public FRigVMFunction_MathTransformBase {
    /* 0x0008 */ bool Condition;
    /* 0x0010 */ FTransform IfTrue;
    /* 0x0070 */ FTransform IfFalse;
    /* 0x00d0 */ FTransform Result;
};

// Size: 0xc0
struct FRigVMFunction_MathTransformToEulerTransform : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FEulerTransform Result;
};

// Size: 0xc0
struct FRigVMFunction_MathTransformToVectors : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FVector Forward;
    /* 0x0088 */ FVector Right;
    /* 0x00a0 */ FVector Up;
};

// Size: 0xa0
struct FRigVMFunction_MathTransformTransformVector : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FVector Location;
    /* 0x0088 */ FVector Result;
};

// Size: 0xd0
struct FRigVMFunction_MathTransformUnaryOp : public FRigVMFunction_MathTransformBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ FTransform Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorAbs : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x50
struct FRigVMFunction_MathVectorAdd : public FRigVMFunction_MathVectorBinaryAggregateOp {
};

// Size: 0x40
struct FRigVMFunction_MathVectorAngle : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ float Result;
};

// Size: 0x30
struct FRigVMFunction_MathVectorArrayAverage : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ TArray<FVector> Array;
    /* 0x0018 */ FVector Average;
};

// Size: 0x30
struct FRigVMFunction_MathVectorArraySum : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ TArray<FVector> Array;
    /* 0x0018 */ FVector Sum;
};

// Size: 0x8
struct FRigVMFunction_MathVectorBase : public FRigVMFunction_MathBase {
};

// Size: 0xa0
struct FRigVMFunction_MathVectorBezierFourPoint : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FRigVMFourPointBezier Bezier;
    /* 0x0068 */ float T;
    /* 0x0070 */ FVector Result;
    /* 0x0088 */ FVector Tangent;
};

// Size: 0x50
struct FRigVMFunction_MathVectorBinaryAggregateOp : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathVectorBinaryOp : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ FVector Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorCeil : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x68
struct FRigVMFunction_MathVectorClamp : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Minimum;
    /* 0x0038 */ FVector Maximum;
    /* 0x0050 */ FVector Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorClampLength : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float MinimumLength;
    /* 0x0024 */ float MaximumLength;
    /* 0x0028 */ FVector Result;
};

// Size: 0xc0
struct FRigVMFunction_MathVectorClampSpatially : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ uint8_t Axis;
    /* 0x0021 */ uint8_t Type;
    /* 0x0024 */ float Minimum;
    /* 0x0028 */ float Maximum;
    /* 0x0030 */ FTransform Space;
    /* 0x0090 */ bool bDrawDebug;
    /* 0x0094 */ FLinearColor DebugColor;
    /* 0x00a4 */ float DebugThickness;
    /* 0x00a8 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathVectorCross : public FRigVMFunction_MathVectorBinaryOp {
};

// Size: 0x38
struct FRigVMFunction_MathVectorDeg : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathVectorDistance : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ float Result;
};

// Size: 0x50
struct FRigVMFunction_MathVectorDiv : public FRigVMFunction_MathVectorBinaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathVectorDot : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ float Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorEquals : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ bool Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorFloor : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x28
struct FRigVMFunction_MathVectorFromDouble : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ FVector Result;
};

// Size: 0x28
struct FRigVMFunction_MathVectorFromFloat : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ float Value;
    /* 0x0010 */ FVector Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorIsNearlyEqual : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ float Tolerance;
    /* 0x003c */ bool Result;
};

// Size: 0x28
struct FRigVMFunction_MathVectorIsNearlyZero : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Tolerance;
    /* 0x0024 */ bool Result;
};

// Size: 0x28
struct FRigVMFunction_MathVectorLength : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Result;
};

// Size: 0x28
struct FRigVMFunction_MathVectorLengthSquared : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Result;
};

// Size: 0x58
struct FRigVMFunction_MathVectorLerp : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ float T;
    /* 0x0040 */ FVector Result;
};

// Size: 0x30
struct FRigVMFunction_MathVectorMake : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ float X;
    /* 0x000c */ float Y;
    /* 0x0010 */ float Z;
    /* 0x0018 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathVectorMakeAbsolute : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Local;
    /* 0x0020 */ FVector Parent;
    /* 0x0038 */ FVector Global;
};

// Size: 0x68
struct FRigVMFunction_MathVectorMakeBezierFourPoint : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FRigVMFourPointBezier Bezier;
};

// Size: 0x50
struct FRigVMFunction_MathVectorMakeRelative : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Global;
    /* 0x0020 */ FVector Parent;
    /* 0x0038 */ FVector Local;
};

// Size: 0x50
struct FRigVMFunction_MathVectorMax : public FRigVMFunction_MathVectorBinaryAggregateOp {
};

// Size: 0x50
struct FRigVMFunction_MathVectorMin : public FRigVMFunction_MathVectorBinaryAggregateOp {
};

// Size: 0x50
struct FRigVMFunction_MathVectorMirror : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Normal;
    /* 0x0038 */ FVector Result;
};

// Size: 0xb0
struct FRigVMFunction_MathVectorMirrorTransform : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ uint8_t MirrorAxis;
    /* 0x0021 */ uint8_t AxisToFlip;
    /* 0x0030 */ FTransform CentralTransform;
    /* 0x0090 */ FVector Result;
};

// Size: 0x50
struct FRigVMFunction_MathVectorMod : public FRigVMFunction_MathVectorBinaryOp {
};

// Size: 0x50
struct FRigVMFunction_MathVectorMul : public FRigVMFunction_MathVectorBinaryAggregateOp {
};

// Size: 0x38
struct FRigVMFunction_MathVectorNegate : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathVectorNotEquals : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ bool Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorOrthogonal : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ bool Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorParallel : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector A;
    /* 0x0020 */ FVector B;
    /* 0x0038 */ bool Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorRad : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0xa0
struct FRigVMFunction_MathVectorRemap : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector SourceMinimum;
    /* 0x0038 */ FVector SourceMaximum;
    /* 0x0050 */ FVector TargetMinimum;
    /* 0x0068 */ FVector TargetMaximum;
    /* 0x0080 */ bool bClamp;
    /* 0x0088 */ FVector Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorRound : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x40
struct FRigVMFunction_MathVectorScale : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Factor;
    /* 0x0028 */ FVector Result;
};

// Size: 0x58
struct FRigVMFunction_MathVectorSelectBool : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ bool Condition;
    /* 0x0010 */ FVector IfTrue;
    /* 0x0028 */ FVector IfFalse;
    /* 0x0040 */ FVector Result;
};

// Size: 0x40
struct FRigVMFunction_MathVectorSetLength : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float Length;
    /* 0x0028 */ FVector Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorSign : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x50
struct FRigVMFunction_MathVectorSub : public FRigVMFunction_MathVectorBinaryOp {
};

// Size: 0x38
struct FRigVMFunction_MathVectorUnaryOp : public FRigVMFunction_MathVectorBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Result;
};

// Size: 0x38
struct FRigVMFunction_MathVectorUnit : public FRigVMFunction_MathVectorUnaryOp {
};

// Size: 0x8
struct FRigVMFunction_NameBase : public FRigVMStruct {
};

// Size: 0x20
struct FRigVMFunction_NameConcat : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName A;
    /* 0x0010 */ FName B;
    /* 0x0018 */ FName Result;
};

// Size: 0x28
struct FRigVMFunction_NameReplace : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName Old;
    /* 0x0018 */ FName New;
    /* 0x0020 */ FName Result;
};

// Size: 0x28
struct FRigVMFunction_NameTruncate : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ int32_t Count;
    /* 0x0014 */ bool FromEnd;
    /* 0x0018 */ FName Remainder;
    /* 0x0020 */ FName Chopped;
};

// Size: 0x40
struct FRigVMFunction_NoiseDouble : public FRigVMFunction_MathBase {
    /* 0x0008 */ double Value;
    /* 0x0010 */ double Speed;
    /* 0x0018 */ double Frequency;
    /* 0x0020 */ double Minimum;
    /* 0x0028 */ double Maximum;
    /* 0x0030 */ double Result;
    /* 0x0038 */ double Time;
};

// Size: 0x28
struct FRigVMFunction_NoiseFloat : public FRigVMFunction_MathBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float Speed;
    /* 0x0010 */ float Frequency;
    /* 0x0014 */ float Minimum;
    /* 0x0018 */ float Maximum;
    /* 0x001c */ float Result;
    /* 0x0020 */ float Time;
};

// Size: 0x88
struct FRigVMFunction_NoiseVector : public FRigVMFunction_MathBase {
    /* 0x0008 */ FVector position;
    /* 0x0020 */ FVector Speed;
    /* 0x0038 */ FVector Frequency;
    /* 0x0050 */ float Minimum;
    /* 0x0054 */ float Maximum;
    /* 0x0058 */ FVector Result;
    /* 0x0070 */ FVector Time;
};

// Size: 0x90
struct FRigVMFunction_NoiseVector2 : public FRigVMFunction_MathBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ FVector Speed;
    /* 0x0038 */ FVector Frequency;
    /* 0x0050 */ double Minimum;
    /* 0x0058 */ double Maximum;
    /* 0x0060 */ FVector Result;
    /* 0x0078 */ FVector Time;
};

// Size: 0x30
struct FRigVMFunction_RandomFloat : public FRigVMFunction_MathBase {
    /* 0x0008 */ int32_t Seed;
    /* 0x000c */ float Minimum;
    /* 0x0010 */ float Maximum;
    /* 0x0014 */ float Duration;
    /* 0x0018 */ float Result;
    /* 0x001c */ float LastResult;
    /* 0x0020 */ int32_t LastSeed;
    /* 0x0024 */ int32_t BaseSeed;
    /* 0x0028 */ float TimeLeft;
};

// Size: 0x58
struct FRigVMFunction_RandomVector : public FRigVMFunction_MathBase {
    /* 0x0008 */ int32_t Seed;
    /* 0x000c */ float Minimum;
    /* 0x0010 */ float Maximum;
    /* 0x0014 */ float Duration;
    /* 0x0018 */ FVector Result;
    /* 0x0030 */ FVector LastResult;
    /* 0x0048 */ int32_t LastSeed;
    /* 0x004c */ int32_t BaseSeed;
    /* 0x0050 */ float TimeLeft;
};

// Size: 0x10
struct FRigVMFunction_SecondsToFrames : public FRigVMFunction_AnimBase {
    /* 0x0008 */ float Seconds;
    /* 0x000c */ float Frames;
};

// Size: 0x340
struct FRigVMFunction_Sequence : public FRigVMStruct {
    /* 0x0010 */ FRigVMExecuteContext ExecuteContext;
    /* 0x0120 */ FRigVMExecuteContext A;
    /* 0x0230 */ FRigVMExecuteContext B;
};

// Size: 0x8
struct FRigVMFunction_SimBase : public FRigVMStruct {
};

// Size: 0x10
struct FRigVMFunction_SimBaseMutable : public FRigVMStructMutable {
};

// Size: 0x20
struct FRigVMFunction_StartsWith : public FRigVMFunction_NameBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName Start;
    /* 0x0018 */ bool Result;
};

// Size: 0x8
struct FRigVMFunction_StringBase : public FRigVMStruct {
};

// Size: 0x38
struct FRigVMFunction_StringConcat : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString A;
    /* 0x0018 */ FString B;
    /* 0x0028 */ FString Result;
};

// Size: 0x30
struct FRigVMFunction_StringContains : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ FString search;
    /* 0x0028 */ bool Result;
};

// Size: 0x30
struct FRigVMFunction_StringEndsWith : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ FString Ending;
    /* 0x0028 */ bool Result;
};

// Size: 0x30
struct FRigVMFunction_StringFind : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString search;
    /* 0x0028 */ bool Found;
    /* 0x002c */ int32_t Index;
};

// Size: 0x38
struct FRigVMFunction_StringJoin : public FRigVMFunction_StringBase {
    /* 0x0008 */ TArray<FString> Values;
    /* 0x0018 */ FString Separator;
    /* 0x0028 */ FString Result;
};

// Size: 0x30
struct FRigVMFunction_StringLeft : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ int32_t Count;
    /* 0x0020 */ FString Result;
};

// Size: 0x20
struct FRigVMFunction_StringLength : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ int32_t Length;
};

// Size: 0x30
struct FRigVMFunction_StringMiddle : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ int32_t Start;
    /* 0x001c */ int32_t Count;
    /* 0x0020 */ FString Result;
};

// Size: 0x20
struct FRigVMFunction_StringPadInteger : public FRigVMFunction_StringBase {
    /* 0x0008 */ int32_t Value;
    /* 0x000c */ int32_t Digits;
    /* 0x0010 */ FString Result;
};

// Size: 0x48
struct FRigVMFunction_StringReplace : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ FString Old;
    /* 0x0028 */ FString New;
    /* 0x0038 */ FString Result;
};

// Size: 0x28
struct FRigVMFunction_StringReverse : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString Reverse;
};

// Size: 0x30
struct FRigVMFunction_StringRight : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ int32_t Count;
    /* 0x0020 */ FString Result;
};

// Size: 0x38
struct FRigVMFunction_StringSplit : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString Separator;
    /* 0x0028 */ TArray<FString> Result;
};

// Size: 0x30
struct FRigVMFunction_StringStartsWith : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ FString Start;
    /* 0x0028 */ bool Result;
};

// Size: 0x28
struct FRigVMFunction_StringToLowercase : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString Result;
};

// Size: 0x28
struct FRigVMFunction_StringToUppercase : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString Result;
};

// Size: 0x28
struct FRigVMFunction_StringTrimWhitespace : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Value;
    /* 0x0018 */ FString Result;
};

// Size: 0x40
struct FRigVMFunction_StringTruncate : public FRigVMFunction_StringBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ int32_t Count;
    /* 0x001c */ bool FromEnd;
    /* 0x0020 */ FString Remainder;
    /* 0x0030 */ FString Chopped;
};

// Size: 0x38
struct FRigVMFunction_TimeLoop : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Speed;
    /* 0x000c */ float Duration;
    /* 0x0010 */ bool Normalize;
    /* 0x0014 */ float Absolute;
    /* 0x0018 */ float Relative;
    /* 0x001c */ float FlipFlop;
    /* 0x0020 */ bool Even;
    /* 0x0024 */ float AccumulatedAbsolute;
    /* 0x0028 */ float AccumulatedRelative;
    /* 0x002c */ int32_t NumIterations;
    /* 0x0030 */ bool bIsInitialized;
};

// Size: 0x48
struct FRigVMFunction_TimeOffsetFloat : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Value;
    /* 0x000c */ float SecondsAgo;
    /* 0x0010 */ int32_t BufferSize;
    /* 0x0014 */ float TimeRange;
    /* 0x0018 */ float Result;
    /* 0x0020 */ TArray<float> Buffer;
    /* 0x0030 */ TArray<float> DeltaTimes;
    /* 0x0040 */ int32_t LastInsertIndex;
    /* 0x0044 */ int32_t UpperBound;
};

// Size: 0x110
struct FRigVMFunction_TimeOffsetTransform : public FRigVMFunction_SimBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ float SecondsAgo;
    /* 0x0074 */ int32_t BufferSize;
    /* 0x0078 */ float TimeRange;
    /* 0x0080 */ FTransform Result;
    /* 0x00e0 */ TArray<FTransform> Buffer;
    /* 0x00f0 */ TArray<float> DeltaTimes;
    /* 0x0100 */ int32_t LastInsertIndex;
    /* 0x0104 */ int32_t UpperBound;
};

// Size: 0x70
struct FRigVMFunction_TimeOffsetVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Value;
    /* 0x0020 */ float SecondsAgo;
    /* 0x0024 */ int32_t BufferSize;
    /* 0x0028 */ float TimeRange;
    /* 0x0030 */ FVector Result;
    /* 0x0048 */ TArray<FVector> Buffer;
    /* 0x0058 */ TArray<float> DeltaTimes;
    /* 0x0068 */ int32_t LastInsertIndex;
    /* 0x006c */ int32_t UpperBound;
};

// Size: 0x18
struct FRigVMFunction_Timeline : public FRigVMFunction_SimBase {
    /* 0x0008 */ float Speed;
    /* 0x000c */ float Time;
    /* 0x0010 */ float AccumulatedValue;
    /* 0x0014 */ bool bIsInitialized;
};

// Size: 0x18
struct FRigVMFunction_UserDefinedEvent : public FRigVMStruct {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
    /* 0x0010 */ FName EventName;
};

// Size: 0xd8
struct FRigVMFunction_VerletIntegrateVector : public FRigVMFunction_SimBase {
    /* 0x0008 */ FVector Target;
    /* 0x0020 */ float Strength;
    /* 0x0024 */ float Damp;
    /* 0x0028 */ float Blend;
    /* 0x0030 */ FVector Force;
    /* 0x0048 */ FVector position;
    /* 0x0060 */ FVector Velocity;
    /* 0x0078 */ FVector Acceleration;
    /* 0x0090 */ FRigVMSimPoint Point;
    /* 0x00d0 */ bool bInitialized;
};

// Size: 0x50
struct FRigVMFunction_VisualDebugQuat : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ bool bEnabled;
    /* 0x0034 */ float Thickness;
    /* 0x0038 */ float Scale;
    /* 0x003c */ FName BoneSpace;
};

// Size: 0x40
struct FRigVMFunction_VisualDebugQuatNoSpace : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FQuat Value;
    /* 0x0030 */ bool bEnabled;
    /* 0x0034 */ float Thickness;
    /* 0x0038 */ float Scale;
};

// Size: 0x90
struct FRigVMFunction_VisualDebugTransform : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ bool bEnabled;
    /* 0x0074 */ float Thickness;
    /* 0x0078 */ float Scale;
    /* 0x007c */ FName BoneSpace;
};

// Size: 0x80
struct FRigVMFunction_VisualDebugTransformNoSpace : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FTransform Value;
    /* 0x0070 */ bool bEnabled;
    /* 0x0074 */ float Thickness;
    /* 0x0078 */ float Scale;
};

// Size: 0x50
struct FRigVMFunction_VisualDebugVector : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FVector Value;
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ ERigUnitVisualDebugPointMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ float Scale;
    /* 0x0044 */ FName BoneSpace;
};

// Size: 0x48
struct FRigVMFunction_VisualDebugVectorNoSpace : public FRigVMFunction_DebugBase {
    /* 0x0010 */ FVector Value;
    /* 0x0028 */ bool bEnabled;
    /* 0x0029 */ ERigUnitVisualDebugPointMode Mode;
    /* 0x002c */ FLinearColor Color;
    /* 0x003c */ float Thickness;
    /* 0x0040 */ float Scale;
};

// Size: 0x78
struct FRigVMFunction_VisualLogArrow : public FRigVMFunction_VisualLogObject {
    /* 0x0040 */ FVector SegmentStart;
    /* 0x0058 */ FVector SegmentEnd;
    /* 0x0070 */ float ArrowHeadSize;
};

// Size: 0x30
struct FRigVMFunction_VisualLogBase : public FRigVMFunction_DebugBaseMutable {
    /* 0x0018 */ FString Text;
    /* 0x0028 */ FName Category;
};

// Size: 0x80
struct FRigVMFunction_VisualLogBox : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FBox Box;
};

// Size: 0x90
struct FRigVMFunction_VisualLogCapsule : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FVector base;
    /* 0x0060 */ float HalfHeight;
    /* 0x0064 */ float Radius;
    /* 0x0070 */ FQuat Rotation;
};

// Size: 0x80
struct FRigVMFunction_VisualLogCircle : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FVector Center;
    /* 0x0060 */ FVector UpAxis;
    /* 0x0078 */ float Radius;
    /* 0x007c */ float Thickness;
};

// Size: 0x80
struct FRigVMFunction_VisualLogCone : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FVector Origin;
    /* 0x0060 */ FVector Direction;
    /* 0x0078 */ float Length;
    /* 0x007c */ float Angle;
};

// Size: 0x80
struct FRigVMFunction_VisualLogCylinder : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FVector Start;
    /* 0x0060 */ FVector End;
    /* 0x0078 */ float Radius;
};

// Size: 0x60
struct FRigVMFunction_VisualLogLocation : public FRigVMFunction_VisualLogObject {
    /* 0x0040 */ FVector Location;
    /* 0x0058 */ float Radius;
};

// Size: 0x40
struct FRigVMFunction_VisualLogObject : public FRigVMFunction_VisualLogBase {
    /* 0x0030 */ FLinearColor ObjectColor;
};

// Size: 0xe0
struct FRigVMFunction_VisualLogOrientedBox : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FBox Box;
    /* 0x0080 */ FTransform Transform;
};

// Size: 0x78
struct FRigVMFunction_VisualLogSegment : public FRigVMFunction_VisualLogObject {
    /* 0x0040 */ FVector SegmentStart;
    /* 0x0058 */ FVector SegmentEnd;
    /* 0x0070 */ float Thickness;
};

// Size: 0x68
struct FRigVMFunction_VisualLogSphere : public FRigVMFunction_VisualLogWireframeOptional {
    /* 0x0048 */ FVector Center;
    /* 0x0060 */ float Radius;
};

// Size: 0x30
struct FRigVMFunction_VisualLogText : public FRigVMFunction_VisualLogBase {
};

// Size: 0x48
struct FRigVMFunction_VisualLogWireframeOptional : public FRigVMFunction_VisualLogObject {
    /* 0x0040 */ bool bWireframe;
};

// Size: 0xb0
struct FRigVMGraphFunctionArgument {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FName DisplayName;
    /* 0x0010 */ FName CPPType;
    /* 0x0018 */ TSoftObjectPtr<UObject> CPPTypeObject;
    /* 0x0040 */ bool bIsArray;
    /* 0x0041 */ ERigVMPinDirection Direction;
    /* 0x0048 */ FString DefaultValue;
    /* 0x0058 */ bool bIsConst;
    /* 0x0060 */ TMap<FString, FText> PathToTooltip;
};

// Size: 0x460
struct FRigVMGraphFunctionData {
    /* 0x0000 */ FRigVMGraphFunctionHeader Header;
    /* 0x01f8 */ FRigVMFunctionCompilationData CompilationData;
    /* 0x0430 */ FString SerializedCollapsedNode;
    /* 0x0440 */ FRigVMObjectArchive CollapseNodeArchive;
};

// Size: 0x1f8
struct FRigVMGraphFunctionHeader {
    /* 0x0000 */ FRigVMGraphFunctionIdentifier LibraryPointer;
    /* 0x0050 */ FRigVMVariant Variant;
    /* 0x0070 */ FName Name;
    /* 0x0078 */ FString NodeTitle;
    /* 0x0088 */ FLinearColor nodeColor;
    /* 0x0098 */ FText Tooltip;
    /* 0x00a8 */ FString Description;
    /* 0x00b8 */ FString Category;
    /* 0x00c8 */ FString Keywords;
    /* 0x00d8 */ TArray<FRigVMGraphFunctionArgument> Arguments;
    /* 0x00e8 */ TMap<FRigVMGraphFunctionIdentifier, uint32_t> Dependencies;
    /* 0x0138 */ TArray<FRigVMExternalVariable> ExternalVariables;
    /* 0x0148 */ FRigVMNodeLayout Layout;
};

// Size: 0x10
struct FRigVMGraphFunctionHeaderArray {
    /* 0x0000 */ TArray<FRigVMGraphFunctionHeader> Headers;
};

// Size: 0x28
class IRigVMGraphFunctionHost : public UInterface {
};

// Size: 0x50
struct FRigVMGraphFunctionIdentifier {
    /* 0x0000 */ FSoftObjectPath LibraryNode;
    /* 0x0020 */ FString LibraryNodePath;
    /* 0x0030 */ FSoftObjectPath HostObject;
};

// Size: 0x20
struct FRigVMGraphFunctionStore {
    /* 0x0000 */ TArray<FRigVMGraphFunctionData> PublicFunctions;
    /* 0x0010 */ TArray<FRigVMGraphFunctionData> PrivateFunctions;
};

// Size: 0x278
class URigVMHost : public UObject {
    /* 0x0030 */ FRigVMRuntimeSettings VMRuntimeSettings;
    /* 0x0058 */ URigVM* VM;
    /* 0x0060 */ TMap<FString, FSoftObjectPath> UserDefinedStructGuidToPathName;
    /* 0x00b0 */ TMap<FString, FSoftObjectPath> UserDefinedEnumToPathName;
    /* 0x0100 */ TSet<UObject*> UserDefinedTypesInUse;
    /* 0x0158 */ FRigVMDrawContainer DrawContainer;
    /* 0x0188 */ TArray<FName> EventQueue;
    /* 0x0200 */ TArray<UAssetUserData*> AssetUserData;

    bool CanExecute() const;
    bool Execute(const FName& InEventName);
    bool ExecuteEvent(const FName& InEventName);
    static TArray<URigVMHost*> FindRigVMHosts(UObject* Outer, UClass* OptionalClass);
    float GetAbsoluteTime() const;
    float GetCurrentFramesPerSecond() const;
    float GetDeltaTime() const;
    FRigVMExtendedExecuteContext GetExtendedExecuteContext();
    TArray<FName> GetScriptAccessibleVariables() const;
    TArray<FName> GetSupportedEvents() const;
    URigVM* GetVM();
    FString GetVariableAsString(const FName& InVariableName) const;
    FName GetVariableType(const FName& InVariableName) const;
    bool IsInitRequired() const;
    bool RemoveRunOnceEvent(const FName& InEventName);
    void RequestInit();
    void RequestRunOnceEvent(const FName& InEventName, int32_t InEventIndex);
    void SetAbsoluteAndDeltaTime(float InAbsoluteTime, float InDeltaTime);
    void SetAbsoluteTime(float InAbsoluteTime, bool InSetDeltaTimeZero);
    void SetDeltaTime(float InDeltaTime);
    void SetFramesPerSecond(float InFramesPerSecond);
    bool SetVariableFromString(const FName& InVariableName, FString InValue);
    bool SupportsEvent(const FName& InEventName) const;
};

// Size: 0x8
struct FRigVMInstruction {
    /* 0x0000 */ int32_t ByteCodeIndex;
    /* 0x0004 */ ERigVMOpCode OpCode;
    /* 0x0005 */ uint8_t OperandAlignment;
};

// Size: 0x10
struct FRigVMInstructionArray {
    /* 0x0000 */ TArray<FRigVMInstruction> Instructions;
};

// Size: 0x50
struct FRigVMInstructionSetExecuteState {
    /* 0x0000 */ TMap<uint32_t, uint32_t> SliceHashToNumInstruction;
};

// Size: 0x28
struct FRigVMInstructionVisitInfo {
};

// Size: 0xc
struct FRigVMInvokeEntryOp : public FRigVMBaseOp {
};

// Size: 0x10
struct FRigVMJumpIfOp : public FRigVMUnaryOp {
};

// Size: 0x8
struct FRigVMJumpOp : public FRigVMBaseOp {
};

// Size: 0xc
struct FRigVMJumpToBranchOp : public FRigVMUnaryOp {
};

// Size: 0xa0
struct FRigVMMemoryContainer {
    /* 0x0000 */ bool bUseNameMap;
    /* 0x0001 */ ERigVMMemoryType MemoryType;
    /* 0x0008 */ TArray<FRigVMRegister> Registers;
    /* 0x0018 */ TArray<FRigVMRegisterOffset> RegisterOffsets;
    /* 0x0028 */ TArray<uint8_t> Data;
    /* 0x0038 */ TArray<UScriptStruct*> ScriptStructs;
    /* 0x0048 */ TMap<FName, int32_t> NameMap;
    /* 0x0098 */ bool bEncounteredErrorDuringLoad;
};

// Size: 0xc
struct FRigVMMemoryStatistics {
    /* 0x0000 */ int32_t RegisterCount;
    /* 0x0004 */ int32_t DataBytes;
    /* 0x0008 */ int32_t TotalBytes;
};

// Size: 0x28
class URigVMMemoryStorage : public UObject {
};

// Size: 0x240
class URigVMMemoryStorageGeneratorClass : public UClass {
};

// Size: 0x50
struct FRigVMMemoryStorageStruct : public FInstancedPropertyBag {
};

// Size: 0x28
struct FRigVMMirrorSettings {
    /* 0x0000 */ uint8_t MirrorAxis;
    /* 0x0001 */ uint8_t AxisToFlip;
    /* 0x0008 */ FString SearchString;
    /* 0x0018 */ FString ReplaceString;
};

// Size: 0x3b0
class URigVMNativized : public URigVM {
};

// Size: 0xb0
struct FRigVMNodeLayout {
    /* 0x0000 */ TArray<FRigVMPinCategory> Categories;
    /* 0x0010 */ TMap<FString, int32_t> PinIndexInCategory;
    /* 0x0060 */ TMap<FString, FString> DisplayNames;
};

// Size: 0x20
struct FRigVMObjectArchive {
    /* 0x0000 */ TArray<uint8_t> Buffer;
    /* 0x0010 */ int32_t UncompressedSize;
    /* 0x0014 */ int32_t CompressedSize;
    /* 0x0018 */ bool bIsCompressed;
};

// Size: 0x6
struct FRigVMOperand {
    /* 0x0000 */ ERigVMMemoryType MemoryType;
    /* 0x0002 */ uint16_t RegisterIndex;
    /* 0x0004 */ uint16_t RegisterOffset;
};

// Size: 0x30
struct FRigVMParameter {
    /* 0x0000 */ ERigVMParameterType Type;
    /* 0x0004 */ FName Name;
    /* 0x000c */ int32_t RegisterIndex;
    /* 0x0010 */ FString CPPType;
    /* 0x0020 */ UScriptStruct* ScriptStruct;
    /* 0x0028 */ FName ScriptStructPath;
};

// Size: 0x28
struct FRigVMPinCategory {
    /* 0x0000 */ FString Path;
    /* 0x0010 */ TArray<FString> Elements;
    /* 0x0020 */ bool bExpandedByDefault;
};

// Size: 0x38
struct FRigVMPredicateBranch {
};

// Size: 0x28
struct FRigVMProfilingInfo {
};

// Size: 0x48
class URigVMProjectSettings : public UDeveloperSettings {
    /* 0x0038 */ TArray<FRigVMTag> VariantTags;

    FRigVMTag GetTag(FName InTagName) const;
};

// Size: 0x1a
struct FRigVMQuaternaryOp : public FRigVMBaseOp {
};

// Size: 0x20
struct FRigVMQuinaryOp : public FRigVMBaseOp {
};

// Size: 0x24
struct FRigVMRegister {
    /* 0x0000 */ ERigVMRegisterType Type;
    /* 0x0004 */ uint32_t ByteIndex;
    /* 0x0008 */ uint16_t ElementSize;
    /* 0x000a */ uint16_t ElementCount;
    /* 0x000c */ uint16_t SliceCount;
    /* 0x000e */ uint8_t AlignmentBytes;
    /* 0x0010 */ uint16_t TrailingBytes;
    /* 0x0014 */ FName Name;
    /* 0x001c */ int32_t ScriptStructIndex;
    /* 0x0020 */ bool bIsArray;
    /* 0x0021 */ bool bIsDynamic;
};

// Size: 0x48
struct FRigVMRegisterOffset {
    /* 0x0000 */ TArray<int32_t> Segments;
    /* 0x0010 */ ERigVMRegisterType Type;
    /* 0x0014 */ FName CPPType;
    /* 0x0020 */ UScriptStruct* ScriptStruct;
    /* 0x0028 */ UScriptStruct* ParentScriptStruct;
    /* 0x0030 */ int32_t ArrayIndex;
    /* 0x0034 */ uint16_t ElementSize;
    /* 0x0038 */ FString CachedSegmentPath;
};

// Size: 0x10
struct FRigVMRunInstructionsOp : public FRigVMUnaryOp {
};

// Size: 0x18
struct FRigVMRuntimeSettings {
    /* 0x0000 */ int32_t MaximumArraySize;
};

// Size: 0x26
struct FRigVMSenaryOp : public FRigVMBaseOp {
};

// Size: 0x8
struct FRigVMSetupTraitsOp : public FRigVMUnaryOp {
};

// Size: 0x40
struct FRigVMSimPoint {
    /* 0x0000 */ float Mass;
    /* 0x0004 */ float Size;
    /* 0x0008 */ float LinearDamping;
    /* 0x000c */ float InheritMotion;
    /* 0x0010 */ FVector position;
    /* 0x0028 */ FVector LinearVelocity;
};

// Size: 0x14
struct FRigVMSlice {
};

// Size: 0x38
struct FRigVMStatistics {
    /* 0x0000 */ int32_t BytesForCDO;
    /* 0x0004 */ int32_t BytesPerInstance;
    /* 0x0008 */ FRigVMMemoryStatistics LiteralMemory;
    /* 0x0014 */ FRigVMMemoryStatistics WorkMemory;
    /* 0x0020 */ FRigVMMemoryStatistics DebugMemory;
    /* 0x002c */ int32_t BytesForCaching;
    /* 0x0030 */ FRigVMByteCodeStatistics ByteCode;
};

// Size: 0x8
struct FRigVMStruct {
};

// Size: 0x10
struct FRigVMStructMutable : public FRigVMStruct {
    /* 0x0008 */ FRigVMExecutePin ExecutePin;
};

// Size: 0x40
struct FRigVMTag {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FString Label;
    /* 0x0018 */ FText Tooltip;
    /* 0x0028 */ FLinearColor Color;
    /* 0x0038 */ bool bShowInUserInterface;
    /* 0x0039 */ bool bMarksSubjectAsInvalid;
};

// Size: 0x10
struct FRigVMTemplateArgumentType {
    /* 0x0000 */ FName CPPType;
    /* 0x0008 */ UObject* CPPTypeObject;
};

// Size: 0x14
struct FRigVMTernaryOp : public FRigVMBaseOp {
};

// Size: 0x18
struct FRigVMTrait : public FRigVMStruct {
    /* 0x0008 */ FString Name;
};

// Size: 0x8
struct FRigVMUnaryOp : public FRigVMBaseOp {
};

// Size: 0x4
struct FRigVMUnknownType {
    /* 0x0000 */ uint32_t Hash;
};

// Size: 0x58
struct FRigVMUserWorkflow {
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Tooltip;
    /* 0x0028 */ ERigVMUserWorkflowType Type;
    /* 0x0040 */ FDelegate PerformDynamicDelegate;
    /* 0x0050 */ UClass* OptionsClass;
};

// Size: 0x98
class URigVMUserWorkflowOptions : public UObject {
    /* 0x0028 */ UObject* Subject;
    /* 0x0030 */ FRigVMUserWorkflow Workflow;

    bool IsValid() const;
    void ReportError(FString InMessage);
    void ReportInfo(FString InMessage);
    void ReportWarning(FString InMessage);
    bool RequiresDialog() const;
};

// Size: 0x20
struct FRigVMVariant {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ TArray<FRigVMTag> Tags;
};

// Size: 0x40
struct FRigVMVariantRef {
    /* 0x0000 */ FSoftObjectPath ObjectPath;
    /* 0x0020 */ FRigVMVariant Variant;
};

enum class ESequenceTimeUnit {
    DisplayRate = 0,
    TickResolution = 1,
    ESequenceTimeUnit_MAX = 2,
};

// Size: 0x28
class UMovieSceneBindingExtensions : public UBlueprintFunctionLibrary {

    static UMovieSceneTrack* AddTrack(const FMovieSceneBindingProxy& InBinding, UClass* TrackType);
    static bool EqualEqual_MovieSceneBindingProxy(FMovieSceneBindingProxy A, FMovieSceneBindingProxy B);
    static TArray<UMovieSceneTrack*> FindTracksByExactType(const FMovieSceneBindingProxy& InBinding, UClass* TrackType);
    static TArray<UMovieSceneTrack*> FindTracksByType(const FMovieSceneBindingProxy& InBinding, UClass* TrackType);
    static TArray<FMovieSceneBindingProxy> GetChildPossessables(const FMovieSceneBindingProxy& InBinding);
    static FText GetDisplayName(const FMovieSceneBindingProxy& InBinding);
    static FGuid GetId(const FMovieSceneBindingProxy& InBinding);
    static FString GetName(const FMovieSceneBindingProxy& InBinding);
    static UObject* GetObjectTemplate(const FMovieSceneBindingProxy& InBinding);
    static FMovieSceneBindingProxy GetParent(const FMovieSceneBindingProxy& InBinding);
    static UClass* GetPossessedObjectClass(const FMovieSceneBindingProxy& InBinding);
    static int32_t GetSortingOrder(const FMovieSceneBindingProxy& InBinding);
    static TArray<UMovieSceneTrack*> GetTracks(const FMovieSceneBindingProxy& InBinding);
    static bool IsValid(const FMovieSceneBindingProxy& InBinding);
    static void MoveBindingContents(const FMovieSceneBindingProxy& SourceBindingId, const FMovieSceneBindingProxy& DestinationBindingId);
    static bool NotEqual_MovieSceneBindingProxy(FMovieSceneBindingProxy A, FMovieSceneBindingProxy B);
    static void Remove(const FMovieSceneBindingProxy& InBinding);
    static void RemoveTrack(const FMovieSceneBindingProxy& InBinding, UMovieSceneTrack* TrackToRemove);
    static void SetDisplayName(const FMovieSceneBindingProxy& InBinding, const FText& InDisplayName);
    static void SetName(const FMovieSceneBindingProxy& InBinding, FString InName);
    static void SetParent(const FMovieSceneBindingProxy& InBinding, const FMovieSceneBindingProxy& InParentBinding);
    static void SetSortingOrder(const FMovieSceneBindingProxy& InBinding, int32_t SortingOrder);
    static void SetSpawnableBindingID(const FMovieSceneBindingProxy& InBinding, const FMovieSceneObjectBindingID& SpawnableBindingID);
};

// Size: 0x28
class UMovieSceneDoubleVectorTrackExtensions : public UBlueprintFunctionLibrary {

    static int32_t GetNumChannelsUsed(UMovieSceneDoubleVectorTrack* Track);
    static void SetNumChannelsUsed(UMovieSceneDoubleVectorTrack* Track, int32_t InNumChannelsUsed);
};

// Size: 0x28
class UMovieSceneEventTrackExtensions : public UBlueprintFunctionLibrary {

    static UMovieSceneEventRepeaterSection* AddEventRepeaterSection(UMovieSceneEventTrack* InTrack);
    static UMovieSceneEventTriggerSection* AddEventTriggerSection(UMovieSceneEventTrack* InTrack);
    static UClass* GetBoundObjectPropertyClass(const FMovieSceneEvent& EventKey);
};

// Size: 0x28
class UMovieSceneFloatVectorTrackExtensions : public UBlueprintFunctionLibrary {

    static int32_t GetNumChannelsUsed(UMovieSceneFloatVectorTrack* Track);
    static void SetNumChannelsUsed(UMovieSceneFloatVectorTrack* Track, int32_t InNumChannelsUsed);
};

// Size: 0x28
class UMovieSceneFolderExtensions : public UBlueprintFunctionLibrary {

    static bool AddChildFolder(UMovieSceneFolder* TargetFolder, UMovieSceneFolder* FolderToAdd);
    static bool AddChildObjectBinding(UMovieSceneFolder* folder, FMovieSceneBindingProxy InObjectBinding);
    static bool AddChildTrack(UMovieSceneFolder* folder, UMovieSceneTrack* InTrack);
    static TArray<UMovieSceneFolder*> GetChildFolders(UMovieSceneFolder* folder);
    static TArray<FMovieSceneBindingProxy> GetChildObjectBindings(UMovieSceneFolder* folder);
    static TArray<UMovieSceneTrack*> GetChildTracks(UMovieSceneFolder* folder);
    static FColor GetFolderColor(UMovieSceneFolder* folder);
    static FName GetFolderName(UMovieSceneFolder* folder);
    static bool RemoveChildFolder(UMovieSceneFolder* TargetFolder, UMovieSceneFolder* FolderToRemove);
    static bool RemoveChildObjectBinding(UMovieSceneFolder* folder, const FMovieSceneBindingProxy InObjectBinding);
    static bool RemoveChildTrack(UMovieSceneFolder* folder, UMovieSceneTrack* InTrack);
    static bool SetFolderColor(UMovieSceneFolder* folder, FColor InFolderColor);
    static bool SetFolderName(UMovieSceneFolder* folder, FName InFolderName);
};

// Size: 0x28
class UMovieSceneMaterialTrackExtensions : public UBlueprintFunctionLibrary {

    static int32_t GetMaterialIndex(UMovieSceneComponentMaterialTrack* Track);
    static FComponentMaterialInfo GetMaterialInfo(UMovieSceneComponentMaterialTrack* Track);
    static void SetMaterialIndex(UMovieSceneComponentMaterialTrack* Track, const int32_t MaterialIndex);
    static void SetMaterialInfo(UMovieSceneComponentMaterialTrack* Track, const FComponentMaterialInfo& MaterialInfo);
};

// Size: 0x28
class UMovieScenePrimitiveMaterialTrackExtensions : public UBlueprintFunctionLibrary {

    static int32_t GetMaterialIndex(UMovieScenePrimitiveMaterialTrack* Track);
    static FComponentMaterialInfo GetMaterialInfo(UMovieScenePrimitiveMaterialTrack* Track);
    static void SetMaterialIndex(UMovieScenePrimitiveMaterialTrack* Track, const int32_t MaterialIndex);
    static void SetMaterialInfo(UMovieScenePrimitiveMaterialTrack* Track, const FComponentMaterialInfo& MaterialInfo);
};

// Size: 0x28
class UMovieScenePropertyTrackExtensions : public UBlueprintFunctionLibrary {

    static UEnum* GetByteTrackEnum(UMovieSceneByteTrack* Track);
    static UClass* GetObjectPropertyClass(UMovieSceneObjectPropertyTrack* Track);
    static FName GetPropertyName(UMovieScenePropertyTrack* Track);
    static FString GetPropertyPath(UMovieScenePropertyTrack* Track);
    static FName GetUniqueTrackName(UMovieScenePropertyTrack* Track);
    static void SetByteTrackEnum(UMovieSceneByteTrack* Track, UEnum* InEnum);
    static void SetObjectPropertyClass(UMovieSceneObjectPropertyTrack* Track, UClass* PropertyClass);
    static void SetPropertyNameAndPath(UMovieScenePropertyTrack* Track, const FName& InPropertyName, FString InPropertyPath);
};

// Size: 0x60
class UMovieSceneScriptingActorReferenceChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingActorReferenceKey* AddKey(const FFrameNumber InTime, FMovieSceneObjectBindingID NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    FMovieSceneObjectBindingID GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(FMovieSceneObjectBindingID InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingActorReferenceKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    FMovieSceneObjectBindingID GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(const FMovieSceneObjectBindingID& InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingActualFloatKey : public UMovieSceneScriptingFloatKey {
};

// Size: 0x60
class UMovieSceneScriptingBoolChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingBoolKey* AddKey(const FFrameNumber& InTime, bool NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    FSequencerScriptingRange ComputeEffectiveRange() const;
    TArray<bool> EvaluateKeys(FSequencerScriptingRange Range, FFrameRate FrameRate) const;
    bool GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    int32_t GetNumKeys() const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(bool InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingBoolKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    bool GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(bool InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingByteChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingByteKey* AddKey(const FFrameNumber& InTime, uint8_t NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit, EMovieSceneKeyInterpolation InInterpolation);
    uint8_t GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(uint8_t InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingByteKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    uint8_t GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(uint8_t InNewValue);
};

// Size: 0x30
class UMovieSceneScriptingChannel : public UObject {
    /* 0x0028 */ FName ChannelName;
};

// Size: 0x60
class UMovieSceneScriptingDoubleAsFloatKey : public UMovieSceneScriptingFloatKey {
};

// Size: 0x60
class UMovieSceneScriptingDoubleChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingDoubleKey* AddKey(const FFrameNumber& InTime, double NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit, EMovieSceneKeyInterpolation InInterpolation);
    FSequencerScriptingRange ComputeEffectiveRange() const;
    TArray<double> EvaluateKeys(FSequencerScriptingRange Range, FFrameRate FrameRate) const;
    double GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    int32_t GetNumKeys() const;
    uint8_t GetPostInfinityExtrapolation() const;
    uint8_t GetPreInfinityExtrapolation() const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(double InDefaultValue);
    void SetPostInfinityExtrapolation(uint8_t InExtrapolation);
    void SetPreInfinityExtrapolation(uint8_t InExtrapolation);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingDoubleKey : public UMovieSceneScriptingKey {

    float GetArriveTangent() const;
    float GetArriveTangentWeight() const;
    uint8_t GetInterpolationMode() const;
    float GetLeaveTangent() const;
    float GetLeaveTangentWeight() const;
    uint8_t GetTangentMode() const;
    uint8_t GetTangentWeightMode() const;
    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    double GetValue() const;
    void SetArriveTangent(float InNewValue);
    void SetArriveTangentWeight(float InNewValue);
    void SetInterpolationMode(uint8_t InNewValue);
    void SetLeaveTangent(float InNewValue);
    void SetLeaveTangentWeight(float InNewValue);
    void SetTangentMode(uint8_t InNewValue);
    void SetTangentWeightMode(uint8_t InNewValue);
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(double InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingEventChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingEventKey* AddKey(const FFrameNumber& InTime, FMovieSceneEvent NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingEventKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    FMovieSceneEvent GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(const FMovieSceneEvent& InNewValue);
};

// Size: 0x80
class UMovieSceneScriptingFloatChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingFloatKey* AddKey(const FFrameNumber& InTime, float NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit, EMovieSceneKeyInterpolation InInterpolation);
    FSequencerScriptingRange ComputeEffectiveRange() const;
    TArray<float> EvaluateKeys(FSequencerScriptingRange Range, FFrameRate FrameRate) const;
    float GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    int32_t GetNumKeys() const;
    uint8_t GetPostInfinityExtrapolation() const;
    uint8_t GetPreInfinityExtrapolation() const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(float InDefaultValue);
    void SetPostInfinityExtrapolation(uint8_t InExtrapolation);
    void SetPreInfinityExtrapolation(uint8_t InExtrapolation);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x40
class UMovieSceneScriptingFloatKey : public UMovieSceneScriptingKey {

    float GetArriveTangent() const;
    float GetArriveTangentWeight() const;
    uint8_t GetInterpolationMode() const;
    float GetLeaveTangent() const;
    float GetLeaveTangentWeight() const;
    uint8_t GetTangentMode() const;
    uint8_t GetTangentWeightMode() const;
    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    float GetValue() const;
    void SetArriveTangent(float InNewValue);
    void SetArriveTangentWeight(float InNewValue);
    void SetInterpolationMode(uint8_t InNewValue);
    void SetLeaveTangent(float InNewValue);
    void SetLeaveTangentWeight(float InNewValue);
    void SetTangentMode(uint8_t InNewValue);
    void SetTangentWeightMode(uint8_t InNewValue);
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(float InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingIntegerChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingIntegerKey* AddKey(const FFrameNumber& InTime, int32_t NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    TArray<int32_t> EvaluateKeys(FSequencerScriptingRange Range, FFrameRate FrameRate) const;
    int32_t GetDefault() const;
    bool GetInterpolateLinearKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    int32_t GetNumKeys() const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(int32_t InDefaultValue);
    void SetInterpolateLinearKeys(bool bInInterpolateLinearKeys);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingIntegerKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    int32_t GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(int32_t InNewValue);
};

// Size: 0x40
class UMovieSceneScriptingKey : public UObject {
};

// Size: 0x60
class UMovieSceneScriptingObjectPathChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingObjectPathKey* AddKey(const FFrameNumber InTime, UObject* NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    UObject* GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(UObject* InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingObjectPathKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    UObject* GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(UObject* InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingParticleChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingParticleKey* AddKey(const FFrameNumber& InTime, EParticleKey NewParticleValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    FSequencerScriptingRange ComputeEffectiveRange() const;
    TArray<EParticleKey> EvaluateKeys(FSequencerScriptingRange Range, FFrameRate FrameRate) const;
    EParticleKey GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    int32_t GetNumKeys() const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(EParticleKey InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingParticleKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    EParticleKey GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(EParticleKey InNewValue);
};

// Size: 0x60
class UMovieSceneScriptingStringChannel : public UMovieSceneScriptingChannel {

    UMovieSceneScriptingStringKey* AddKey(const FFrameNumber& InTime, FString NewValue, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    FString GetDefault() const;
    TArray<UMovieSceneScriptingKey*> GetKeys() const;
    TArray<UMovieSceneScriptingKey*> GetKeysByIndex(const TArray<int32_t>& Indices) const;
    bool HasDefault() const;
    void RemoveDefault();
    void RemoveKey(UMovieSceneScriptingKey* Key);
    void SetDefault(FString InDefaultValue);
    void Transform(FFrameNumber OffsetFrame, double Scale, FFrameNumber PivotFrame, FSequencerScriptingRange ScriptingRange, EMovieSceneTimeUnit TimeUnit);
};

// Size: 0x60
class UMovieSceneScriptingStringKey : public UMovieSceneScriptingKey {

    FFrameTime GetTime(EMovieSceneTimeUnit TimeUnit) const;
    FString GetValue() const;
    void SetTime(const FFrameNumber& NewFrameNumber, float SubFrame, EMovieSceneTimeUnit TimeUnit);
    void SetValue(FString InNewValue);
};

// Size: 0x28
class UMovieSceneSectionExtensions : public UBlueprintFunctionLibrary {

    static TArray<UMovieSceneScriptingChannel*> GetAllChannels(UMovieSceneSection* Section);
    static int32_t GetAutoSizeEndFrame(UMovieSceneSection* Section);
    static float GetAutoSizeEndFrameSeconds(UMovieSceneSection* Section);
    static bool GetAutoSizeHasEndFrame(UMovieSceneSection* Section);
    static bool GetAutoSizeHasStartFrame(UMovieSceneSection* Section);
    static int32_t GetAutoSizeStartFrame(UMovieSceneSection* Section);
    static float GetAutoSizeStartFrameSeconds(UMovieSceneSection* Section);
    static UMovieSceneScriptingChannel* GetChannel(UMovieSceneSection* Section, const FName& ChannelName);
    static TArray<UMovieSceneScriptingChannel*> GetChannelsByType(UMovieSceneSection* Section, UClass* ChannelType);
    static int32_t GetEndFrame(UMovieSceneSection* Section);
    static float GetEndFrameSeconds(UMovieSceneSection* Section);
    static int32_t GetParentSequenceFrame(UMovieSceneSubSection* Section, int32_t InFrame, UMovieSceneSequence* ParentSequence);
    static int32_t GetStartFrame(UMovieSceneSection* Section);
    static float GetStartFrameSeconds(UMovieSceneSection* Section);
    static bool HasEndFrame(UMovieSceneSection* Section);
    static bool HasStartFrame(UMovieSceneSection* Section);
    static void SetEndFrame(UMovieSceneSection* Section, int32_t EndFrame);
    static void SetEndFrameBounded(UMovieSceneSection* Section, bool bIsBounded);
    static void SetEndFrameSeconds(UMovieSceneSection* Section, float EndTime);
    static void SetRange(UMovieSceneSection* Section, int32_t StartFrame, int32_t EndFrame);
    static void SetRangeSeconds(UMovieSceneSection* Section, float StartTime, float EndTime);
    static void SetStartFrame(UMovieSceneSection* Section, int32_t StartFrame);
    static void SetStartFrameBounded(UMovieSceneSection* Section, bool bIsBounded);
    static void SetStartFrameSeconds(UMovieSceneSection* Section, float StartTime);
};

// Size: 0x28
class UMovieSceneSequenceExtensions : public UBlueprintFunctionLibrary {

    static int32_t AddMarkedFrame(UMovieSceneSequence* Sequence, const FMovieSceneMarkedFrame& InMarkedFrame);
    static int32_t AddMarkedFrameToSequence(UMovieSceneSequence* Sequence, const FMovieSceneMarkedFrame& InMarkedFrame, EMovieSceneTimeUnit TimeUnit);
    static FMovieSceneBindingProxy AddPossessable(UMovieSceneSequence* Sequence, UObject* ObjectToPossess);
    static UMovieSceneFolder* AddRootFolderToSequence(UMovieSceneSequence* Sequence, FString NewFolderName);
    static FMovieSceneBindingProxy AddSpawnableFromClass(UMovieSceneSequence* Sequence, UClass* ClassToSpawn);
    static FMovieSceneBindingProxy AddSpawnableFromInstance(UMovieSceneSequence* Sequence, UObject* ObjectToSpawn);
    static UMovieSceneTrack* AddTrack(UMovieSceneSequence* Sequence, UClass* TrackType);
    static bool AreMarkedFramesLocked(UMovieSceneSequence* Sequence);
    static void DeleteMarkedFrame(UMovieSceneSequence* Sequence, int32_t DeleteIndex);
    static void DeleteMarkedFrames(UMovieSceneSequence* Sequence);
    static FMovieSceneBindingProxy FindBindingById(UMovieSceneSequence* Sequence, FGuid BindingID);
    static FMovieSceneBindingProxy FindBindingByName(UMovieSceneSequence* Sequence, FString Name);
    static int32_t FindMarkedFrameByFrameNumber(UMovieSceneSequence* Sequence, FFrameNumber InFrameNumber);
    static int32_t FindMarkedFrameByFrameNumberInSequence(UMovieSceneSequence* Sequence, FFrameNumber InFrameNumber, EMovieSceneTimeUnit TimeUnit);
    static int32_t FindMarkedFrameByLabel(UMovieSceneSequence* Sequence, FString InLabel);
    static int32_t FindNextMarkedFrame(UMovieSceneSequence* Sequence, FFrameNumber InFrameNumber, bool bForward);
    static int32_t FindNextMarkedFrameInSequence(UMovieSceneSequence* Sequence, FFrameNumber InFrameNumber, bool bForward, EMovieSceneTimeUnit TimeUnit);
    static TArray<UMovieSceneTrack*> FindTracksByExactType(UMovieSceneSequence* Sequence, UClass* TrackType);
    static TArray<UMovieSceneTrack*> FindTracksByType(UMovieSceneSequence* Sequence, UClass* TrackType);
    static FMovieSceneObjectBindingID GetBindingID(UMovieSceneSequence* Sequence, const FMovieSceneBindingProxy& InBinding);
    static TArray<FMovieSceneBindingProxy> GetBindings(UMovieSceneSequence* Sequence);
    static EUpdateClockSource GetClockSource(UMovieSceneSequence* InSequence);
    static FFrameRate GetDisplayRate(UMovieSceneSequence* Sequence);
    static EMovieSceneEvaluationType GetEvaluationType(UMovieSceneSequence* InSequence);
    static TArray<FMovieSceneMarkedFrame> GetMarkedFrames(UMovieSceneSequence* Sequence);
    static TArray<FMovieSceneMarkedFrame> GetMarkedFramesFromSequence(UMovieSceneSequence* Sequence, EMovieSceneTimeUnit TimeUnit);
    static UMovieScene* GetMovieScene(UMovieSceneSequence* Sequence);
    static int32_t GetPlaybackEnd(UMovieSceneSequence* Sequence);
    static float GetPlaybackEndSeconds(UMovieSceneSequence* Sequence);
    static FSequencerScriptingRange GetPlaybackRange(UMovieSceneSequence* Sequence);
    static int32_t GetPlaybackStart(UMovieSceneSequence* Sequence);
    static float GetPlaybackStartSeconds(UMovieSceneSequence* Sequence);
    static FMovieSceneObjectBindingID GetPortableBindingID(UMovieSceneSequence* RootSequence, UMovieSceneSequence* DestinationSequence, const FMovieSceneBindingProxy& InBinding);
    static TArray<FMovieSceneBindingProxy> GetPossessables(UMovieSceneSequence* Sequence);
    static TArray<UMovieSceneFolder*> GetRootFoldersInSequence(UMovieSceneSequence* Sequence);
    static TArray<FMovieSceneBindingProxy> GetSpawnables(UMovieSceneSequence* Sequence);
    static FFrameRate GetTickResolution(UMovieSceneSequence* Sequence);
    static TArray<UMovieSceneTrack*> GetTracks(UMovieSceneSequence* Sequence);
    static double GetViewRangeEnd(UMovieSceneSequence* InSequence);
    static double GetViewRangeStart(UMovieSceneSequence* InSequence);
    static double GetWorkRangeEnd(UMovieSceneSequence* InSequence);
    static double GetWorkRangeStart(UMovieSceneSequence* InSequence);
    static bool IsPlaybackRangeLocked(UMovieSceneSequence* Sequence);
    static bool IsReadOnly(UMovieSceneSequence* Sequence);
    static TArray<UObject*> LocateBoundObjects(UMovieSceneSequence* Sequence, const FMovieSceneBindingProxy& InBinding, UObject* Context);
    static FSequencerScriptingRange MakeRange(UMovieSceneSequence* Sequence, int32_t StartFrame, int32_t Duration);
    static FSequencerScriptingRange MakeRangeSeconds(UMovieSceneSequence* Sequence, float StartTime, float Duration);
    static void RemoveRootFolderFromSequence(UMovieSceneSequence* Sequence, UMovieSceneFolder* folder);
    static bool RemoveTrack(UMovieSceneSequence* Sequence, UMovieSceneTrack* Track);
    static FMovieSceneBindingProxy ResolveBindingID(UMovieSceneSequence* RootSequence, FMovieSceneObjectBindingID InObjectBindingID);
    static void SetClockSource(UMovieSceneSequence* InSequence, EUpdateClockSource InClockSource);
    static void SetDisplayRate(UMovieSceneSequence* Sequence, FFrameRate DisplayRate);
    static void SetEvaluationType(UMovieSceneSequence* InSequence, EMovieSceneEvaluationType InEvaluationType);
    static void SetMarkedFrame(UMovieSceneSequence* Sequence, int32_t InMarkIndex, FFrameNumber InFrameNumber);
    static void SetMarkedFrameInSequence(UMovieSceneSequence* Sequence, int32_t InMarkIndex, FFrameNumber InFrameNumber, EMovieSceneTimeUnit TimeUnit);
    static void SetMarkedFramesLocked(UMovieSceneSequence* Sequence, bool bInLocked);
    static void SetPlaybackEnd(UMovieSceneSequence* Sequence, int32_t EndFrame);
    static void SetPlaybackEndSeconds(UMovieSceneSequence* Sequence, float EndTime);
    static void SetPlaybackRangeLocked(UMovieSceneSequence* Sequence, bool bInLocked);
    static void SetPlaybackStart(UMovieSceneSequence* Sequence, int32_t StartFrame);
    static void SetPlaybackStartSeconds(UMovieSceneSequence* Sequence, float StartTime);
    static void SetReadOnly(UMovieSceneSequence* Sequence, bool bInReadOnly);
    static void SetTickResolution(UMovieSceneSequence* Sequence, FFrameRate TickResolution);
    static void SetTickResolutionDirectly(UMovieSceneSequence* Sequence, FFrameRate TickResolution);
    static void SetViewRangeEnd(UMovieSceneSequence* InSequence, double EndTimeInSeconds);
    static void SetViewRangeStart(UMovieSceneSequence* InSequence, double StartTimeInSeconds);
    static void SetWorkRangeEnd(UMovieSceneSequence* InSequence, double EndTimeInSeconds);
    static void SetWorkRangeStart(UMovieSceneSequence* InSequence, double StartTimeInSeconds);
    static void SortMarkedFrames(UMovieSceneSequence* Sequence);
};

// Size: 0x28
class UMovieSceneTimeWarpExtensions : public UBlueprintFunctionLibrary {

    static void BreakTimeWarp(const FMovieSceneTimeWarpVariant& TimeWarp, double& FixedPlayRate);
    static FMovieSceneTimeWarpVariant Conv_PlayRateToTimeWarpVariant(double ConstantPlayRate);
    static double Conv_TimeWarpVariantToPlayRate(const FMovieSceneTimeWarpVariant& TimeWarp);
    static FMovieSceneTimeWarpVariant MakeTimeWarp(double FixedPlayRate);
    static void SetFixedPlayRate(FMovieSceneTimeWarpVariant& TimeWarp, double FixedPlayRate);
    static double ToFixedPlayRate(const FMovieSceneTimeWarpVariant& TimeWarp);
};

// Size: 0x28
class UMovieSceneTrackExtensions : public UBlueprintFunctionLibrary {

    static UMovieSceneSection* AddSection(UMovieSceneTrack* Track);
    static FColor GetColorTint(UMovieSceneTrack* Track);
    static FText GetDisplayName(UMovieSceneTrack* Track);
    static UMovieSceneSection* GetSectionToKey(UMovieSceneTrack* Track);
    static TArray<UMovieSceneSection*> GetSections(UMovieSceneTrack* Track);
    static int32_t GetSortingOrder(UMovieSceneTrack* Track);
    static FText GetTrackRowDisplayName(UMovieSceneTrack* Track, int32_t RowIndex);
    static void RemoveSection(UMovieSceneTrack* Track, UMovieSceneSection* Section);
    static void SetColorTint(UMovieSceneTrack* Track, const FColor& ColorTint);
    static void SetDisplayName(UMovieSceneTrack* Track, const FText& InName);
    static void SetSectionToKey(UMovieSceneTrack* Track, UMovieSceneSection* Section);
    static void SetSortingOrder(UMovieSceneTrack* Track, int32_t SortingOrder);
    static void SetTrackRowDisplayName(UMovieSceneTrack* Track, const FText& InName, int32_t RowIndex);
};

// Size: 0x14
struct FSequencerScriptingRange {
    /* 0x0000 */ bool bHasStart;
    /* 0x0000 */ bool bHasEnd;
    /* 0x0004 */ int32_t InclusiveStart;
    /* 0x0008 */ int32_t ExclusiveEnd;
    /* 0x000c */ FFrameRate InternalRate;
};

// Size: 0x28
class USequencerScriptingRangeExtensions : public UBlueprintFunctionLibrary {

    static int32_t GetEndFrame(const FSequencerScriptingRange& Range);
    static float GetEndSeconds(const FSequencerScriptingRange& Range);
    static int32_t GetStartFrame(const FSequencerScriptingRange& Range);
    static float GetStartSeconds(const FSequencerScriptingRange& Range);
    static bool HasEnd(const FSequencerScriptingRange& Range);
    static bool HasStart(const FSequencerScriptingRange& Range);
    static void RemoveEnd(FSequencerScriptingRange& Range);
    static void RemoveStart(FSequencerScriptingRange& Range);
    static void SetEndFrame(FSequencerScriptingRange& Range, int32_t End);
    static void SetEndSeconds(FSequencerScriptingRange& Range, float End);
    static void SetStartFrame(FSequencerScriptingRange& Range, int32_t Start);
    static void SetStartSeconds(FSequencerScriptingRange& Range, float Start);
};

// Size: 0x28
class UObjectTest : public UObject {
};

// Size: 0x3c
struct FOrientedBoxFloat {
    /* 0x0000 */ FVector3f Center;
    /* 0x000c */ FVector3f AxisX;
    /* 0x0018 */ FVector3f AxisY;
    /* 0x0024 */ FVector3f AxisZ;
    /* 0x0030 */ float ExtentX;
    /* 0x0034 */ float ExtentY;
    /* 0x0038 */ float ExtentZ;
};

// Size: 0x60
struct FStructSerializerArrayTestStruct {
    /* 0x0000 */ TArray<int32_t> Int32Array;
    /* 0x0010 */ TArray<uint8_t> ByteArray;
    /* 0x0020 */ int32_t StaticSingleElement;
    /* 0x0024 */ int32_t StaticInt32Array[3];
    /* 0x0030 */ float StaticFloatArray[3];
    /* 0x0040 */ TArray<FVector> VectorArray;
    /* 0x0050 */ TArray<FStructSerializerBuiltinTestStruct> StructArray;
};

// Size: 0x3
struct FStructSerializerBooleanTestStruct {
    /* 0x0000 */ bool BoolFalse;
    /* 0x0001 */ bool BoolTrue;
    /* 0x0002 */ bool Bitfield0;
    /* 0x0002 */ bool Bitfield1;
    /* 0x0002 */ bool Bitfield2Set;
    /* 0x0002 */ bool Bitfield3;
    /* 0x0002 */ bool Bitfield4Set;
    /* 0x0002 */ bool Bitfield5Set;
    /* 0x0002 */ bool Bitfield6;
    /* 0x0002 */ bool Bitfield7Set;
};

// Size: 0xd0
struct FStructSerializerBuiltinTestStruct {
    /* 0x0000 */ FGuid Guid;
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FString String;
    /* 0x0028 */ FText Text;
    /* 0x0038 */ FDateTime DateTime;
    /* 0x0040 */ FTimespan Timespan;
    /* 0x0048 */ FVector Vector;
    /* 0x0060 */ FVector4 Vector4;
    /* 0x0080 */ FRotator Rotator;
    /* 0x00a0 */ FQuat Quat;
    /* 0x00c0 */ FColor Color;
};

// Size: 0x38
struct FStructSerializerByteArray {
    /* 0x0000 */ int32_t Dummy1;
    /* 0x0008 */ TArray<uint8_t> ByteArray;
    /* 0x0018 */ int32_t Dummy2;
    /* 0x0020 */ TArray<int8_t> Int8Array;
    /* 0x0030 */ int32_t Dummy3;
};

// Size: 0x360
struct FStructSerializerLWCTypesTest {
    /* 0x0000 */ FVector Vector;
    /* 0x0018 */ FVector2D Vector2D;
    /* 0x0030 */ FVector4 Vector4;
    /* 0x0050 */ FMatrix Matrix;
    /* 0x00d0 */ FPlane Plane;
    /* 0x00f0 */ FQuat Quat;
    /* 0x0110 */ FRotator Rotator;
    /* 0x0130 */ FTransform Transform;
    /* 0x0190 */ FBox Box;
    /* 0x01c8 */ FBox2D Box2D;
    /* 0x01f0 */ FBoxSphereBounds BoxSphereBounds;
    /* 0x0228 */ FOrientedBox OrientedBox;
    /* 0x02a0 */ float float;
    /* 0x02a8 */ double Double;
    /* 0x02b0 */ TArray<FVector> VectorArray;
    /* 0x02c0 */ TMap<FString, FVector> StrToVec;
    /* 0x0310 */ TSet<FVector> VectorSet;
};

// Size: 0x140
struct FStructSerializerMapTestStruct {
    /* 0x0000 */ TMap<int32_t, FString> IntToStr;
    /* 0x0050 */ TMap<FString, FString> StrToStr;
    /* 0x00a0 */ TMap<FString, FVector> StrToVec;
    /* 0x00f0 */ TMap<FString, FStructSerializerBuiltinTestStruct> StrToStruct;
};

// Size: 0x220
struct FStructSerializerNonLWCTypesTest {
    /* 0x0000 */ FVector3f Vector;
    /* 0x000c */ FVector2f Vector2D;
    /* 0x0020 */ FVector4f Vector4;
    /* 0x0030 */ FMatrix44f Matrix;
    /* 0x0070 */ FPlane4f Plane;
    /* 0x0080 */ FQuat4f Quat;
    /* 0x0090 */ FRotator3f Rotator;
    /* 0x00a0 */ FTransform3f Transform;
    /* 0x00d0 */ FBox3f Box;
    /* 0x00ec */ FBox2f Box2D;
    /* 0x0100 */ FBoxSphereBounds3f BoxSphereBounds;
    /* 0x011c */ FOrientedBoxFloat OrientedBox;
    /* 0x0158 */ float float;
    /* 0x0160 */ double Double;
    /* 0x0168 */ TArray<FVector3f> VectorArray;
    /* 0x0178 */ TMap<FString, FVector3f> StrToVec;
    /* 0x01c8 */ TSet<FVector3f> VectorSet;
};

// Size: 0x30
struct FStructSerializerNumericTestStruct {
    /* 0x0000 */ int8_t int8;
    /* 0x0002 */ int16_t int16;
    /* 0x0004 */ int32_t int32;
    /* 0x0008 */ int64_t int64;
    /* 0x0010 */ uint8_t uint8;
    /* 0x0012 */ uint16_t uint16;
    /* 0x0014 */ uint32_t uint32;
    /* 0x0018 */ uint64_t uint64;
    /* 0x0020 */ float float;
    /* 0x0028 */ double Double;
};

// Size: 0xc0
struct FStructSerializerObjectTestStruct {
    /* 0x0000 */ UClass* RawClass;
    /* 0x0008 */ UClass* WrappedClass;
    /* 0x0010 */ UClass* SubClass;
    /* 0x0018 */ TSoftClassPtr<UObjectTest> SoftClass;
    /* 0x0040 */ UObject* RawObject;
    /* 0x0048 */ UObject* WrappedObject;
    /* 0x0050 */ TWeakObjectPtr<UObjectTest> WeakObject;
    /* 0x0058 */ TSoftObjectPtr<UObjectTest> SoftObject;
    /* 0x0080 */ FSoftClassPath ClassPath;
    /* 0x00a0 */ FSoftObjectPath ObjectPath;
};

// Size: 0x200
struct FStructSerializerOptionalTestStruct {
    /* 0x0000 */ TOptional<FString> StrOptional;
    /* 0x0010 */ TOptional<FString> StrOptionalUnset;
    /* 0x0020 */ TOptional<int32_t> IntOptional;
    /* 0x0028 */ TOptional<int32_t> IntOptionalUnset;
    /* 0x0030 */ TOptional<FName> NameOptional;
    /* 0x0038 */ TOptional<FName> NameOptionalUnset;
    /* 0x0040 */ TOptional<FStructSerializerBuiltinTestStruct> StructOptional;
    /* 0x0120 */ TOptional<FStructSerializerBuiltinTestStruct> StructOptionalUnset;
};

// Size: 0x140
struct FStructSerializerSetTestStruct {
    /* 0x0000 */ TSet<FString> StrSet;
    /* 0x0050 */ TSet<int32_t> IntSet;
    /* 0x00a0 */ TSet<FName> NameSet;
    /* 0x00f0 */ TSet<FStructSerializerBuiltinTestStruct> StructSet;
};

// Size: 0xa10
struct FStructSerializerTestStruct {
    /* 0x0000 */ FStructSerializerNumericTestStruct Numerics;
    /* 0x0030 */ FStructSerializerBooleanTestStruct Booleans;
    /* 0x0038 */ FStructSerializerObjectTestStruct Objects;
    /* 0x0100 */ FStructSerializerBuiltinTestStruct Builtins;
    /* 0x01d0 */ FStructSerializerArrayTestStruct Arrays;
    /* 0x0230 */ FStructSerializerMapTestStruct Maps;
    /* 0x0370 */ FStructSerializerSetTestStruct Sets;
    /* 0x04b0 */ FStructSerializerOptionalTestStruct Optionals;
    /* 0x06b0 */ FStructSerializerLWCTypesTest LWCTypes;
};

// Size: 0x38
struct FSessionServiceLog {
    /* 0x0000 */ FName Category;
    /* 0x0008 */ FString Data;
    /* 0x0018 */ FGuid InstanceId;
    /* 0x0028 */ double TimeSeconds;
    /* 0x0030 */ uint8_t Verbosity;
};

// Size: 0x1
struct FSessionServiceLogSubscribe {
};

// Size: 0x1
struct FSessionServiceLogUnsubscribe {
};

// Size: 0x10
struct FSessionServicePing {
    /* 0x0000 */ FString UserName;
};

// Size: 0x90
struct FSessionServicePong {
    /* 0x0000 */ bool Authorized;
    /* 0x0008 */ FString BuildDate;
    /* 0x0018 */ FString DeviceName;
    /* 0x0028 */ FGuid InstanceId;
    /* 0x0038 */ FString InstanceName;
    /* 0x0048 */ FString PlatformName;
    /* 0x0058 */ FGuid SessionId;
    /* 0x0068 */ FString SessionName;
    /* 0x0078 */ FString SessionOwner;
    /* 0x0088 */ bool Standalone;
};

enum class EMipFilter {
    Point = 0,
    Bilinear = 1,
    Trilinear = 2,
    AnisotropicPoint = 3,
    AnisotropicLinear = 4,
    EMipFilter_MAX = 5,
};

enum class EOceanSimulationFidelity {
    Disabled = 0,
    Resolution128 = 1,
    Resolution256 = 2,
    Resolution512 = 3,
    EOceanSimulationFidelity_MAX = 4,
};

// Size: 0x2f0
class AMultiLineShaderTest : public AActor {
    /* 0x02a8 */ UTextureRenderTarget2D* Texture;
    /* 0x02b0 */ int32_t LineCount;
    /* 0x02b4 */ float MaxLineOffset;
    /* 0x02b8 */ float LineThickness;
    /* 0x02bc */ float LineValue;
    /* 0x02c0 */ bool bActive;

    void Toggle();
};

// Size: 0x2e8
class AMultiStampShaderTest : public AActor {
    /* 0x02a8 */ UTexture2D* Stamp;
    /* 0x02b0 */ UTextureRenderTarget2D* Texture;
    /* 0x02b8 */ int32_t StampCount;
    /* 0x02bc */ bool bActive;

    void Toggle();
};

// Size: 0x50
struct FOceanParameters {
    /* 0x0000 */ float GravityAcceleration;
    /* 0x0004 */ float Depth;
    /* 0x0008 */ float Lambda;
    /* 0x000c */ FOceanSpectrumParameters Spectrum0;
    /* 0x002c */ bool bUseDualSpectrum;
    /* 0x0030 */ FOceanSpectrumParameters Spectrum1;
};

// Size: 0x20
struct FOceanSpectrumParameters {
    /* 0x0000 */ float Scale;
    /* 0x0004 */ float windSpeed;
    /* 0x0008 */ float WindDirection;
    /* 0x000c */ float Fetch;
    /* 0x0010 */ float SpreadBlend;
    /* 0x0014 */ float Swell;
    /* 0x0018 */ float PeakEnhancement;
    /* 0x001c */ float ShortWavesFade;
};

// Size: 0x4
struct FBoneID : public FElementID {
};

// Size: 0x2f0
class USkeletalMeshDescription : public UMeshDescriptionBase {
};

// Size: 0x4
struct FSourceGeometryPartID : public FElementID {
};

// Size: 0x20
struct FAnchors {
    /* 0x0000 */ FVector2D Minimum;
    /* 0x0010 */ FVector2D Maximum;
};

// Size: 0x3c0
class UButtonWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FButtonStyle ButtonStyle;
};

// Size: 0x4
struct FCharRange {
    /* 0x0000 */ uint16_t First;
    /* 0x0002 */ uint16_t Last;
};

// Size: 0x10
struct FCharRangeList {
    /* 0x0000 */ TArray<FCharRange> Ranges;
};

// Size: 0x980
class UCheckBoxWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FCheckBoxStyle CheckBoxStyle;
};

// Size: 0x5f0
class UComboBoxWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FComboBoxStyle ComboBoxStyle;
};

// Size: 0x590
class UComboButtonWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FComboButtonStyle ComboButtonStyle;
};

// Size: 0x200
struct FCustomizedToolMenu : public FToolMenuProfile {
    /* 0x01a0 */ TMap<FName, FCustomizedToolMenuNameArray> EntryOrder;
    /* 0x01f0 */ TArray<FName> SectionOrder;
};

// Size: 0x4
struct FCustomizedToolMenuEntry {
    /* 0x0000 */ ECustomizedToolMenuVisibility Visibility;
};

// Size: 0x10
struct FCustomizedToolMenuNameArray {
    /* 0x0000 */ TArray<FName> Names;
};

// Size: 0x4
struct FCustomizedToolMenuSection {
    /* 0x0000 */ ECustomizedToolMenuVisibility Visibility;
};

enum class ECustomizedToolMenuVisibility {
    None = 0,
    Visible = 1,
    Hidden = 2,
    ECustomizedToolMenuVisibility_MAX = 3,
};

enum class EDescendantScrollDestination {
    IntoView = 0,
    TopOrLeft = 1,
    Center = 2,
    BottomOrRight = 3,
    EDescendantScrollDestination_MAX = 4,
};

enum class EInputPreProcessorType {
    Overlay = 0,
    PreEngine = 1,
    Engine = 2,
    PreEditor = 3,
    Editor = 4,
    PreGame = 5,
    Game = 6,
    Count = 7,
    EInputPreProcessorType_MAX = 8,
};

enum class EListItemAlignment {
    EvenlyDistributed = 0,
    EvenlySize = 1,
    EvenlyWide = 2,
    LeftAligned = 3,
    RightAligned = 4,
    CenterAligned = 5,
    Fill = 6,
    EListItemAlignment_MAX = 7,
};

enum class EMultiBlockType {
    None = 0,
    ButtonRow = 1,
    EditableText = 2,
    Heading = 3,
    MenuEntry = 4,
    Separator = 5,
    ToolBarButton = 6,
    ToolBarComboButton = 7,
    Widget = 8,
    EMultiBlockType_MAX = 9,
};

enum class EMultiBoxType {
    MenuBar = 0,
    ToolBar = 1,
    VerticalToolBar = 2,
    SlimHorizontalToolBar = 3,
    UniformToolBar = 4,
    Menu = 5,
    ButtonRow = 6,
    SlimHorizontalUniformToolBar = 7,
    SlimWrappingToolBar = 8,
    EMultiBoxType_MAX = 9,
};

enum class EMultipleKeyBindingIndex {
    Primary = 0,
    Secondary = 1,
    NumChords = 2,
    EMultipleKeyBindingIndex_MAX = 3,
};

enum class EPopupLayoutMode {
    Menu = 0,
    ToolTip = 1,
    EPopupLayoutMode_MAX = 2,
};

enum class EProgressBarFillStyle {
    Mask = 0,
    Scale = 1,
    EProgressBarFillStyle_MAX = 2,
};

enum class EProgressBarFillType {
    LeftToRight = 0,
    RightToLeft = 1,
    FillFromCenter = 2,
    FillFromCenterHorizontal = 3,
    FillFromCenterVertical = 4,
    TopToBottom = 5,
    BottomToTop = 6,
    EProgressBarFillType_MAX = 7,
};

enum class EScrollIntoViewAlignment {
    IntoView = 0,
    TopOrLeft = 1,
    CenterAligned = 2,
    BottomOrRight = 3,
    EScrollIntoViewAlignment_MAX = 4,
};

enum class EScrollWhenFocusChanges {
    NoScroll = 0,
    InstantScroll = 1,
    AnimatedScroll = 2,
    EScrollWhenFocusChanges_MAX = 3,
};

enum class ESelectionMode {
    None = 0,
    Single = 1,
    SingleToggle = 2,
    Multi = 3,
    ESelectionMode_MAX = 4,
};

enum class EStretch {
    None = 0,
    Fill = 1,
    ScaleToFit = 2,
    ScaleToFitX = 3,
    ScaleToFitY = 4,
    ScaleToFill = 5,
    ScaleBySafeZone = 6,
    UserSpecified = 7,
    UserSpecifiedWithClipping = 8,
    EStretch_MAX = 9,
};

enum class EStretchDirection {
    Both = 0,
    DownOnly = 1,
    UpOnly = 2,
    EStretchDirection_MAX = 3,
};

enum class ETableViewMode {
    List = 0,
    Tile = 1,
    Tree = 2,
    ETableViewMode_MAX = 3,
};

enum class ETextFlowDirection {
    Auto = 0,
    LeftToRight = 1,
    RightToLeft = 2,
    Culture = 3,
    ETextFlowDirection_MAX = 4,
};

enum class ETextJustify {
    Left = 0,
    Center = 1,
    Right = 2,
    InvariantLeft = 3,
    InvariantRight = 4,
    ETextJustify_MAX = 5,
};

enum class ETextWrappingPolicy {
    DefaultWrapping = 0,
    AllowPerCharacterWrapping = 1,
    ETextWrappingPolicy_MAX = 2,
};

enum class EUserInterfaceActionType {
    None = 0,
    Button = 1,
    ToggleButton = 2,
    RadioButton = 3,
    Check = 4,
    CollapsedButton = 5,
    EUserInterfaceActionType_MAX = 6,
};

enum class EVirtualKeyboardDismissAction {
    TextChangeOnDismiss = 0,
    TextCommitOnAccept = 1,
    TextCommitOnDismiss = 2,
    EVirtualKeyboardDismissAction_MAX = 3,
};

enum class EVirtualKeyboardTrigger {
    OnFocusByPointer = 0,
    OnAllFocusEvents = 1,
    EVirtualKeyboardTrigger_MAX = 2,
};

// Size: 0xcb0
class UEditableTextBoxWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FEditableTextBoxStyle EditableTextBoxStyle;
};

// Size: 0x2c0
class UEditableTextWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FEditableTextStyle EditableTextStyle;
};

// Size: 0x20
struct FInputChord {
    /* 0x0000 */ FKey Key;
    /* 0x0018 */ bool bShift;
    /* 0x0018 */ bool bCtrl;
    /* 0x0018 */ bool bAlt;
    /* 0x0018 */ bool bCmd;
};

// Size: 0x8
struct FInputPreprocessorRegistrationKey {
    /* 0x0000 */ EInputPreProcessorType Type;
    /* 0x0004 */ int32_t Priority;
};

// Size: 0x260
class UProgressWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FProgressBarStyle ProgressBarStyle;
};

// Size: 0x680
class UScrollBarWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FScrollBarStyle ScrollBarStyle;
};

// Size: 0x320
class UScrollBoxWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FScrollBoxStyle ScrollBoxStyle;
};

// Size: 0x30
class USlateSettings : public UObject {
    /* 0x0028 */ bool bExplicitCanvasChildZOrder;
};

// Size: 0x550
class USpinBoxWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FSpinBoxStyle SpinBoxStyle;
};

// Size: 0x310
class UTextBlockWidgetStyle : public USlateWidgetStyleContainerBase {
    /* 0x0030 */ FTextBlockStyle TextBlockStyle;
};

// Size: 0x28
class UToolMenuBase : public UObject {
};

// Size: 0x1a0
struct FToolMenuProfile {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ TMap<FName, FCustomizedToolMenuEntry> Entries;
    /* 0x0058 */ TMap<FName, FCustomizedToolMenuSection> Sections;
    /* 0x00a8 */ TArray<FName> SuppressExtenders;
};

// Size: 0x1
struct FVirtualKeyboardOptions {
    /* 0x0000 */ bool bEnableAutocorrect;
};

// Size: 0x50
struct FAnalogInputEvent : public FKeyEvent {
};

// Size: 0x390
struct FButtonStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush Normal;
    /* 0x00c0 */ FSlateBrush Hovered;
    /* 0x0170 */ FSlateBrush Pressed;
    /* 0x0220 */ FSlateBrush Disabled;
    /* 0x02d0 */ FSlateColor NormalForeground;
    /* 0x02e4 */ FSlateColor HoveredForeground;
    /* 0x02f8 */ FSlateColor PressedForeground;
    /* 0x030c */ FSlateColor DisabledForeground;
    /* 0x0320 */ FMargin NormalPadding;
    /* 0x0330 */ FMargin PressedPadding;
    /* 0x0340 */ FSlateSound PressedSlateSound;
    /* 0x0358 */ FSlateSound ClickedSlateSound;
    /* 0x0370 */ FSlateSound HoveredSlateSound;
};

// Size: 0x8
struct FCaptureLostEvent {
};

// Size: 0x30
struct FCharacterEvent : public FInputEvent {
};

// Size: 0x950
struct FCheckBoxStyle : public FSlateWidgetStyle {
    /* 0x0008 */ uint8_t CheckBoxType;
    /* 0x0010 */ FSlateBrush UncheckedImage;
    /* 0x00c0 */ FSlateBrush UncheckedHoveredImage;
    /* 0x0170 */ FSlateBrush UncheckedPressedImage;
    /* 0x0220 */ FSlateBrush CheckedImage;
    /* 0x02d0 */ FSlateBrush CheckedHoveredImage;
    /* 0x0380 */ FSlateBrush CheckedPressedImage;
    /* 0x0430 */ FSlateBrush UndeterminedImage;
    /* 0x04e0 */ FSlateBrush UndeterminedHoveredImage;
    /* 0x0590 */ FSlateBrush UndeterminedPressedImage;
    /* 0x0640 */ FMargin Padding;
    /* 0x0650 */ FSlateBrush BackgroundImage;
    /* 0x0700 */ FSlateBrush BackgroundHoveredImage;
    /* 0x07b0 */ FSlateBrush BackgroundPressedImage;
    /* 0x0860 */ FSlateColor ForegroundColor;
    /* 0x0874 */ FSlateColor HoveredForeground;
    /* 0x0888 */ FSlateColor PressedForeground;
    /* 0x089c */ FSlateColor CheckedForeground;
    /* 0x08b0 */ FSlateColor CheckedHoveredForeground;
    /* 0x08c4 */ FSlateColor CheckedPressedForeground;
    /* 0x08d8 */ FSlateColor UndeterminedForeground;
    /* 0x08ec */ FSlateColor BorderBackgroundColor;
    /* 0x0900 */ FSlateSound CheckedSlateSound;
    /* 0x0918 */ FSlateSound UncheckedSlateSound;
    /* 0x0930 */ FSlateSound HoveredSlateSound;
};

// Size: 0x5c0
struct FComboBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FComboButtonStyle ComboButtonStyle;
    /* 0x0570 */ FSlateSound PressedSlateSound;
    /* 0x0588 */ FSlateSound SelectionChangeSlateSound;
    /* 0x05a0 */ FMargin ContentPadding;
    /* 0x05b0 */ FMargin MenuRowPadding;
};

// Size: 0x560
struct FComboButtonStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FButtonStyle ButtonStyle;
    /* 0x03a0 */ FSlateBrush DownArrowImage;
    /* 0x0450 */ FDeprecateSlateVector2D ShadowOffset;
    /* 0x0458 */ FLinearColor ShadowColorAndOpacity;
    /* 0x0470 */ FSlateBrush MenuBorderBrush;
    /* 0x0520 */ FMargin MenuBorderPadding;
    /* 0x0530 */ FMargin ContentPadding;
    /* 0x0540 */ FMargin DownArrowPadding;
    /* 0x0550 */ uint8_t DownArrowAlign;
};

// Size: 0x18
struct FCompositeFallbackFont {
    /* 0x0000 */ FTypeface Typeface;
    /* 0x0010 */ float ScalingFactor;
};

// Size: 0x40
struct FCompositeFont {
    /* 0x0000 */ FTypeface DefaultTypeface;
    /* 0x0010 */ FCompositeFallbackFont FallbackTypeface;
    /* 0x0028 */ TArray<FCompositeSubFont> SubTypefaces;
    /* 0x0038 */ bool bEnableAscentDescentOverride;
};

// Size: 0x38
struct FCompositeSubFont : public FCompositeFallbackFont {
    /* 0x0018 */ TArray<FInt32Range> CharacterRanges;
    /* 0x0028 */ FString Cultures;
};

// Size: 0x8
struct FDeprecateSlateVector2D : public FVector2f {
};

// Size: 0xbe0
struct FDockTabStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FButtonStyle CloseButtonStyle;
    /* 0x03a0 */ FSlateBrush NormalBrush;
    /* 0x0450 */ FSlateBrush ColorOverlayTabBrush;
    /* 0x0500 */ FSlateBrush ColorOverlayIconBrush;
    /* 0x05b0 */ FSlateBrush ForegroundBrush;
    /* 0x0660 */ FSlateBrush HoveredBrush;
    /* 0x0710 */ FSlateBrush ContentAreaBrush;
    /* 0x07c0 */ FSlateBrush TabWellBrush;
    /* 0x0870 */ FTextBlockStyle TabTextStyle;
    /* 0x0b50 */ FMargin TabPadding;
    /* 0x0b60 */ FDeprecateSlateVector2D IconSize;
    /* 0x0b68 */ float OverlapWidth;
    /* 0x0b6c */ FSlateColor FlashColor;
    /* 0x0b80 */ FSlateColor NormalForegroundColor;
    /* 0x0b94 */ FSlateColor HoveredForegroundColor;
    /* 0x0ba8 */ FSlateColor ActiveForegroundColor;
    /* 0x0bbc */ FSlateColor ForegroundForegroundColor;
    /* 0x0bd0 */ float IconBorderPadding;
};

enum class EButtonClickMethod {
    DownAndUp = 0,
    MouseDown = 1,
    MouseUp = 2,
    PreciseClick = 3,
    EButtonClickMethod_MAX = 4,
};

enum class EButtonPressMethod {
    DownAndUp = 0,
    ButtonPress = 1,
    ButtonRelease = 2,
    EButtonPressMethod_MAX = 3,
};

enum class EButtonTouchMethod {
    DownAndUp = 0,
    Down = 1,
    PreciseTap = 2,
    EButtonTouchMethod_MAX = 3,
};

enum class ECheckBoxState {
    Unchecked = 0,
    Checked = 1,
    Undetermined = 2,
    ECheckBoxState_MAX = 3,
};

enum class EColorVisionDeficiency {
    NormalVision = 0,
    Deuteranope = 1,
    Protanope = 2,
    Tritanope = 3,
    EColorVisionDeficiency_MAX = 4,
};

enum class EConsumeMouseWheel {
    WhenScrollingPossible = 0,
    Always = 1,
    Never = 2,
    EConsumeMouseWheel_MAX = 3,
};

enum class EFlowDirectionPreference {
    Inherit = 0,
    Culture = 1,
    LeftToRight = 2,
    RightToLeft = 3,
    EFlowDirectionPreference_MAX = 4,
};

enum class EFocusCause {
    Mouse = 0,
    Navigation = 1,
    SetDirectly = 2,
    Cleared = 3,
    OtherWidgetLostFocus = 4,
    WindowActivate = 5,
    EFocusCause_MAX = 6,
};

enum class EFontHinting {
    Default = 0,
    Auto = 1,
    AutoLight = 2,
    Monochrome = 3,
    None = 4,
    EFontHinting_MAX = 5,
};

enum class EFontLayoutMethod {
    Metrics = 0,
    BoundingBox = 1,
    EFontLayoutMethod_MAX = 2,
};

enum class EFontLoadingPolicy {
    LazyLoad = 0,
    Stream = 1,
    Inline = 2,
    EFontLoadingPolicy_MAX = 3,
};

enum class EFontRasterizationMode {
    Bitmap = 0,
    Msdf = 1,
    Sdf = 2,
    SdfApproximation = 3,
    EFontRasterizationMode_MAX = 4,
};

enum class EHorizontalAlignment {
    HAlign_Fill = 0,
    HAlign_Left = 1,
    HAlign_Center = 2,
    HAlign_Right = 3,
    HAlign_MAX = 4,
};

enum class EMenuPlacement {
    MenuPlacement_BelowAnchor = 0,
    MenuPlacement_CenteredBelowAnchor = 1,
    MenuPlacement_BelowRightAnchor = 2,
    MenuPlacement_ComboBox = 3,
    MenuPlacement_ComboBoxRight = 4,
    MenuPlacement_MenuRight = 5,
    MenuPlacement_AboveAnchor = 6,
    MenuPlacement_CenteredAboveAnchor = 7,
    MenuPlacement_AboveRightAnchor = 8,
    MenuPlacement_MenuLeft = 9,
    MenuPlacement_Center = 10,
    MenuPlacement_RightLeftCenter = 11,
    MenuPlacement_MatchBottomLeft = 12,
    MenuPlacement_MAX = 13,
};

enum class ENavigationGenesis {
    Keyboard = 0,
    Controller = 1,
    User = 2,
    ENavigationGenesis_MAX = 3,
};

enum class ENavigationSource {
    FocusedWidget = 0,
    WidgetUnderCursor = 1,
    ENavigationSource_MAX = 2,
};

enum class EOrientation {
    Orient_Horizontal = 0,
    Orient_Vertical = 1,
    Orient_MAX = 2,
};

enum class EScrollDirection {
    Scroll_Down = 0,
    Scroll_Up = 1,
    Scroll_MAX = 2,
};

enum class ESelectInfo {
    OnKeyPress = 0,
    OnNavigation = 1,
    OnMouseClick = 2,
    Direct = 3,
    ESelectInfo_MAX = 4,
};

enum class ESlateBrushDrawType {
    NoDrawType = 0,
    Box = 1,
    Border = 2,
    Image = 3,
    RoundedBox = 4,
    ESlateBrushDrawType_MAX = 5,
};

enum class ESlateBrushImageType {
    NoImage = 0,
    FullColor = 1,
    Linear = 2,
    Vector = 3,
    ESlateBrushImageType_MAX = 4,
};

enum class ESlateBrushMirrorType {
    NoMirror = 0,
    Horizontal = 1,
    Vertical = 2,
    Both = 3,
    ESlateBrushMirrorType_MAX = 4,
};

enum class ESlateBrushRoundingType {
    FixedRadius = 0,
    HalfHeightRadius = 1,
    ESlateBrushRoundingType_MAX = 2,
};

enum class ESlateBrushTileType {
    NoTile = 0,
    Horizontal = 1,
    Vertical = 2,
    Both = 3,
    ESlateBrushTileType_MAX = 4,
};

enum class ESlateCheckBoxType {
    CheckBox = 0,
    ToggleButton = 1,
    ESlateCheckBoxType_MAX = 2,
};

enum class ESlateColorStylingMode {
    UseColor_Specified = 0,
    UseColor_ColorTable = 1,
    UseColor_Foreground = 2,
    UseColor_Foreground_Subdued = 3,
    UseColor_UseStyle = 4,
    UseColor_MAX = 5,
};

enum class ESlateDebuggingFocusEvent {
    FocusChanging = 0,
    FocusLost = 1,
    FocusReceived = 2,
    MAX = 3,
};

enum class ESlateDebuggingInputEvent {
    MouseMove = 0,
    MouseEnter = 1,
    MouseLeave = 2,
    PreviewMouseButtonDown = 3,
    MouseButtonDown = 4,
    MouseButtonUp = 5,
    MouseButtonDoubleClick = 6,
    MouseWheel = 7,
    TouchStart = 8,
    TouchEnd = 9,
    TouchForceChanged = 10,
    TouchFirstMove = 11,
    TouchMoved = 12,
    DragDetected = 13,
    DragEnter = 14,
    DragLeave = 15,
    DragOver = 16,
    DragDrop = 17,
    DropMessage = 18,
    PreviewKeyDown = 19,
    KeyDown = 20,
    KeyUp = 21,
    KeyChar = 22,
    AnalogInput = 23,
    TouchGesture = 24,
    MotionDetected = 25,
    MAX = 26,
};

enum class ESlateDebuggingNavigationMethod {
    Unknown = 0,
    Explicit = 1,
    CustomDelegateBound = 2,
    CustomDelegateUnbound = 3,
    NextOrPrevious = 4,
    HitTestGrid = 5,
    ESlateDebuggingNavigationMethod_MAX = 6,
};

enum class ESlateDebuggingStateChangeEvent {
    MouseCaptureGained = 0,
    MouseCaptureLost = 1,
    ESlateDebuggingStateChangeEvent_MAX = 2,
};

enum class ESlateParentWindowSearchMethod {
    ActiveWindow = 0,
    MainWindow = 1,
    ESlateParentWindowSearchMethod_MAX = 2,
};

enum class ESlatePostRT {
    None = 0,
    ESlatePostRT_0 = 1,
    ESlatePostRT_1 = 2,
    ESlatePostRT_2 = 4,
    ESlatePostRT_3 = 8,
    ESlatePostRT_4 = 16,
    All = 31,
    Num = 5,
    ESlatePostRT_MAX = 32,
};

enum class EStyleColor {
    Black = 0,
    Background = 1,
    Title = 2,
    WindowBorder = 3,
    Foldout = 4,
    Input = 5,
    InputOutline = 6,
    Recessed = 7,
    Panel = 8,
    Header = 9,
    Dropdown = 10,
    DropdownOutline = 11,
    Hover = 12,
    Hover2 = 13,
    White = 14,
    White25 = 15,
    Highlight = 16,
    Primary = 17,
    PrimaryHover = 18,
    PrimaryPress = 19,
    Secondary = 20,
    Foreground = 21,
    ForegroundHover = 22,
    ForegroundInverted = 23,
    ForegroundHeader = 24,
    Select = 25,
    SelectInactive = 26,
    SelectParent = 27,
    SelectHover = 28,
    Notifications = 29,
    AccentBlue = 30,
    AccentPurple = 31,
    AccentPink = 32,
    AccentRed = 33,
    AccentOrange = 34,
    AccentYellow = 35,
    AccentGreen = 36,
    AccentBrown = 37,
    AccentBlack = 38,
    AccentGray = 39,
    AccentWhite = 40,
    AccentFolder = 41,
    Warning = 42,
    Error = 43,
    Success = 44,
    User1 = 45,
    User2 = 46,
    User3 = 47,
    User4 = 48,
    User5 = 49,
    User6 = 50,
    User7 = 51,
    User8 = 52,
    User9 = 53,
    User10 = 54,
    User11 = 55,
    User12 = 56,
    User13 = 57,
    User14 = 58,
    User15 = 59,
    User16 = 60,
    MAX = 61,
};

enum class ETextCommit {
    Default = 0,
    OnEnter = 1,
    OnUserMovedFocus = 2,
    OnCleared = 3,
    ETextCommit_MAX = 4,
};

enum class ETextOverflowPolicy {
    Clip = 0,
    Ellipsis = 1,
    MultilineEllipsis = 2,
    MiddleEllipsis = 3,
    ETextOverflowPolicy_MAX = 4,
};

enum class ETextShapingMethod {
    Auto = 0,
    KerningOnly = 1,
    FullShaping = 2,
    ETextShapingMethod_MAX = 3,
};

enum class ETextTransformPolicy {
    None = 0,
    ToLower = 1,
    ToUpper = 2,
    ETextTransformPolicy_MAX = 3,
};

enum class EUINavigation {
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
    Next = 4,
    Previous = 5,
    Num = 6,
    Invalid = 7,
    EUINavigation_MAX = 8,
};

enum class EUINavigationAction {
    Accept = 0,
    Back = 1,
    Num = 2,
    Invalid = 3,
    EUINavigationAction_MAX = 4,
};

enum class EUINavigationRule {
    Escape = 0,
    Explicit = 1,
    Wrap = 2,
    Stop = 3,
    Custom = 4,
    CustomBoundary = 5,
    Invalid = 6,
    EUINavigationRule_MAX = 7,
};

enum class EVerticalAlignment {
    VAlign_Fill = 0,
    VAlign_Top = 1,
    VAlign_Center = 2,
    VAlign_Bottom = 3,
    VAlign_MAX = 4,
};

enum class EWidgetClipping {
    Inherit = 0,
    ClipToBounds = 1,
    ClipToBoundsWithoutIntersecting = 2,
    ClipToBoundsAlways = 3,
    OnDemand = 4,
    EWidgetClipping_MAX = 5,
};

enum class EWidgetPixelSnapping {
    Inherit = 0,
    Disabled = 1,
    SnapToPixel = 2,
    EWidgetPixelSnapping_MAX = 3,
};

// Size: 0xc80
struct FEditableTextBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundImageNormal;
    /* 0x00c0 */ FSlateBrush BackgroundImageHovered;
    /* 0x0170 */ FSlateBrush BackgroundImageFocused;
    /* 0x0220 */ FSlateBrush BackgroundImageReadOnly;
    /* 0x02d0 */ FMargin Padding;
    /* 0x02e0 */ FTextBlockStyle TextStyle;
    /* 0x05c0 */ FSlateColor ForegroundColor;
    /* 0x05d4 */ FSlateColor BackgroundColor;
    /* 0x05e8 */ FSlateColor ReadOnlyForegroundColor;
    /* 0x05fc */ FSlateColor FocusedForegroundColor;
    /* 0x0610 */ FMargin HScrollBarPadding;
    /* 0x0620 */ FMargin VScrollBarPadding;
    /* 0x0630 */ FScrollBarStyle ScrollBarStyle;
};

// Size: 0x290
struct FEditableTextStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateFontInfo Font;
    /* 0x0068 */ FSlateColor ColorAndOpacity;
    /* 0x0080 */ FSlateBrush BackgroundImageSelected;
    /* 0x0130 */ FSlateBrush BackgroundImageComposing;
    /* 0x01e0 */ FSlateBrush CaretImage;
};

// Size: 0x180
struct FExpandableAreaStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush CollapsedImage;
    /* 0x00c0 */ FSlateBrush ExpandedImage;
    /* 0x0170 */ float RolloutAnimationSeconds;
};

// Size: 0x8
struct FFocusEvent {
};

// Size: 0x78
class UFontBulkData : public UObject {
};

// Size: 0x28
struct FFontData {
    /* 0x0000 */ FString FontFilename;
    /* 0x0014 */ EFontHinting Hinting;
    /* 0x0015 */ EFontLoadingPolicy LoadingPolicy;
    /* 0x0018 */ int32_t SubFaceIndex;
    /* 0x0020 */ UObject* FontFaceAsset;
};

// Size: 0x28
class IFontFaceInterface : public UInterface {
};

// Size: 0x20
struct FFontOutlineSettings {
    /* 0x0000 */ int32_t OutlineSize;
    /* 0x0004 */ bool bMiteredCorners;
    /* 0x0005 */ bool bSeparateFillAlpha;
    /* 0x0006 */ bool bApplyOutlineToDropShadows;
    /* 0x0008 */ UObject* OutlineMaterial;
    /* 0x0010 */ FLinearColor OutlineColor;
};

// Size: 0x28
class IFontProviderInterface : public UInterface {
};

// Size: 0x4
struct FFontSdfSettings {
    /* 0x0000 */ int32_t BasePpem;
};

// Size: 0x38
struct FGeometry {
};

// Size: 0xfa0
struct FHeaderRowStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FTableColumnHeaderStyle ColumnStyle;
    /* 0x0650 */ FTableColumnHeaderStyle LastColumnStyle;
    /* 0x0c90 */ FSplitterStyle ColumnSplitterStyle;
    /* 0x0e00 */ float SplitterHandleSize;
    /* 0x0e10 */ FSlateBrush BackgroundBrush;
    /* 0x0ec0 */ FSlateColor ForegroundColor;
    /* 0x0ee0 */ FSlateBrush HorizontalSeparatorBrush;
    /* 0x0f90 */ float HorizontalSeparatorThickness;
};

// Size: 0x690
struct FHyperlinkStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FButtonStyle UnderlineStyle;
    /* 0x03a0 */ FTextBlockStyle TextStyle;
    /* 0x0680 */ FMargin Padding;
};

// Size: 0xf70
struct FInlineEditableTextBlockStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FEditableTextBoxStyle EditableTextBoxStyle;
    /* 0x0c90 */ FTextBlockStyle TextStyle;
};

// Size: 0xd0
struct FInlineTextImageStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush Image;
    /* 0x00c0 */ int16_t Baseline;
};

// Size: 0x28
struct FInputEvent {
};

// Size: 0x48
struct FKeyEvent : public FInputEvent {
};

// Size: 0x10
struct FMargin {
    /* 0x0000 */ float Left;
    /* 0x0004 */ float Top;
    /* 0x0008 */ float Right;
    /* 0x000c */ float Bottom;
};

// Size: 0x88
struct FMotionEvent : public FInputEvent {
};

// Size: 0x30
struct FNavigationEvent : public FInputEvent {
};

// Size: 0x80
struct FPointerEvent : public FInputEvent {
};

// Size: 0x230
struct FProgressBarStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundImage;
    /* 0x00c0 */ FSlateBrush FillImage;
    /* 0x0170 */ FSlateBrush MarqueeImage;
    /* 0x0220 */ bool EnableFillAnimation;
};

// Size: 0x650
struct FScrollBarStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush HorizontalBackgroundImage;
    /* 0x00c0 */ FSlateBrush VerticalBackgroundImage;
    /* 0x0170 */ FSlateBrush VerticalTopSlotImage;
    /* 0x0220 */ FSlateBrush HorizontalTopSlotImage;
    /* 0x02d0 */ FSlateBrush VerticalBottomSlotImage;
    /* 0x0380 */ FSlateBrush HorizontalBottomSlotImage;
    /* 0x0430 */ FSlateBrush NormalThumbImage;
    /* 0x04e0 */ FSlateBrush HoveredThumbImage;
    /* 0x0590 */ FSlateBrush DraggedThumbImage;
    /* 0x0640 */ float Thickness;
};

// Size: 0x170
struct FScrollBorderStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush TopShadowBrush;
    /* 0x00c0 */ FSlateBrush BottomShadowBrush;
};

// Size: 0x2f0
struct FScrollBoxStyle : public FSlateWidgetStyle {
    /* 0x0008 */ float BarThickness;
    /* 0x0010 */ FSlateBrush TopShadowBrush;
    /* 0x00c0 */ FSlateBrush BottomShadowBrush;
    /* 0x0170 */ FSlateBrush LeftShadowBrush;
    /* 0x0220 */ FSlateBrush RightShadowBrush;
    /* 0x02d0 */ FMargin HorizontalScrolledContentPadding;
    /* 0x02e0 */ FMargin VerticalScrolledContentPadding;
};

// Size: 0xfe0
struct FSearchBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FEditableTextBoxStyle TextBoxStyle;
    /* 0x0c90 */ FSlateFontInfo ActiveFontInfo;
    /* 0x0cf0 */ FSlateBrush UpArrowImage;
    /* 0x0da0 */ FSlateBrush DownArrowImage;
    /* 0x0e50 */ FSlateBrush GlassImage;
    /* 0x0f00 */ FSlateBrush ClearImage;
    /* 0x0fb0 */ FMargin ImagePadding;
    /* 0x0fc0 */ TOptional<FVector2D> ImageSizeOverride;
    /* 0x0fd8 */ bool bLeftAlignButtons;
    /* 0x0fd9 */ bool bLeftAlignSearchResultButtons;
    /* 0x0fda */ bool bLeftAlignGlassImageAndClearButton;
};

// Size: 0x1cc0
struct FSegmentedControlStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FCheckBoxStyle ControlStyle;
    /* 0x0960 */ FCheckBoxStyle FirstControlStyle;
    /* 0x12b0 */ FCheckBoxStyle LastControlStyle;
    /* 0x1c00 */ FSlateBrush BackgroundBrush;
    /* 0x1cb0 */ FMargin UniformPadding;
};

// Size: 0xb0
struct FSlateBrush {
    /* 0x0008 */ FSlateColor TintColor;
    /* 0x001c */ uint8_t DrawAs;
    /* 0x001d */ uint8_t Tiling;
    /* 0x001e */ uint8_t Mirroring;
    /* 0x001f */ uint8_t ImageType;
    /* 0x0020 */ FDeprecateSlateVector2D ImageSize;
    /* 0x0028 */ FMargin Margin;
    /* 0x0038 */ UObject* ResourceObject;
    /* 0x0040 */ FSlateBrushOutlineSettings OutlineSettings;
    /* 0x0080 */ FBox2f UVRegion;
    /* 0x0094 */ bool bIsDynamicallyLoaded;
    /* 0x0094 */ bool bHasUObject;
    /* 0x00a8 */ FName ResourceName;
};

// Size: 0x40
struct FSlateBrushOutlineSettings {
    /* 0x0000 */ FVector4 CornerRadii;
    /* 0x0020 */ FSlateColor Color;
    /* 0x0034 */ float Width;
    /* 0x0038 */ uint8_t RoundingType;
    /* 0x0039 */ bool bUseBrushTransparency;
};

// Size: 0x14
struct FSlateColor {
    /* 0x0000 */ FLinearColor SpecifiedColor;
    /* 0x0010 */ ESlateColorStylingMode ColorUseRule;
};

// Size: 0x60
struct FSlateFontInfo {
    /* 0x0000 */ UObject* FontObject;
    /* 0x0008 */ UObject* FontMaterial;
    /* 0x0010 */ FFontOutlineSettings OutlineSettings;
    /* 0x0040 */ FName TypefaceFontName;
    /* 0x0048 */ float Size;
    /* 0x004c */ int32_t LetterSpacing;
    /* 0x0050 */ float SkewAmount;
    /* 0x0055 */ bool bForceMonospaced;
    /* 0x0056 */ bool bMaterialIsStencil;
    /* 0x0058 */ float MonospacedWidth;
};

// Size: 0x18
struct FSlateSound {
    /* 0x0000 */ UObject* ResourceObject;
};

// Size: 0x7d8
class USlateThemeManager : public UObject {
    /* 0x0028 */ FGuid CurrentThemeId;
    /* 0x0038 */ FStyleColorList ActiveColors;
};

// Size: 0x28
class USlateTypes : public UObject {
};

// Size: 0x8
struct FSlateWidgetStyle {
};

// Size: 0x30
class USlateWidgetStyleAsset : public UObject {
    /* 0x0028 */ USlateWidgetStyleContainerBase* CustomStyle;
};

// Size: 0x30
class USlateWidgetStyleContainerBase : public UObject {
};

// Size: 0x28
class ISlateWidgetStyleContainerInterface : public UInterface {
};

// Size: 0x440
struct FSliderStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush NormalBarImage;
    /* 0x00c0 */ FSlateBrush HoveredBarImage;
    /* 0x0170 */ FSlateBrush DisabledBarImage;
    /* 0x0220 */ FSlateBrush NormalThumbImage;
    /* 0x02d0 */ FSlateBrush HoveredThumbImage;
    /* 0x0380 */ FSlateBrush DisabledThumbImage;
    /* 0x0430 */ float BarThickness;
};

// Size: 0x520
struct FSpinBoxStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundBrush;
    /* 0x00c0 */ FSlateBrush ActiveBackgroundBrush;
    /* 0x0170 */ FSlateBrush HoveredBackgroundBrush;
    /* 0x0220 */ FSlateBrush ActiveFillBrush;
    /* 0x02d0 */ FSlateBrush HoveredFillBrush;
    /* 0x0380 */ FSlateBrush InactiveFillBrush;
    /* 0x0430 */ FSlateBrush ArrowsImage;
    /* 0x04e0 */ FSlateColor ForegroundColor;
    /* 0x04f4 */ FMargin TextPadding;
    /* 0x0504 */ FMargin InsetPadding;
};

// Size: 0x170
struct FSplitterStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush HandleNormalBrush;
    /* 0x00c0 */ FSlateBrush HandleHighlightBrush;
};

// Size: 0x7a0
struct FStyleColorList {
    /* 0x0000 */ FLinearColor StyleColors[61];
};

// Size: 0x40
struct FStyleTheme {
};

// Size: 0x640
struct FTableColumnHeaderStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush SortPrimaryAscendingImage;
    /* 0x00c0 */ FSlateBrush SortPrimaryDescendingImage;
    /* 0x0170 */ FSlateBrush SortSecondaryAscendingImage;
    /* 0x0220 */ FSlateBrush SortSecondaryDescendingImage;
    /* 0x02d0 */ FSlateBrush NormalBrush;
    /* 0x0380 */ FSlateBrush HoveredBrush;
    /* 0x0430 */ FSlateBrush MenuDropdownImage;
    /* 0x04e0 */ FSlateBrush MenuDropdownNormalBorderBrush;
    /* 0x0590 */ FSlateBrush MenuDropdownHoveredBorderBrush;
};

// Size: 0xb50
struct FTableRowStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush SelectorFocusedBrush;
    /* 0x00c0 */ FSlateBrush ActiveHoveredBrush;
    /* 0x0170 */ FSlateBrush ActiveBrush;
    /* 0x0220 */ FSlateBrush InactiveHoveredBrush;
    /* 0x02d0 */ FSlateBrush InactiveBrush;
    /* 0x0380 */ bool bUseParentRowBrush;
    /* 0x0390 */ FSlateBrush ParentRowBackgroundBrush;
    /* 0x0440 */ FSlateBrush ParentRowBackgroundHoveredBrush;
    /* 0x04f0 */ FSlateBrush EvenRowBackgroundHoveredBrush;
    /* 0x05a0 */ FSlateBrush EvenRowBackgroundBrush;
    /* 0x0650 */ FSlateBrush OddRowBackgroundHoveredBrush;
    /* 0x0700 */ FSlateBrush OddRowBackgroundBrush;
    /* 0x07b0 */ FSlateColor TextColor;
    /* 0x07c4 */ FSlateColor SelectedTextColor;
    /* 0x07e0 */ FSlateBrush DropIndicator_Above;
    /* 0x0890 */ FSlateBrush DropIndicator_Onto;
    /* 0x0940 */ FSlateBrush DropIndicator_Below;
    /* 0x09f0 */ FSlateBrush ActiveHighlightedBrush;
    /* 0x0aa0 */ FSlateBrush InactiveHighlightedBrush;
};

// Size: 0xc0
struct FTableViewStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundBrush;
};

// Size: 0x2e0
struct FTextBlockStyle : public FSlateWidgetStyle {
    /* 0x0008 */ FSlateFontInfo Font;
    /* 0x0068 */ FSlateColor ColorAndOpacity;
    /* 0x007c */ FDeprecateSlateVector2D ShadowOffset;
    /* 0x0084 */ FLinearColor ShadowColorAndOpacity;
    /* 0x0094 */ FSlateColor SelectedBackgroundColor;
    /* 0x00a8 */ FSlateColor HighlightColor;
    /* 0x00c0 */ FSlateBrush HighlightShape;
    /* 0x0170 */ FSlateBrush StrikeBrush;
    /* 0x0220 */ FSlateBrush UnderlineBrush;
    /* 0x02d0 */ ETextTransformPolicy TransformPolicy;
    /* 0x02d1 */ ETextOverflowPolicy OverflowPolicy;
};

// Size: 0x3ef0
struct FToolBarStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSlateBrush BackgroundBrush;
    /* 0x00c0 */ FSlateBrush ExpandBrush;
    /* 0x0170 */ FSlateBrush SeparatorBrush;
    /* 0x0220 */ FTextBlockStyle LabelStyle;
    /* 0x0500 */ FEditableTextBoxStyle EditableTextStyle;
    /* 0x1180 */ FCheckBoxStyle ToggleButton;
    /* 0x1ad0 */ FComboButtonStyle ComboButtonStyle;
    /* 0x2030 */ FButtonStyle SettingsButtonStyle;
    /* 0x23c0 */ FComboButtonStyle SettingsComboButton;
    /* 0x2920 */ FCheckBoxStyle SettingsToggleButton;
    /* 0x3270 */ FButtonStyle ButtonStyle;
    /* 0x3600 */ FMargin LabelPadding;
    /* 0x3610 */ float UniformBlockWidth;
    /* 0x3614 */ float UniformBlockHeight;
    /* 0x3618 */ int32_t NumColumns;
    /* 0x361c */ FMargin IconPadding;
    /* 0x362c */ FMargin SeparatorPadding;
    /* 0x363c */ float SeparatorThickness;
    /* 0x3640 */ FMargin ComboButtonPadding;
    /* 0x3650 */ FMargin ButtonPadding;
    /* 0x3660 */ FMargin CheckBoxPadding;
    /* 0x3670 */ FMargin BlockPadding;
    /* 0x3680 */ FMargin IndentedBlockPadding;
    /* 0x3690 */ FSlateBrush BlockHovered;
    /* 0x3740 */ FMargin BackgroundPadding;
    /* 0x3750 */ FWrapButtonStyle WrapButtonStyle;
    /* 0x3e90 */ FMargin WrapButtonPadding;
    /* 0x3ea0 */ int32_t WrapButtonIndex;
    /* 0x3ea4 */ bool bAllowWrapButton;
    /* 0x3ea5 */ bool bAllowWrappingDefault;
    /* 0x3ea8 */ FDeprecateSlateVector2D IconSize;
    /* 0x3eb0 */ bool bShowLabels;
    /* 0x3eb4 */ float ButtonContentMaxWidth;
    /* 0x3eb8 */ float ButtonContentFillWidth;
    /* 0x3ebc */ float ComboContentMinWidth;
    /* 0x3ec0 */ float ComboContentMaxWidth;
    /* 0x3ec4 */ uint8_t ComboContentHorizontalAlignment;
    /* 0x3ec8 */ FMargin IconPaddingWithVisibleLabel;
    /* 0x3ed8 */ FMargin IconPaddingWithCollapsedLabel;
    /* 0x3ee8 */ TOptional<uint8_t> VerticalAlignmentOverride;
    /* 0x3eec */ float RaisedChildrenRightPadding;
};

// Size: 0x10
struct FTypeface {
    /* 0x0000 */ TArray<FTypefaceEntry> Fonts;
};

// Size: 0x30
struct FTypefaceEntry {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ FFontData Font;
};

// Size: 0x7c0
struct FVolumeControlStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FSliderStyle SliderStyle;
    /* 0x0450 */ FSlateBrush HighVolumeImage;
    /* 0x0500 */ FSlateBrush MidVolumeImage;
    /* 0x05b0 */ FSlateBrush LowVolumeImage;
    /* 0x0660 */ FSlateBrush NoVolumeImage;
    /* 0x0710 */ FSlateBrush MutedImage;
};

// Size: 0x1da0
struct FWindowStyle : public FSlateWidgetStyle {
    /* 0x0010 */ FButtonStyle MinimizeButtonStyle;
    /* 0x03a0 */ FButtonStyle MaximizeButtonStyle;
    /* 0x0730 */ FButtonStyle RestoreButtonStyle;
    /* 0x0ac0 */ FButtonStyle EnterFullscreenButtonStyle;
    /* 0x0e50 */ FButtonStyle ExitFullscreenButtonStyle;
    /* 0x11e0 */ FButtonStyle CloseButtonStyle;
    /* 0x1570 */ FTextBlockStyle TitleTextStyle;
    /* 0x1850 */ FSlateBrush ActiveTitleBrush;
    /* 0x1900 */ FSlateBrush InactiveTitleBrush;
    /* 0x19b0 */ FSlateBrush FlashTitleBrush;
    /* 0x1a60 */ FSlateColor BackgroundColor;
    /* 0x1a80 */ FSlateBrush OutlineBrush;
    /* 0x1b30 */ FSlateColor OutlineColor;
    /* 0x1b50 */ FSlateBrush BorderBrush;
    /* 0x1c00 */ FSlateColor BorderColor;
    /* 0x1c20 */ FSlateBrush BackgroundBrush;
    /* 0x1cd0 */ FSlateBrush ChildBackgroundBrush;
    /* 0x1d80 */ int32_t WindowCornerRadius;
    /* 0x1d84 */ FMargin BorderPadding;
};

// Size: 0x740
struct FWrapButtonStyle {
    /* 0x0000 */ FMargin Padding;
    /* 0x0010 */ int32_t WrapButtonIndex;
    /* 0x0020 */ FSlateBrush ExpandBrush;
    /* 0x00d0 */ bool bHasDownArrow;
    /* 0x00e0 */ TOptional<FComboButtonStyle> ComboButtonStyle;
    /* 0x0650 */ bool bIncludeSeparator;
    /* 0x0660 */ TOptional<FSlateBrush> SeparatorBrush;
    /* 0x0720 */ TOptional<float> SeparatorThickness;
    /* 0x0728 */ TOptional<FMargin> SeparatorPadding;
};

// Size: 0xd0
class USlateFXSubsystem : public UEngineSubsystem {
    /* 0x0030 */ TMap<ESlatePostRT, USlateRHIPostBufferProcessor*> SlatePostBufferProcessors;

    USlateRHIPostBufferProcessor* GetSlatePostProcessor(ESlatePostRT InPostBufferBit);
};

// Size: 0x40
class USlatePostBufferBlur : public USlateRHIPostBufferProcessor {
    /* 0x0028 */ float GaussianBlurStrength;
};

// Size: 0x30
struct FSlatePostSettings {
    /* 0x0000 */ bool bEnabled;
    /* 0x0008 */ UClass* PostProcessorClass;
    /* 0x0010 */ FString PathToSlatePostRT;
    /* 0x0020 */ UTextureRenderTarget2D* CachedSlatePostRT;
};

// Size: 0x28
class USlateRHIPostBufferProcessor : public UObject {
};

// Size: 0x88
class USlateRHIRendererSettings : public UDeveloperSettings {
    /* 0x0038 */ TMap<ESlatePostRT, FSlatePostSettings> SlatePostSettings;

    FSlatePostSettings GetMutableSlatePostSetting(ESlatePostRT InPostBufferBit);
    FSlatePostSettings GetSlatePostSetting(ESlatePostRT InPostBufferBit) const;
};

// Size: 0x1ec0
class UNetConnectionEOS : public UIpConnection {
};

// Size: 0x9a8
class UNetDriverEOS : public UIpNetDriver {
    /* 0x09a0 */ bool bIsPassthrough;
    /* 0x09a1 */ bool bIsUsingP2PSockets;
};

// Size: 0x9a8
class UNetDriverEOSBase : public UNetDriverEOS {
};

// Size: 0x30
class UAmbisonicsEncodingSettings : public USoundfieldEncodingSettingsBase {
    /* 0x0028 */ int32_t AmbisonicsOrder;
};

// Size: 0x1
struct FStateStreamHandle {
};

// Size: 0xa0
struct FTransformDynamicState {
    /* 0x0010 */ FTransform LocalTransform;
    /* 0x0070 */ TArray<FTransform> BoneTransforms;
    /* 0x0080 */ FTransformHandle Parent;
    /* 0x0090 */ bool bVisible;
};

// Size: 0x10
struct FTransformHandle : public FStateStreamHandle {
};

// Size: 0x4
struct FTransformStaticState {
};

// Size: 0x10
struct FCompactEventDesc {
    /* 0x0000 */ UScriptStruct* PayloadStruct;
    /* 0x0008 */ FGameplayTag Tag;
};

// Size: 0x30
struct FCompactStateTransition {
    /* 0x0000 */ FCompactEventDesc RequiredEvent;
    /* 0x0010 */ FStateTreeDelegateDispatcher RequiredDelegateDispatcher;
    /* 0x0020 */ uint16_t ConditionsBegin;
    /* 0x0022 */ FStateTreeStateHandle State;
    /* 0x0024 */ FStateTreeRandomTimeDuration Delay;
    /* 0x0028 */ EStateTreeTransitionTrigger Trigger;
    /* 0x0029 */ EStateTreeTransitionPriority Priority;
    /* 0x002a */ EStateTreeSelectionFallback Fallback;
    /* 0x002b */ uint8_t ConditionsNum;
    /* 0x002c */ bool bTransitionEnabled;
    /* 0x002c */ bool bConsumeEventOnSelect;
};

// Size: 0x4
struct FCompactStateTreeFrame {
    /* 0x0000 */ FStateTreeStateHandle RootState;
    /* 0x0002 */ uint8_t NumberOfTasksStatusMasks;
};

// Size: 0x10
struct FCompactStateTreeParameters {
    /* 0x0000 */ FInstancedPropertyBag Parameters;
};

// Size: 0x60
struct FCompactStateTreeState {
    /* 0x0000 */ FCompactEventDesc RequiredEventToEnter;
    /* 0x0010 */ FName Name;
    /* 0x0018 */ FGameplayTag Tag;
    /* 0x0020 */ UStateTree* LinkedAsset;
    /* 0x0028 */ FStateTreeStateHandle LinkedState;
    /* 0x002a */ FStateTreeStateHandle Parent;
    /* 0x002c */ uint16_t ChildrenBegin;
    /* 0x002e */ uint16_t ChildrenEnd;
    /* 0x0030 */ uint16_t EnterConditionsBegin;
    /* 0x0032 */ uint16_t UtilityConsiderationsBegin;
    /* 0x0034 */ uint16_t TransitionsBegin;
    /* 0x0036 */ uint16_t TasksBegin;
    /* 0x0038 */ FStateTreeIndex16 ParameterTemplateIndex;
    /* 0x003a */ FStateTreeDataHandle ParameterDataHandle;
    /* 0x0040 */ FStateTreeIndex16 ParameterBindingsBatch;
    /* 0x0042 */ FStateTreeIndex16 EventDataIndex;
    /* 0x0044 */ float Weight;
    /* 0x0048 */ float CustomTickRate;
    /* 0x004c */ uint32_t CompletionTasksMask;
    /* 0x0050 */ uint8_t CompletionTasksMaskBufferIndex;
    /* 0x0051 */ uint8_t CompletionTasksMaskBitsOffset;
    /* 0x0052 */ EStateTreeTaskCompletionType CompletionTasksControl;
    /* 0x0053 */ uint8_t EnterConditionsNum;
    /* 0x0054 */ uint8_t UtilityConsiderationsNum;
    /* 0x0055 */ uint8_t TransitionsNum;
    /* 0x0056 */ uint8_t TasksNum;
    /* 0x0057 */ uint8_t EnabledTasksNum;
    /* 0x0058 */ uint8_t InstanceDataNum;
    /* 0x0059 */ uint8_t Depth;
    /* 0x005a */ EStateTreeStateType Type;
    /* 0x005b */ EStateTreeStateSelectionBehavior SelectionBehavior;
    /* 0x005c */ bool bHasTransitionTasks;
    /* 0x005c */ bool bHasStateChangeConditions;
    /* 0x005c */ bool bHasTickTriggerTransitions;
    /* 0x005c */ bool bHasEventTriggerTransitions;
    /* 0x005d */ bool bHasDelegateTriggerTransitions;
    /* 0x005d */ bool bHasCompletedTriggerTransitions;
    /* 0x005d */ bool bHasSucceededTriggerTransitions;
    /* 0x005d */ bool bHasFailedTriggerTransitions;
    /* 0x005d */ bool bCheckPrerequisitesWhenActivatingChildDirectly;
    /* 0x005d */ bool bEnabled;
    /* 0x005d */ bool bConsumeEventOnSelect;
    /* 0x005d */ bool bHasCustomTickRate;
};

enum class EStateTreeBindableStructSource {
    Context = 0,
    Parameter = 1,
    Evaluator = 2,
    GlobalTask = 3,
    StateParameter = 4,
    Task = 5,
    Condition = 6,
    Consideration = 7,
    TransitionEvent = 8,
    StateEvent = 9,
    PropertyFunction = 10,
    Transition = 11,
    EStateTreeBindableStructSource_MAX = 12,
};

enum class EStateTreeBlueprintPropertyCategory {
    NotSet = 0,
    Input = 1,
    Parameter = 2,
    Output = 3,
    ContextObject = 4,
    EStateTreeBlueprintPropertyCategory_MAX = 5,
};

enum class EStateTreeBreakpointType {
    Unset = 0,
    OnEnter = 1,
    OnExit = 2,
    OnTransition = 3,
    EStateTreeBreakpointType_MAX = 4,
};

enum class EStateTreeConditionEvaluationMode {
    Evaluated = 0,
    ForcedTrue = 1,
    ForcedFalse = 2,
    EStateTreeConditionEvaluationMode_MAX = 3,
};

enum class EStateTreeDataSourceType {
    None = 0,
    GlobalInstanceData = 1,
    GlobalInstanceDataObject = 2,
    ActiveInstanceData = 3,
    ActiveInstanceDataObject = 4,
    SharedInstanceData = 5,
    SharedInstanceDataObject = 6,
    ContextData = 7,
    ExternalData = 8,
    GlobalParameterData = 9,
    SubtreeParameterData = 10,
    StateParameterData = 11,
    TransitionEvent = 12,
    StateEvent = 13,
    ExternalGlobalParameterData = 14,
    EStateTreeDataSourceType_MAX = 15,
};

enum class EStateTreeExpressionOperand {
    Copy = 0,
    And = 1,
    Or = 2,
    EStateTreeExpressionOperand_MAX = 3,
};

enum class EStateTreeExternalDataRequirement {
    Required = 0,
    Optional = 1,
    EStateTreeExternalDataRequirement_MAX = 2,
};

enum class EStateTreeFinishTaskType {
    Failed = 0,
    Succeeded = 1,
    EStateTreeFinishTaskType_MAX = 2,
};

enum class EStateTreeLinkerStatus {
    Succeeded = 0,
    Failed = 1,
    EStateTreeLinkerStatus_MAX = 2,
};

enum class EStateTreeLoopEvents {
    Next = 0,
    Break = 1,
    Consume = 2,
    EStateTreeLoopEvents_MAX = 3,
};

enum class EStateTreeNodeFormatting {
    RichText = 0,
    Text = 1,
    EStateTreeNodeFormatting_MAX = 2,
};

enum class EStateTreeParameterDataType {
    GlobalParameterData = 0,
    ExternalGlobalParameterData = 1,
    EStateTreeParameterDataType_MAX = 2,
};

enum class EStateTreePropertyRefType {
    None = 0,
    Bool = 1,
    Byte = 2,
    Int32 = 3,
    Int64 = 4,
    Float = 5,
    Double = 6,
    Name = 7,
    String = 8,
    Text = 9,
    Enum = 10,
    Struct = 11,
    Object = 12,
    SoftObject = 13,
    Class = 14,
    SoftClass = 15,
    EStateTreePropertyRefType_MAX = 16,
};

enum class EStateTreePropertyUsage {
    Invalid = 0,
    Context = 1,
    Input = 2,
    Parameter = 3,
    Output = 4,
    EStateTreePropertyUsage_MAX = 5,
};

enum class EStateTreeRecordTransitions {
    No = 0,
    Yes = 1,
    EStateTreeRecordTransitions_MAX = 2,
};

enum class EStateTreeRunStatus {
    Running = 0,
    Stopped = 1,
    Succeeded = 2,
    Failed = 3,
    Unset = 4,
    EStateTreeRunStatus_MAX = 5,
};

enum class EStateTreeSelectionFallback {
    None = 0,
    NextSelectableSibling = 1,
    EStateTreeSelectionFallback_MAX = 2,
};

enum class EStateTreeStateChangeType {
    None = 0,
    Changed = 1,
    Sustained = 2,
    EStateTreeStateChangeType_MAX = 3,
};

enum class EStateTreeStateSelectionBehavior {
    None = 0,
    TryEnterState = 1,
    TrySelectChildrenInOrder = 2,
    TrySelectChildrenAtRandom = 3,
    TrySelectChildrenWithHighestUtility = 4,
    TrySelectChildrenAtRandomWeightedByUtility = 5,
    TryFollowTransitions = 6,
    TrySelectChildrenAtUniformRandom = 3,
    TrySelectChildrenBasedOnRelativeUtility = 5,
    EStateTreeStateSelectionBehavior_MAX = 7,
};

enum class EStateTreeStateType {
    State = 0,
    Group = 1,
    Linked = 2,
    LinkedAsset = 3,
    Subtree = 4,
    EStateTreeStateType_MAX = 5,
};

enum class EStateTreeTaskCompletionType {
    All = 0,
    Any = 1,
    EStateTreeTaskCompletionType_MAX = 2,
};

enum class EStateTreeTraceEventType {
    Unset = 0,
    OnEntering = 1,
    OnEntered = 2,
    OnExiting = 3,
    OnExited = 4,
    Push = 5,
    Pop = 6,
    OnStateSelected = 7,
    OnStateCompleted = 8,
    OnTicking = 9,
    OnTaskCompleted = 10,
    OnTicked = 11,
    Passed = 12,
    Failed = 13,
    ForcedSuccess = 14,
    ForcedFailure = 15,
    InternalForcedFailure = 16,
    OnRequesting = 17,
    OnEvaluating = 18,
    OnTransition = 19,
    OnTreeStarted = 20,
    OnTreeStopped = 21,
    EStateTreeTraceEventType_MAX = 22,
};

enum class EStateTreeTraceStatus {
    TracesStarted = 0,
    StoppingTrace = 1,
    TracesStopped = 2,
    EStateTreeTraceStatus_MAX = 3,
};

enum class EStateTreeTransitionPriority {
    None = 0,
    Low = 1,
    Normal = 2,
    Medium = 3,
    High = 4,
    Critical = 5,
    EStateTreeTransitionPriority_MAX = 6,
};

enum class EStateTreeTransitionSourceType {
    Unset = 0,
    Asset = 1,
    ExternalRequest = 2,
    Internal = 3,
    EStateTreeTransitionSourceType_MAX = 4,
};

enum class EStateTreeTransitionTrigger {
    None = 0,
    OnStateCompleted = 3,
    OnStateSucceeded = 1,
    OnStateFailed = 2,
    OnTick = 4,
    OnEvent = 8,
    OnDelegate = 16,
    MAX = 17,
};

enum class EStateTreeTransitionType {
    None = 0,
    Succeeded = 1,
    Failed = 2,
    GotoState = 3,
    NextState = 4,
    NextSelectableState = 5,
    NotSet = 6,
    EStateTreeTransitionType_MAX = 7,
};

enum class EStateTreeUpdatePhase {
    Unset = 0,
    StartTree = 1,
    StopTree = 2,
    StartGlobalTasks = 3,
    StartGlobalTasksForSelection = 4,
    StopGlobalTasks = 5,
    StopGlobalTasksForSelection = 6,
    TickStateTree = 7,
    ApplyTransitions = 8,
    TickTransitions = 9,
    TriggerTransitions = 10,
    TickingGlobalTasks = 11,
    TickingTasks = 12,
    TransitionConditions = 13,
    StateSelection = 14,
    TrySelectBehavior = 15,
    EnterConditions = 16,
    EnterStates = 17,
    ExitStates = 18,
    StateCompleted = 19,
    EStateTreeUpdatePhase_MAX = 20,
};

// Size: 0x30
struct FGameplayTagContainerMatchCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ EGameplayContainerMatchType MatchType;
    /* 0x0029 */ bool bExactMatch;
    /* 0x002a */ bool bInvert;
};

// Size: 0x40
struct FGameplayTagContainerMatchConditionInstanceData {
    /* 0x0000 */ FGameplayTagContainer TagContainer;
    /* 0x0020 */ FGameplayTagContainer OtherContainer;
};

// Size: 0x30
struct FGameplayTagMatchCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bExactMatch;
    /* 0x0029 */ bool bInvert;
};

// Size: 0x28
struct FGameplayTagMatchConditionInstanceData {
    /* 0x0000 */ FGameplayTagContainer TagContainer;
    /* 0x0020 */ FGameplayTag Tag;
};

// Size: 0x78
struct FGameplayTagQueryCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ FGameplayTagQuery TagQuery;
    /* 0x0070 */ bool bInvert;
};

// Size: 0x20
struct FGameplayTagQueryConditionInstanceData {
    /* 0x0000 */ FGameplayTagContainer TagContainer;
};

// Size: 0x50
struct FRecordedStateTreeExecutionFrame {
    /* 0x0000 */ UStateTree* StateTree;
    /* 0x0008 */ FStateTreeStateHandle RootState;
    /* 0x000c */ FStateTreeActiveStates ActiveStates;
    /* 0x0040 */ bool bIsGlobalFrame;
};

// Size: 0x38
struct FRecordedStateTreeTransitionResult {
    /* 0x0000 */ TArray<FRecordedStateTreeExecutionFrame> NextActiveFrames;
    /* 0x0010 */ TArray<FStateTreeEvent> NextActiveFrameEvents;
    /* 0x0020 */ FStateTreeStateHandle SourceState;
    /* 0x0022 */ FStateTreeStateHandle TargetState;
    /* 0x0024 */ EStateTreeTransitionPriority Priority;
    /* 0x0028 */ UStateTree* SourceStateTree;
    /* 0x0030 */ FStateTreeStateHandle SourceRootState;
};

// Size: 0x240
class UStateTree : public UDataAsset {
    /* 0x0030 */ uint32_t LastCompiledEditorDataHash;
    /* 0x0038 */ UStateTreeSchema* Schema;
    /* 0x0040 */ TArray<FCompactStateTreeFrame> Frames;
    /* 0x0050 */ TArray<FCompactStateTreeState> States;
    /* 0x0060 */ TArray<FCompactStateTransition> Transitions;
    /* 0x0070 */ FInstancedStructContainer Nodes;
    /* 0x0080 */ FStateTreeInstanceData DefaultInstanceData;
    /* 0x0090 */ FStateTreeInstanceData SharedInstanceData;
    /* 0x00b8 */ TArray<FStateTreeExternalDataDesc> ContextDataDescs;
    /* 0x00d0 */ FStateTreePropertyBindings PropertyBindings;
    /* 0x01d0 */ TArray<FStateTreeStateIdToHandle> IDToStateMappings;
    /* 0x01e0 */ TArray<FStateTreeNodeIdToIndex> IDToNodeMappings;
    /* 0x01f0 */ TArray<FStateTreeTransitionIdToIndex> IDToTransitionMappings;
    /* 0x0200 */ FInstancedPropertyBag Parameters;
    /* 0x0210 */ TArray<FStateTreeExternalDataDesc> ExternalDataDescs;
    /* 0x0220 */ uint32_t CompletionGlobalTasksMask;
    /* 0x0224 */ uint16_t NumContextData;
    /* 0x0226 */ uint16_t NumGlobalInstanceData;
    /* 0x0228 */ uint16_t EvaluatorsBegin;
    /* 0x022a */ uint16_t EvaluatorsNum;
    /* 0x022c */ uint16_t GlobalTasksBegin;
    /* 0x022e */ uint16_t GlobalTasksNum;
    /* 0x0230 */ EStateTreeTaskCompletionType CompletionGlobalTasksControl;
    /* 0x0231 */ EStateTreeParameterDataType ParameterDataType;
    /* 0x0232 */ bool bHasGlobalTransitionTasks;
};

// Size: 0x20
struct FStateTreeAbsoluteFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeAbsoluteIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x34
struct FStateTreeActiveStates {
    /* 0x0020 */ FStateTreeStateHandle States[8];
    /* 0x0030 */ uint8_t NumStates;
};

// Size: 0x20
struct FStateTreeAddFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeAddIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x10
struct FStateTreeAnyEnum {
    /* 0x0000 */ uint32_t Value;
    /* 0x0008 */ UEnum* Enum;
};

// Size: 0x20
struct FStateTreeBindableStructDesc : public FPropertyBindingBindableStructDescriptor {
    /* 0x0018 */ FStateTreeDataHandle DataHandle;
    /* 0x001e */ EStateTreeBindableStructSource DataSource;
};

// Size: 0x30
struct FStateTreeBlueprintConditionWrapper : public FStateTreeConditionBase {
    /* 0x0028 */ UClass* ConditionClass;
};

// Size: 0x30
struct FStateTreeBlueprintConsiderationWrapper : public FStateTreeConsiderationBase {
    /* 0x0028 */ UClass* ConsiderationClass;
};

// Size: 0x28
struct FStateTreeBlueprintEvaluatorWrapper : public FStateTreeEvaluatorBase {
    /* 0x0020 */ UClass* EvaluatorClass;
};

// Size: 0x10
struct FStateTreeBlueprintPropertyRef : public FStateTreePropertyRef {
    /* 0x0002 */ EStateTreePropertyRefType RefType;
    /* 0x0003 */ bool bIsRefToArray;
    /* 0x0003 */ bool bIsOptional;
    /* 0x0008 */ UObject* TypeObject;
};

// Size: 0x38
struct FStateTreeBlueprintTaskWrapper : public FStateTreeTaskBase {
    /* 0x0028 */ UClass* TaskClass;
    /* 0x0030 */ uint8_t TaskFlags;
};

// Size: 0x20
struct FStateTreeBooleanAndPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x2
struct FStateTreeBooleanNotOperationPropertyFunctionInstanceData {
    /* 0x0000 */ bool bInput;
    /* 0x0001 */ bool bResult;
};

// Size: 0x20
struct FStateTreeBooleanNotPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x3
struct FStateTreeBooleanOperationPropertyFunctionInstanceData {
    /* 0x0000 */ bool bLeft;
    /* 0x0001 */ bool bRight;
    /* 0x0002 */ bool bResult;
};

// Size: 0x20
struct FStateTreeBooleanOrPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeBooleanXOrPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x30
struct FStateTreeCompareBoolCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
};

// Size: 0x2
struct FStateTreeCompareBoolConditionInstanceData {
    /* 0x0000 */ bool bLeft;
    /* 0x0001 */ bool bRight;
};

// Size: 0x30
struct FStateTreeCompareDistanceCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
    /* 0x0029 */ EGenericAICheck Operator;
};

// Size: 0x38
struct FStateTreeCompareDistanceConditionInstanceData {
    /* 0x0000 */ FVector Source;
    /* 0x0018 */ FVector Target;
    /* 0x0030 */ double Distance;
};

// Size: 0x30
struct FStateTreeCompareEnumCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
};

// Size: 0x20
struct FStateTreeCompareEnumConditionInstanceData {
    /* 0x0000 */ FStateTreeAnyEnum Left;
    /* 0x0010 */ FStateTreeAnyEnum Right;
};

// Size: 0x30
struct FStateTreeCompareFloatCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
    /* 0x0029 */ EGenericAICheck Operator;
};

// Size: 0x10
struct FStateTreeCompareFloatConditionInstanceData {
    /* 0x0000 */ double Left;
    /* 0x0008 */ double Right;
};

// Size: 0x30
struct FStateTreeCompareIntCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
    /* 0x0029 */ EGenericAICheck Operator;
};

// Size: 0x8
struct FStateTreeCompareIntConditionInstanceData {
    /* 0x0000 */ int32_t Left;
    /* 0x0004 */ int32_t Right;
};

// Size: 0x28
struct FStateTreeConditionBase : public FStateTreeNodeBase {
    /* 0x0020 */ EStateTreeExpressionOperand Operand;
    /* 0x0021 */ int8_t DeltaIndent;
    /* 0x0022 */ EStateTreeConditionEvaluationMode EvaluationMode;
};

// Size: 0x60
class UStateTreeConditionBlueprintBase : public UStateTreeNodeBlueprintBase {

    bool ReceiveTestCondition() const;
};

// Size: 0x28
struct FStateTreeConditionCommonBase : public FStateTreeConditionBase {
};

// Size: 0x28
struct FStateTreeConsiderationBase : public FStateTreeNodeBase {
    /* 0x0020 */ EStateTreeExpressionOperand Operand;
    /* 0x0021 */ int8_t DeltaIndent;
};

// Size: 0x60
class UStateTreeConsiderationBlueprintBase : public UStateTreeNodeBlueprintBase {

    float ReceiveGetScore() const;
};

// Size: 0x28
struct FStateTreeConsiderationCommonBase : public FStateTreeConsiderationBase {
};

// Size: 0x88
struct FStateTreeConsiderationResponseCurve {
    /* 0x0000 */ FRuntimeFloatCurve CurveInfo;
};

// Size: 0x28
struct FStateTreeConstantConsideration : public FStateTreeConsiderationCommonBase {
};

// Size: 0x4
struct FStateTreeConstantConsiderationInstanceData {
    /* 0x0000 */ float Constant;
};

// Size: 0x6
struct FStateTreeDataHandle {
    /* 0x0000 */ EStateTreeDataSourceType Source;
    /* 0x0002 */ uint16_t Index;
    /* 0x0004 */ FStateTreeStateHandle StateHandle;
};

// Size: 0x60
struct FStateTreeDebugTextTask : public FStateTreeTaskCommonBase {
    /* 0x0028 */ FString Text;
    /* 0x0038 */ FColor TextColor;
    /* 0x003c */ float FontScale;
    /* 0x0040 */ FVector Offset;
    /* 0x0058 */ bool bEnabled;
};

// Size: 0x18
struct FStateTreeDebugTextTaskInstanceData {
    /* 0x0000 */ AActor* ReferenceActor;
    /* 0x0008 */ FString BindableText;
};

// Size: 0x28
struct FStateTreeDelayTask : public FStateTreeTaskCommonBase {
};

// Size: 0x14
struct FStateTreeDelayTaskInstanceData {
    /* 0x0000 */ float Duration;
    /* 0x0004 */ float RandomDeviation;
    /* 0x0008 */ bool bRunForever;
};

// Size: 0x10
struct FStateTreeDelegateDispatcher {
    /* 0x0000 */ FGuid ID;
};

// Size: 0x14
struct FStateTreeDelegateListener {
    /* 0x0000 */ FStateTreeDelegateDispatcher Dispatcher;
    /* 0x0010 */ int32_t ID;
};

// Size: 0x20
struct FStateTreeDivideFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeDivideIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x1
struct FStateTreeEditorPropertyPath {
};

// Size: 0x38
struct FStateTreeEnumInputConsideration : public FStateTreeConsiderationCommonBase {
    /* 0x0028 */ FStateTreeEnumValueScorePairs EnumValueScorePairs;
};

// Size: 0x10
struct FStateTreeEnumInputConsiderationInstanceData {
    /* 0x0000 */ FStateTreeAnyEnum Input;
};

// Size: 0x10
struct FStateTreeEnumValueScorePair {
    /* 0x0000 */ int64_t EnumValue;
    /* 0x0008 */ float Score;
};

// Size: 0x10
struct FStateTreeEnumValueScorePairs {
    /* 0x0000 */ TArray<FStateTreeEnumValueScorePair> Data;
};

// Size: 0x20
struct FStateTreeEvaluatorBase : public FStateTreeNodeBase {
};

// Size: 0x60
class UStateTreeEvaluatorBlueprintBase : public UStateTreeNodeBlueprintBase {

    void ReceiveTick(const float deltaTime);
    void ReceiveTreeStart();
    void ReceiveTreeStop();
};

// Size: 0x20
struct FStateTreeEvaluatorCommonBase : public FStateTreeEvaluatorBase {
};

// Size: 0x20
struct FStateTreeEvent {
    /* 0x0000 */ FGameplayTag Tag;
    /* 0x0008 */ FInstancedStruct Payload;
    /* 0x0018 */ FName Origin;
};

// Size: 0x10
struct FStateTreeEventQueue {
    /* 0x0000 */ TArray<FStateTreeSharedEvent> SharedEvents;
};

// Size: 0x8
struct FStateTreeExecutionExtension {
};

// Size: 0x68
struct FStateTreeExecutionFrame {
    /* 0x0000 */ UStateTree* StateTree;
    /* 0x0008 */ FStateTreeStateHandle RootState;
    /* 0x000c */ FStateTreeActiveStates ActiveStates;
    /* 0x0040 */ FStateTreeTasksCompletionStatus ActiveTasksStatus;
    /* 0x0054 */ FStateTreeIndex16 ExternalDataBaseIndex;
    /* 0x0056 */ FStateTreeIndex16 GlobalInstanceIndexBase;
    /* 0x0058 */ FStateTreeIndex16 ActiveInstanceIndexBase;
    /* 0x005a */ FStateTreeDataHandle StateParameterDataHandle;
    /* 0x0060 */ FStateTreeDataHandle GlobalParameterDataHandle;
    /* 0x0067 */ bool bIsGlobalFrame;
};

// Size: 0x78
struct FStateTreeExecutionState {
    /* 0x0000 */ TArray<FStateTreeExecutionFrame> ActiveFrames;
    /* 0x0010 */ TArray<FStateTreeTransitionDelayedState> DelayedTransitions;
    /* 0x0020 */ FRandomStream RandomStream;
    /* 0x0058 */ FInstancedStruct ExecutionExtension;
    /* 0x0068 */ FStateTreeIndex16 EnterStateFailedFrameIndex;
    /* 0x006a */ FStateTreeIndex16 EnterStateFailedTaskIndex;
    /* 0x006c */ FStateTreeIndex16 LastExitedNodeIndex;
    /* 0x006e */ EStateTreeRunStatus LastTickStatus;
    /* 0x006f */ EStateTreeRunStatus TreeRunStatus;
    /* 0x0070 */ EStateTreeRunStatus RequestedStop;
    /* 0x0071 */ EStateTreeUpdatePhase CurrentPhase;
    /* 0x0072 */ uint16_t StateChangeCount;
    /* 0x0074 */ bool bHasPendingCompletedState;
};

// Size: 0x18
struct FStateTreeExternalDataDesc {
    /* 0x0000 */ UStruct* Struct;
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FStateTreeExternalDataHandle Handle;
    /* 0x0016 */ EStateTreeExternalDataRequirement requirement;
};

// Size: 0x6
struct FStateTreeExternalDataHandle {
    /* 0x0000 */ FStateTreeDataHandle DataHandle;
};

// Size: 0xc
struct FStateTreeFloatCombinaisonPropertyFunctionInstanceData {
    /* 0x0000 */ float Left;
    /* 0x0004 */ float Right;
    /* 0x0008 */ float Result;
};

// Size: 0xb0
struct FStateTreeFloatInputConsideration : public FStateTreeConsiderationCommonBase {
    /* 0x0028 */ FStateTreeConsiderationResponseCurve ResponseCurve;
};

// Size: 0xc
struct FStateTreeFloatInputConsiderationInstanceData {
    /* 0x0000 */ float Input;
    /* 0x0004 */ FFloatInterval interval;
};

// Size: 0x28
class UStateTreeFunctionLibrary : public UBlueprintFunctionLibrary {

    static void K2_GetParametersProperty(const FStateTreeReference& Reference, FGuid PropertyID, int32_t& ReturnValue);
    static void K2_SetParametersProperty(FStateTreeReference& Reference, FGuid PropertyID, const int32_t& NewValue);
    static FStateTreeReference MakeStateTreeReference(UStateTree* StateTree);
    static void SetStateTree(FStateTreeReference& Reference, UStateTree* StateTree);
};

// Size: 0x2
struct FStateTreeIndex16 {
    /* 0x0000 */ uint16_t Value;
};

// Size: 0x1
struct FStateTreeIndex8 {
    /* 0x0000 */ uint8_t Value;
};

// Size: 0x10
struct FStateTreeInstanceData {
};

// Size: 0x8
struct FStateTreeInstanceObjectWrapper {
    /* 0x0000 */ UObject* InstanceObject;
};

// Size: 0xe0
struct FStateTreeInstanceStorage {
    /* 0x0000 */ FInstancedStructContainer InstanceStructs;
    /* 0x0010 */ FStateTreeExecutionState ExecutionState;
    /* 0x0088 */ TArray<FStateTreeTemporaryInstanceData> TemporaryInstances;
    /* 0x00b8 */ TArray<FStateTreeTransitionRequest> TransitionRequests;
    /* 0x00c8 */ FInstancedPropertyBag GlobalParameters;
    /* 0x00d8 */ uint32_t UniqueIdGenerator;
};

// Size: 0xc
struct FStateTreeIntCombinaisonPropertyFunctionInstanceData {
    /* 0x0000 */ int32_t Left;
    /* 0x0004 */ int32_t Right;
    /* 0x0008 */ int32_t Result;
};

// Size: 0x20
struct FStateTreeInvertFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeInvertIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeMakeIntervalPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x10
struct FStateTreeMakeIntervalPropertyFunctionInstanceData {
    /* 0x0000 */ float min;
    /* 0x0004 */ float max;
    /* 0x0008 */ FFloatInterval Result;
};

// Size: 0x20
struct FStateTreeMultiplyFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeMultiplyIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeNodeBase {
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FStateTreeIndex16 BindingsBatch;
    /* 0x0012 */ FStateTreeIndex16 InstanceTemplateIndex;
    /* 0x0014 */ FStateTreeDataHandle InstanceDataHandle;
};

// Size: 0x58
class UStateTreeNodeBlueprintBase : public UObject {

    FText GetPropertyDescriptionByPropertyName(FName PropertyName) const;
    void GetPropertyReference(const FStateTreeBlueprintPropertyRef& PropertyRef) const;
    bool IsPropertyRefValid(const FStateTreeBlueprintPropertyRef& PropertyRef) const;
    FText ReceiveGetDescription(EStateTreeNodeFormatting Formatting) const;
    void RequestTransition(const FStateTreeStateLink& TargetState, const EStateTreeTransitionPriority Priority);
    void SendEvent(const FStateTreeEvent& Event);
};

// Size: 0x14
struct FStateTreeNodeIdToIndex {
    /* 0x0000 */ FGuid ID;
    /* 0x0010 */ FStateTreeIndex16 Index;
};

// Size: 0x30
struct FStateTreeObjectEqualsCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
};

// Size: 0x10
struct FStateTreeObjectEqualsConditionInstanceData {
    /* 0x0000 */ UObject* Left;
    /* 0x0008 */ UObject* Right;
};

// Size: 0x30
struct FStateTreeObjectIsChildOfClassCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
};

// Size: 0x10
struct FStateTreeObjectIsChildOfClassConditionInstanceData {
    /* 0x0000 */ UObject* Object;
    /* 0x0008 */ UClass* Class;
};

// Size: 0x30
struct FStateTreeObjectIsValidCondition : public FStateTreeConditionCommonBase {
    /* 0x0028 */ bool bInvert;
};

// Size: 0x8
struct FStateTreeObjectIsValidConditionInstanceData {
    /* 0x0000 */ UObject* Object;
};

// Size: 0x30
struct FStateTreePropertyAccess {
    /* 0x0000 */ FPropertyBindingPropertyIndirection SourceIndirection;
    /* 0x0020 */ UStruct* SourceStructType;
    /* 0x0028 */ FStateTreeDataHandle SourceDataHandle;
};

// Size: 0x100
struct FStateTreePropertyBindings : public FPropertyBindingBindingCollection {
    /* 0x00c0 */ TArray<FStateTreeBindableStructDesc> SourceStructs;
    /* 0x00d0 */ TArray<FStateTreePropertyPathBinding> PropertyPathBindings;
    /* 0x00e0 */ TArray<FStateTreePropertyRefPath> PropertyReferencePaths;
    /* 0x00f0 */ TArray<FStateTreePropertyAccess> PropertyAccesses;
};

// Size: 0x20
struct FStateTreePropertyFunctionBase : public FStateTreeNodeBase {
};

// Size: 0x20
struct FStateTreePropertyFunctionCommonBase : public FStateTreePropertyFunctionBase {
};

// Size: 0x30
struct FStateTreePropertyPathBinding : public FPropertyBindingBinding {
    /* 0x0028 */ FStateTreeDataHandle SourceDataHandle;
};

// Size: 0x2
struct FStateTreePropertyRef {
    /* 0x0000 */ FStateTreeIndex16 RefAccessIndex;
};

// Size: 0x18
struct FStateTreePropertyRefPath {
    /* 0x0000 */ FPropertyBindingPath SourcePropertyPath;
    /* 0x0010 */ FStateTreeDataHandle SourceDataHandle;
};

// Size: 0x28
struct FStateTreeRandomCondition : public FStateTreeConditionCommonBase {
};

// Size: 0x4
struct FStateTreeRandomConditionInstanceData {
    /* 0x0000 */ float Threshold;
};

// Size: 0x4
struct FStateTreeRandomTimeDuration {
    /* 0x0000 */ uint16_t Duration;
    /* 0x0002 */ uint16_t RandomVariance;
};

// Size: 0x28
struct FStateTreeReference {
    /* 0x0000 */ UStateTree* StateTree;
    /* 0x0008 */ FInstancedPropertyBag Parameters;
    /* 0x0018 */ TArray<FGuid> PropertyOverrides;
};

// Size: 0x30
struct FStateTreeReferenceOverrideItem {
    /* 0x0000 */ FGameplayTag StateTag;
    /* 0x0008 */ FStateTreeReference StateTreeReference;
};

// Size: 0x10
struct FStateTreeReferenceOverrides {
    /* 0x0000 */ TArray<FStateTreeReferenceOverrideItem> OverrideItems;
};

// Size: 0x40
struct FStateTreeRunParallelStateTreeExecutionExtension : public FStateTreeExecutionExtension {
};

// Size: 0x30
struct FStateTreeRunParallelStateTreeTask : public FStateTreeTaskCommonBase {
    /* 0x0028 */ FGameplayTag StateTreeOverrideTag;
};

// Size: 0x48
struct FStateTreeRunParallelStateTreeTaskInstanceData {
    /* 0x0000 */ FStateTreeReference StateTree;
    /* 0x0028 */ FStateTreeInstanceData TreeInstanceData;
    /* 0x0038 */ UStateTree* RunningStateTree;
};

// Size: 0x4
struct FStateTreeScheduledTick {
    /* 0x0000 */ float NextDeltaTime;
};

// Size: 0x28
class UStateTreeSchema : public UObject {
};

// Size: 0x28
class IStateTreeSchemaProvider : public UInterface {
};

// Size: 0x40
class UStateTreeSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bAutoStartDebuggerTracesOnNonEditorTargets;
};

// Size: 0x10
struct FStateTreeSharedEvent {
};

// Size: 0x8
struct FStateTreeSingleFloatPropertyFunctionInstanceData {
    /* 0x0000 */ float Input;
    /* 0x0004 */ float Result;
};

// Size: 0x8
struct FStateTreeSingleIntPropertyFunctionInstanceData {
    /* 0x0000 */ int32_t Input;
    /* 0x0004 */ int32_t Result;
};

// Size: 0x2
struct FStateTreeStateHandle {
    /* 0x0000 */ uint16_t Index;
};

// Size: 0x14
struct FStateTreeStateIdToHandle {
    /* 0x0000 */ FGuid ID;
    /* 0x0010 */ FStateTreeStateHandle Handle;
};

// Size: 0x4
struct FStateTreeStateLink {
    /* 0x0000 */ FStateTreeStateHandle StateHandle;
    /* 0x0002 */ EStateTreeSelectionFallback Fallback;
};

// Size: 0x10
struct FStateTreeStructRef {
};

// Size: 0x20
struct FStateTreeSubtractFloatPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x20
struct FStateTreeSubtractIntPropertyFunction : public FStateTreePropertyFunctionCommonBase {
};

// Size: 0x28
struct FStateTreeTaskBase : public FStateTreeNodeBase {
    /* 0x0020 */ bool bTaskEnabled;
    /* 0x0021 */ EStateTreeTransitionPriority TransitionHandlingPriority;
};

// Size: 0x60
class UStateTreeTaskBlueprintBase : public UStateTreeNodeBlueprintBase {
    /* 0x0059 */ bool bShouldStateChangeOnReselect;
    /* 0x0059 */ bool bShouldCallTickOnlyOnEvents;
    /* 0x0059 */ bool bShouldCopyBoundPropertiesOnTick;
    /* 0x0059 */ bool bShouldCopyBoundPropertiesOnExitState;

    void BindDelegate(const FStateTreeDelegateListener& Listener, const FDelegate& Delegate);
    void BroadcastDelegate(FStateTreeDelegateDispatcher Dispatcher);
    void FinishTask(const bool bSucceeded);
    EStateTreeRunStatus ReceiveEnterState(const FStateTreeTransitionResult& Transition);
    void ReceiveExitState(const FStateTreeTransitionResult& Transition);
    void ReceiveLatentEnterState(const FStateTreeTransitionResult& Transition);
    void ReceiveLatentTick(const float deltaTime);
    void ReceiveStateCompleted(const EStateTreeRunStatus CompletionStatus, const FStateTreeActiveStates CompletedActiveStates);
    EStateTreeRunStatus ReceiveTick(const float deltaTime);
    void UnbindDelegate(const FStateTreeDelegateListener& Listener);
};

// Size: 0x28
struct FStateTreeTaskCommonBase : public FStateTreeTaskBase {
};

// Size: 0x10
struct FStateTreeTasksCompletionStatus {
};

// Size: 0x20
struct FStateTreeTemporaryInstanceData {
    /* 0x0004 */ FStateTreeDataHandle DataHandle;
    /* 0x000a */ FStateTreeIndex16 OwnerNodeIndex;
    /* 0x0010 */ FInstancedStruct Instance;
};

// Size: 0x30
struct FStateTreeTransitionDelayedState {
    /* 0x0008 */ UStateTree* StateTree;
    /* 0x0010 */ FStateTreeSharedEvent CapturedEvent;
    /* 0x0020 */ float TimeLeft;
    /* 0x0024 */ uint32_t CapturedEventHash;
    /* 0x0028 */ FStateTreeStateHandle StateHandle;
    /* 0x002a */ FStateTreeIndex16 TransitionIndex;
};

// Size: 0x14
struct FStateTreeTransitionIdToIndex {
    /* 0x0000 */ FGuid ID;
    /* 0x0010 */ FStateTreeIndex16 Index;
};

// Size: 0xc
struct FStateTreeTransitionRequest {
    /* 0x0000 */ FStateTreeStateHandle TargetState;
    /* 0x0002 */ EStateTreeTransitionPriority Priority;
    /* 0x0003 */ EStateTreeSelectionFallback Fallback;
};

// Size: 0x48
struct FStateTreeTransitionResult {
    /* 0x0000 */ TArray<FStateTreeExecutionFrame> NextActiveFrames;
    /* 0x0028 */ FStateTreeStateHandle SourceState;
    /* 0x002a */ FStateTreeStateHandle TargetState;
    /* 0x002c */ FStateTreeStateHandle CurrentState;
    /* 0x002e */ EStateTreeRunStatus CurrentRunStatus;
    /* 0x002f */ EStateTreeStateChangeType ChangeType;
    /* 0x0030 */ EStateTreeTransitionPriority Priority;
    /* 0x0038 */ UStateTree* SourceStateTree;
    /* 0x0040 */ FStateTreeStateHandle SourceRootState;
};

// Size: 0x10
struct FStateTreeTransitionSource {
};

// Size: 0x2f0
class UStaticMeshDescription : public UMeshDescriptionBase {

    void CreateCube(FVector Center, FVector HalfExtents, FPolygonGroupID PolygonGroup, FPolygonID& PolygonID_PlusX, FPolygonID& PolygonID_MinusX, FPolygonID& PolygonID_PlusY, FPolygonID& PolygonID_MinusY, FPolygonID& PolygonID_PlusZ, FPolygonID& PolygonID_MinusZ);
    FVector2D GetVertexInstanceUV(FVertexInstanceID VertexInstanceID, int32_t UVIndex) const;
    void SetPolygonGroupMaterialSlotName(FPolygonGroupID PolygonGroupID, const FName& SlotName);
    void SetVertexInstanceUV(FVertexInstanceID VertexInstanceID, FVector2D UV, int32_t UVIndex);
};

// Size: 0x70
struct FUVMapSettings {
    /* 0x0000 */ FVector Size;
    /* 0x0018 */ FVector2D UVTile;
    /* 0x0028 */ FVector position;
    /* 0x0040 */ FRotator Rotation;
    /* 0x0058 */ FVector Scale;
};

enum class EStoveAlignment {
    TopLeft = 0,
    TopCenter = 1,
    TopRight = 2,
    MiddleLeft = 3,
    MiddleCenter = 4,
    MiddleRight = 5,
    BottomLeft = 6,
    BottomCenter = 7,
    BottomRight = 8,
    EStoveAlignment_MAX = 9,
};

// Size: 0xe8
struct FPopupUIFrame {
    /* 0x0000 */ FStovePopupControl Control;
    /* 0x0058 */ FString Origin;
    /* 0x0068 */ FString ResourceKey;
    /* 0x0078 */ int32_t ID;
    /* 0x0080 */ FString URL;
    /* 0x0090 */ bool bCloseButton;
    /* 0x0091 */ bool bNavigationBar;
    /* 0x0092 */ bool bBackButton;
    /* 0x0093 */ bool bForwardButton;
    /* 0x0094 */ bool bRefreshButton;
    /* 0x0095 */ bool bHomeButton;
    /* 0x0096 */ bool bDisallowedButton;
    /* 0x0097 */ bool bUseLoadingAnimation;
    /* 0x0098 */ int32_t Days;
    /* 0x00a0 */ FString CloseNormalUrl;
    /* 0x00b0 */ FString CloseNormalId;
    /* 0x00c0 */ FString ClosePressedUrl;
    /* 0x00d0 */ FString ClosePressedId;
    /* 0x00e0 */ int32_t CloseType;
};

// Size: 0x90
struct FStoveAchievement {
    /* 0x0000 */ FString AchievementId;
    /* 0x0010 */ FString Name;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ FString DefaultImage;
    /* 0x0040 */ FString AchievedImage;
    /* 0x0050 */ FStoveAchievementCondition Condition;
    /* 0x0078 */ int32_t Value;
    /* 0x0080 */ FString Status;
};

// Size: 0x28
struct FStoveAchievementCondition {
    /* 0x0000 */ int32_t GoalValue;
    /* 0x0008 */ FString ValueOperation;
    /* 0x0018 */ FString Type;
};

// Size: 0x80
struct FStoveAutoPopup {
    /* 0x0000 */ FString Origin;
    /* 0x0010 */ int32_t ID;
    /* 0x0018 */ FString URL;
    /* 0x0028 */ FStovePopupControl Control;
};

// Size: 0x48
struct FStoveCefCookie {
    /* 0x0000 */ FString Domain;
    /* 0x0010 */ FString Path;
    /* 0x0020 */ FString Name;
    /* 0x0030 */ FString Value;
    /* 0x0040 */ bool bHttpOnly;
    /* 0x0041 */ bool bSecure;
    /* 0x0044 */ int32_t Expiration;
};

// Size: 0x20
struct FStoveCefHeader {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Value;
};

// Size: 0x68
struct FStoveCommunityPopup {
    /* 0x0000 */ FString URL;
    /* 0x0010 */ FStovePopupControl Control;
};

// Size: 0x58
struct FStoveConfig {
    /* 0x0000 */ FString Env;
    /* 0x0010 */ FString AppKey;
    /* 0x0020 */ FString SecretKey;
    /* 0x0030 */ FString GameId;
    /* 0x0040 */ int32_t LogLevel;
    /* 0x0048 */ FString LogPath;
};

// Size: 0x68
struct FStoveCouponPopup {
    /* 0x0000 */ FString URL;
    /* 0x0010 */ FStovePopupControl Control;
};

// Size: 0x38
struct FStoveCustomEvent {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Category1;
    /* 0x0020 */ FString Category2;
    /* 0x0030 */ float SimpleValue;
};

// Size: 0x20
struct FStoveCustomEventParameter {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Value;
};

// Size: 0x20
struct FStoveError {
    /* 0x0000 */ int32_t FunctionType;
    /* 0x0004 */ FStoveResult ErrorResult;
    /* 0x0008 */ FString Message;
    /* 0x0018 */ int32_t ExternalError;
};

// Size: 0x50
struct FStoveInventoryItem {
    /* 0x0000 */ int64_t TransactionMasterNo;
    /* 0x0008 */ int64_t TransactionDetailNo;
    /* 0x0010 */ int64_t ProductId;
    /* 0x0018 */ FString GameItemId;
    /* 0x0028 */ FString ProductName;
    /* 0x0038 */ int32_t Quantity;
    /* 0x0040 */ FString ThumbnailUrl;
};

// Size: 0x90
struct FStoveManualPopup {
    /* 0x0000 */ FString Origin;
    /* 0x0010 */ FString ResourceKey;
    /* 0x0020 */ int32_t ID;
    /* 0x0028 */ FString URL;
    /* 0x0038 */ FStovePopupControl Control;
};

// Size: 0x80
struct FStoveNewsPopup {
    /* 0x0000 */ FString Origin;
    /* 0x0010 */ int32_t ID;
    /* 0x0018 */ FString URL;
    /* 0x0028 */ FStovePopupControl Control;
};

// Size: 0x18
struct FStoveOrderProduct {
    /* 0x0000 */ int64_t ProductId;
    /* 0x0008 */ double SalePrice;
    /* 0x0010 */ int32_t Quantity;
};

// Size: 0x18
struct FStoveOverImmersion {
    /* 0x0000 */ FString Message;
    /* 0x0010 */ int32_t ElapsedTimeInHours;
    /* 0x0014 */ int32_t MinExposureTimeInSeconds;
};

// Size: 0x28
struct FStoveOwnership {
    /* 0x0000 */ FString GameId;
    /* 0x0010 */ int32_t GameCode;
    /* 0x0014 */ int32_t OwnershipCode;
    /* 0x0018 */ uint64_t PurchaseDate;
    /* 0x0020 */ uint64_t MemberNo;
};

// Size: 0x58
struct FStovePopupControl {
    /* 0x0000 */ FStovePopupControlUI UI;
};

// Size: 0x58
struct FStovePopupControlUI {
    /* 0x0000 */ FStovePopupControlUIVisible Visible;
    /* 0x0008 */ int32_t DisallowedDay;
    /* 0x0010 */ FStovePopupControlUICloseButtonImage CloseButtonImage;
};

// Size: 0x48
struct FStovePopupControlUICloseButtonImage {
    /* 0x0000 */ FStovePopupControlUICloseButtonImageDetail Normal;
    /* 0x0020 */ FStovePopupControlUICloseButtonImageDetail Pressed;
    /* 0x0040 */ int32_t Type;
};

// Size: 0x20
struct FStovePopupControlUICloseButtonImageDetail {
    /* 0x0000 */ FString FileUrl;
    /* 0x0010 */ FString FileId;
};

// Size: 0x7
struct FStovePopupControlUIVisible {
    /* 0x0000 */ bool CloseButton;
    /* 0x0001 */ bool NavigationBar;
    /* 0x0002 */ bool BackButton;
    /* 0x0003 */ bool ForwardButton;
    /* 0x0004 */ bool RefreshButton;
    /* 0x0005 */ bool HomeButton;
    /* 0x0006 */ bool DisallowedButton;
};

// Size: 0x20
struct FStovePopupRequestCookie {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Value;
};

// Size: 0x20
struct FStovePopupRequestHeader {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ FString Value;
};

// Size: 0xe0
struct FStoveProduct {
    /* 0x0000 */ int64_t ProductId;
    /* 0x0008 */ FString GameItemId;
    /* 0x0018 */ FString Name;
    /* 0x0028 */ FString Description;
    /* 0x0038 */ int32_t Quantity;
    /* 0x003c */ uint16_t ProductTypeCode;
    /* 0x0040 */ FString CategoryId;
    /* 0x0050 */ FString CurrencyCode;
    /* 0x0060 */ double Price;
    /* 0x0068 */ double DisplayPrice;
    /* 0x0070 */ FString DisplayPriceString;
    /* 0x0080 */ double SalePrice;
    /* 0x0088 */ double DisplaySalePrice;
    /* 0x0090 */ FString DisplaySalePriceString;
    /* 0x00a0 */ bool bIsDiscount;
    /* 0x00a2 */ uint16_t DiscountType;
    /* 0x00a4 */ int32_t DiscountTypeValue;
    /* 0x00a8 */ uint64_t DiscountBeginDate;
    /* 0x00b0 */ uint64_t DiscountEndDate;
    /* 0x00b8 */ int32_t TotalQuantity;
    /* 0x00bc */ int32_t MemberQuantity;
    /* 0x00c0 */ int32_t GuidQuantity;
    /* 0x00c8 */ FString ThumbnailUrl;
    /* 0x00d8 */ bool bCanWithdraw;
};

// Size: 0x20
struct FStovePurchase {
    /* 0x0000 */ int64_t TransactionMasterNo;
    /* 0x0008 */ FString TempPaymentUrl;
    /* 0x0018 */ int32_t PurchaseProgress;
};

// Size: 0x28
struct FStovePurchaseProduct {
    /* 0x0000 */ int64_t ProductId;
    /* 0x0008 */ FString CategoryId;
    /* 0x0018 */ int32_t TotalQuantity;
    /* 0x001c */ int32_t MemberQuantity;
    /* 0x0020 */ int32_t GuidQuantity;
};

// Size: 0x8
struct FStovePurchaseVerification {
    /* 0x0000 */ FStoveResult ErrorResult;
    /* 0x0004 */ bool IsPurchased;
};

// Size: 0x30
struct FStoveRank {
    /* 0x0000 */ uint64_t MemberNo;
    /* 0x0008 */ int32_t Score;
    /* 0x000c */ uint32_t Rank;
    /* 0x0010 */ FString Nickname;
    /* 0x0020 */ FString ProfileImage;
};

// Size: 0x4
struct FStoveResult {
    /* 0x0000 */ int32_t Result;
};

// Size: 0x38
class UStoveSDKObject : public UObject {
    /* 0x0030 */ UStoveSDKPopup* _PopupWidget;

    FStoveResult StoveSDKConfirmPurchase(FString TransactionMasterNo);
    FStoveResult StoveSDKFetchInventory();
    FStoveResult StoveSDKFetchProducts(FString CategoryId, const bool IsRefresh);
    FStoveResult StoveSDKFetchShopCategories();
    FStoveResult StoveSDKFetchTermsAgreement();
    FStoveResult StoveSDKGetAchievement(FString AchievementId);
    FStoveResult StoveSDKGetAllAchievement();
    FStoveResult StoveSDKGetAutoPopup();
    FStoveResult StoveSDKGetCommunityPopup();
    FStoveResult StoveSDKGetCouponPopup();
    FStoveState StoveSDKGetInitState();
    FStoveResult StoveSDKGetManualPopup(FString ResourceKey);
    FStoveResult StoveSDKGetNewsPopup();
    FStoveResult StoveSDKGetOwnership();
    FStoveResult StoveSDKGetRank(FString LeaderboardId, const int32_t PageIndex, const int32_t PageSize, bool IncludeMyRank);
    FString StoveSDKGetSDKVersion();
    FStoveResult StoveSDKGetStat(FString StatId);
    FStoveResult StoveSDKGetToken();
    FStoveTraceHint StoveSDKGetTraceHint();
    FStoveResult StoveSDKGetUser();
    FStoveResult StoveSDKIAPInit(FString ShopKey);
    FStoveResult StoveSDKInit(const FStoveConfig& config);
    FStoveResult StoveSDKSetGameProfile(FString WorldId, FString CharactorNo);
    FStoveResult StoveSDKSetLanguage(FString Language);
    FStoveResult StoveSDKSetPopupDisallowed(const int32_t PopupId, const int32_t Days);
    FStoveResult StoveSDKSetStat(FString StatId, const int32_t StatValue);
    FStoveResult StoveSDKStartPurchase(const TArray<FStoveOrderProduct> Products, const int32_t ProductSize);
    FStoveResult StoveSDKStashCustomEvent(FString Name, FString Category1, FString Category2, FString SimpleValue, const TArray<FStoveCustomEventParameter> Params, int32_t ParamSize);
    FString StoveSDKTranslateLanguage(FString Original);
    FStoveResult StoveSDKUnInit();
    FStovePurchaseVerification StoveSDKVerifyPurchase(FString CategoryId, FString ProductId);
};

// Size: 0x530
class UStoveSDKPopup : public UUserWidget {
};

// Size: 0x40
struct FStoveShopCategories {
    /* 0x0000 */ FString CategoryId;
    /* 0x0010 */ FString ParentCategoryId;
    /* 0x0020 */ int32_t DisplayNo;
    /* 0x0028 */ FString Name;
    /* 0x0038 */ int32_t Depth;
};

// Size: 0x20
struct FStoveShutdown {
    /* 0x0000 */ int32_t InAdvanceTimeInMinutes;
    /* 0x0008 */ FString Message;
    /* 0x0018 */ int32_t ExposureTimeInSeconds;
};

// Size: 0x38
struct FStoveStat {
    /* 0x0000 */ FStoveStatFullId StatFullId;
    /* 0x0020 */ int32_t CurrentValue;
    /* 0x0028 */ uint64_t MemberNo;
    /* 0x0030 */ uint64_t UpdatedAt;
};

// Size: 0x20
struct FStoveStatFullId {
    /* 0x0000 */ FString GameId;
    /* 0x0010 */ FString StatId;
};

// Size: 0x18
struct FStoveStatValue {
    /* 0x0000 */ int32_t CurrentValue;
    /* 0x0004 */ bool bUpdated;
    /* 0x0008 */ FString ErrorMessage;
};

// Size: 0x4
struct FStoveState {
    /* 0x0000 */ int32_t State;
};

// Size: 0x38
struct FStoveTermsAgreement {
    /* 0x0000 */ FString GameId;
    /* 0x0010 */ bool Result;
    /* 0x0018 */ FString Region;
    /* 0x0028 */ FString AgreementUrl;
};

// Size: 0x10
struct FStoveToken {
    /* 0x0000 */ FString AccessToken;
};

// Size: 0x58
struct FStoveTraceHint {
    /* 0x0000 */ FStoveResult ErrorResult;
    /* 0x0008 */ FString SessionId;
    /* 0x0018 */ FString RefSessionId;
    /* 0x0028 */ FString UUID;
    /* 0x0038 */ FString ServiceProtocol;
    /* 0x0048 */ FString RefSourceType;
};

// Size: 0x28
struct FStoveUser {
    /* 0x0000 */ uint64_t MemberNo;
    /* 0x0008 */ FString Nickname;
    /* 0x0018 */ FString GameUserId;
};

enum class EStreamlineFeature {
    DLSSG = 0,
    Latewarp = 1,
    Reflex = 2,
    DeepDVC = 3,
    Count = 4,
    EStreamlineFeature_MAX = 5,
};

enum class EStreamlineFeatureRequirementsFlags {
    None = 0,
    D3D11Supported = 1,
    D3D12Supported = 2,
    VulkanSupported = 4,
    VSyncOffRequired = 8,
    HardwareSchedulingRequired = 16,
    EStreamlineFeatureRequirementsFlags_MAX = 17,
};

enum class EStreamlineFeatureSupport {
    Supported = 0,
    NotSupported = 1,
    NotSupportedIncompatibleHardware = 2,
    NotSupportedDriverOutOfDate = 3,
    NotSupportedOperatingSystemOutOfDate = 4,
    NotSupportedHardewareSchedulingDisabled = 5,
    NotSupportedByRHI = 6,
    NotSupportedByPlatformAtBuildTime = 7,
    NotSupportedIncompatibleAPICaptureToolActive = 8,
    EStreamlineFeatureSupport_MAX = 9,
};

// Size: 0x34
struct FStreamlineFeatureRequirements {
    /* 0x0000 */ EStreamlineFeatureSupport Support;
    /* 0x0001 */ EStreamlineFeatureRequirementsFlags Requirements;
    /* 0x0004 */ FStreamlineVersion RequiredOperatingSystemVersion;
    /* 0x0010 */ FStreamlineVersion DetectedOperatingSystemVersion;
    /* 0x001c */ FStreamlineVersion RequiredDriverVersion;
    /* 0x0028 */ FStreamlineVersion DetectedDriverVersion;
};

// Size: 0x28
class UStreamlineLibrary : public UBlueprintFunctionLibrary {

    static void BreakStreamlineFeatureRequirements(EStreamlineFeatureRequirementsFlags Requirements, bool& D3D11Supported, bool& D3D12Supported, bool& VulkanSupported, bool& VSyncOffRequired, bool& HardwareSchedulingRequired);
    static FStreamlineFeatureRequirements GetStreamlineFeatureInformation(EStreamlineFeature Feature);
    static bool IsStreamlineFeatureSupported(EStreamlineFeature Feature);
    static EStreamlineFeatureSupport QueryStreamlineFeatureSupport(EStreamlineFeature Feature);
};

// Size: 0xc
struct FStreamlineVersion {
    /* 0x0000 */ int32_t Major;
    /* 0x0004 */ int32_t Minor;
    /* 0x0008 */ int32_t Build;
};

enum class EStreamlineDLSSGMode {
    Off = 0,
    Auto = 251,
    On2X = 17,
    On3X = 23,
    On4X = 31,
    EStreamlineDLSSGMode_MAX = 252,
};

// Size: 0x28
class UStreamlineLibraryDLSSG : public UBlueprintFunctionLibrary {

    static void GetDLSSGFrameTiming(float& FrameRateInHertz, int32_t& FramesPresented);
    static EStreamlineDLSSGMode GetDLSSGMode();
    static EStreamlineDLSSGMode GetDefaultDLSSGMode();
    static TArray<EStreamlineDLSSGMode> GetSupportedDLSSGModes();
    static bool IsDLSSGModeSupported(EStreamlineDLSSGMode DLSSGMode);
    static bool IsDLSSGSupported();
    static EStreamlineFeatureSupport QueryDLSSGSupport();
    static void SetDLSSGMode(EStreamlineDLSSGMode DLSSGMode);
};

enum class EStreamlineSettingOverride {
    Enabled = 0,
    Disabled = 1,
    UseProjectSettings = 2,
    EStreamlineSettingOverride_MAX = 3,
};

// Size: 0x30
class UStreamlineOverrideSettings : public UObject {
    /* 0x0028 */ EStreamlineSettingOverride LoadDebugOverlayOverride;
    /* 0x0029 */ EStreamlineSettingOverride AllowOTAUpdateOverride;
    /* 0x002a */ EStreamlineSettingOverride EnableDLSSFGInPlayInEditorViewportsOverride;
    /* 0x002b */ EStreamlineSettingOverride UseSlSetTagOverride;
};

// Size: 0x38
class UStreamlineSettings : public UObject {
    /* 0x0028 */ bool bLoadDebugOverlay;
    /* 0x0029 */ bool bAllowOTAUpdate;
    /* 0x002c */ int32_t NVIDIANGXApplicationId;
    /* 0x0030 */ bool bEnableStreamlineD3D12;
    /* 0x0031 */ bool bEnableStreamlineD3D11;
    /* 0x0032 */ bool bEnableDLSSFGInPlayInEditorViewports;
    /* 0x0033 */ bool bUseSlSetTag;
};

enum class EStreamlineReflexMode {
    Off = 0,
    Enabled = 1,
    Boost = 3,
    EStreamlineReflexMode_MAX = 4,
};

// Size: 0x28
class UStreamlineLibraryReflex : public UBlueprintFunctionLibrary {

    static EStreamlineReflexMode GetDefaultReflexMode();
    static float GetGameLatencyInMs();
    static float GetGameToRenderLatencyInMs();
    static EStreamlineReflexMode GetReflexMode();
    static float GetRenderLatencyInMs();
    static TArray<EStreamlineReflexMode> GetSupportedReflexModes();
    static bool IsReflexModeSupported(EStreamlineReflexMode ReflexMode);
    static bool IsReflexSupported();
    static EStreamlineFeatureSupport QueryReflexSupport();
    static void SetReflexMode(const EStreamlineReflexMode Mode);
};

// Size: 0x288
struct FAchievementDataRowBase : public FTableRowBase {
    /* 0x0008 */ FString ID;
    /* 0x0018 */ int32_t Index;
    /* 0x0020 */ FString scope;
    /* 0x0030 */ FString metric;
    /* 0x0040 */ FString argument;
    /* 0x0050 */ EMetaMetricOp Op;
    /* 0x0054 */ float Value;
    /* 0x0058 */ FString wingdkid;
    /* 0x0068 */ FString en;
    /* 0x0078 */ FString en_desc;
    /* 0x0088 */ FString ja;
    /* 0x0098 */ FString ja_desc;
    /* 0x00a8 */ FString fr;
    /* 0x00b8 */ FString fr_desc;
    /* 0x00c8 */ FString it;
    /* 0x00d8 */ FString it_desc;
    /* 0x00e8 */ FString de;
    /* 0x00f8 */ FString de_desc;
    /* 0x0108 */ FString es;
    /* 0x0118 */ FString es_desc;
    /* 0x0128 */ FString cs;
    /* 0x0138 */ FString cs_desc;
    /* 0x0148 */ FString hu;
    /* 0x0158 */ FString hu_desc;
    /* 0x0168 */ FString ko;
    /* 0x0178 */ FString ko_desc;
    /* 0x0188 */ FString pt;
    /* 0x0198 */ FString pt_desc;
    /* 0x01a8 */ FString ru;
    /* 0x01b8 */ FString ru_desc;
    /* 0x01c8 */ FString zh;
    /* 0x01d8 */ FString zh_desc;
    /* 0x01e8 */ FString zhtw;
    /* 0x01f8 */ FString zhtw_desc;
    /* 0x0208 */ FString tr;
    /* 0x0218 */ FString tr_desc;
    /* 0x0228 */ FString ua;
    /* 0x0238 */ FString ua_desc;
    /* 0x0248 */ FString pl;
    /* 0x0258 */ FString pl_desc;
    /* 0x0268 */ FString esmx;
    /* 0x0278 */ FString esmx_desc;
};

// Size: 0x18
struct FActivityEntry {
    /* 0x0000 */ EActivityPriority Priority;
    /* 0x0008 */ FString titleStringKey;
};

// Size: 0x4
struct FActivityShowConfig {
    /* 0x0000 */ int32_t maxShownAcivities;
};

// Size: 0x18
struct FActivityShowState {
    /* 0x0000 */ int32_t maxEntries;
    /* 0x0008 */ TArray<FActivityEntry> activeEntries;
};

// Size: 0x50
struct FActivityState {
    /* 0x0000 */ TMap<UActorComponent*, FActivityEntry> activeEntries;
};

// Size: 0x120
class UActivityTracker : public UActorComponent {
    /* 0x00b8 */ FActivityState State;
    /* 0x0108 */ FActivityShowConfig showConfig;
    /* 0x010c */ bool IsDirty;
    /* 0x0110 */ FMulticastInlineDelegate uponStateChange;

    void ClearActivityEntry(UActorComponent* Source);
    FActivityShowState ComputeShowState(FActivityShowConfig config) const;
    FActivityState GetState() const;
    void SetActivityEntry(UActorComponent* Source, FActivityEntry Entry);
};

// Size: 0x78
class UAssetBook : public UObject {
    /* 0x0028 */ TMap<FString, FBookPage> pages;

    UObject* GetAsset(FString Name) const;
    UClass* GetAssetClass(FString Name) const;
    bool HasAsset(FString Name) const;
    TArray<FString> ListPageNames() const;
};

// Size: 0x2f8
class AAssetConfigMule : public AActor {
    /* 0x02a8 */ FAssetLibraryConfig config;
};

// Size: 0xc8
class UAssetLibrary : public UObject {
    /* 0x0028 */ FAssetLibraryConfig config;
    /* 0x0078 */ TMap<FString, UAssetBook*> loadedBooks;

    UAssetBook* GetBook(FString bookName) const;
    bool IsLoaded(FString bookName) const;
    void KickoffAutoLoads();
};

// Size: 0x30
struct FAssetLibraryBookRef {
    /* 0x0000 */ bool isAutoLoad;
    /* 0x0008 */ TSoftClassPtr<UAssetBook> bookClass;
};

// Size: 0x50
struct FAssetLibraryConfig {
    /* 0x0000 */ TMap<FString, FAssetLibraryBookRef> bookrefs;
};

// Size: 0xc8
class UAutoOrientTracker : public UActorComponent {
    /* 0x00b8 */ FOrientConfig config;
    /* 0x00c0 */ FOrientState State;
};

// Size: 0x2e0
class UBackbone : public UGameInstance {
    /* 0x01c0 */ FBackboneConfig config;
    /* 0x0228 */ UGenericSaveGame* runtimeState;
    /* 0x0240 */ UPlatformManager* PlatformManager;
    /* 0x0248 */ UOptionManager* OptionManager;
    /* 0x0250 */ UProfileManager* ProfileManager;
    /* 0x0258 */ UAssetLibrary* AssetLibrary;
    /* 0x0260 */ UNotificationBoard* NotificationBoard;
    /* 0x0268 */ USnapclipManager* SnapclipManager;
    /* 0x0270 */ UBeatManager* BeatManager;
    /* 0x0278 */ UStoryManager* StoryManager;
    /* 0x0280 */ ULocManager* LocManager;
    /* 0x0288 */ UIconBroker* IconBroker;
    /* 0x0290 */ UMasterSyncManager* masterSync;
    /* 0x0298 */ UMetaMetric* MetaMetric;
    /* 0x02a0 */ UGlobe* Globe;
    /* 0x02a8 */ UMailManager* MailManager;
    /* 0x02b0 */ UNetMan* NetMan;
    /* 0x02b8 */ USaveLibrary* SaveLibrary;
    /* 0x02c0 */ UInputIconManager* InputIconManager;
    /* 0x02c8 */ UPixelFed* PixelFed;
    /* 0x02d0 */ UModManager* ModManager;
    /* 0x02d8 */ UModAPI* ModAPI;

    static UObject* GetAsset(const UObject* WorldContext, FString bookName, FString AssetName);
    static UClass* GetAssetClass(const UObject* WorldContext, FString bookName, FString AssetName);
    static UAssetLibrary* GetAssetLibrary(const UObject* WorldContext);
    static UBackbone* GetBackbone(const UObject* WorldContext);
    static UBeatManager* GetBeatManager(const UObject* WorldContext);
    static UGlobe* GetGlobe(const UObject* WorldContext);
    static UInputIconManager* GetInputIconManager(const UObject* WorldContext);
    static UDataTable* GetLinkedTable(const UObject* WorldContext, FName tableName);
    static ULocManager* GetLocManager(const UObject* WorldContext);
    static UMetaMetric* GetMetaMetric(const UObject* WorldContext);
    static UModManager* GetModManager(const UObject* WorldContext);
    static UNetMan* GetNetMan(const UObject* WorldContext);
    static UOptionManager* GetOptionManager(const UObject* WorldContext);
    static UPixelFed* GetPixelFed(const UObject* WorldContext);
    static UPlatformManager* GetPlatformManager(const UObject* WorldContext);
    static APopConfigMule* GetPopConfigMule(const UObject* WorldContext);
    static UGenericSaveGame* GetRuntimeState(const UObject* WorldContext);
    static UGenericSaveGame* GetSave(const UObject* WorldContext);
    static USaveLibrary* GetSaveLibrary(const UObject* WorldContext);
    static UTexture2D* GetSnapclip(const UObject* WorldContext, UClass* Subject);
    static UGenericSaveGame* GetSpecificSave(const UObject* WorldContext, int32_t profileIndex);
    static UStoryManager* GetStoryManager(const UObject* WorldContext);
    static bool HasAsset(const UObject* WorldContext, FString bookName, FString AssetName);
    static bool IsController(const UObject* WorldContext);
    static bool IsMasterSyncBusy(const UObject* WorldContext);
    static void ReportMetricAbsolute(const UObject* WorldContext, FName metricId, FName argument, int32_t Value);
    static void ReportMetricAdditive(const UObject* WorldContext, FName metricId, FName argument, int32_t Value);
    static void RequestMasterSyncUpdate(const UObject* WorldContext);
    static void SetPrimeProfile(const UObject* WorldContext, int32_t profileIndex);
};

// Size: 0x68
struct FBackboneConfig {
    /* 0x0000 */ UClass* OptionConfigMule;
    /* 0x0008 */ UClass* ProfileConfigMule;
    /* 0x0010 */ UClass* AssetConfigMule;
    /* 0x0018 */ UClass* SnapclipConfigMule;
    /* 0x0020 */ UClass* BeatConfigMule;
    /* 0x0028 */ UClass* StoryConfigMule;
    /* 0x0030 */ UClass* LocConfigMule;
    /* 0x0038 */ UClass* IconConfigMule;
    /* 0x0040 */ UClass* PopConfigMule;
    /* 0x0048 */ UClass* MasterSyncConfigMule;
    /* 0x0050 */ UClass* MetaMetricConfigMule;
    /* 0x0058 */ UClass* GlobeConfigMule;
    /* 0x0060 */ UClass* MailConfigMule;
};

// Size: 0x28
class UBackingParser : public UBlueprintFunctionLibrary {

    static bool ParseFromRaw(FMapDataHolding& mapData, FPlayState& PlayState, const TArray<uint8_t>& raw);
    static bool ParseToRaw(const FMapDataHolding& Data, const FPlayState& PlayState, TArray<uint8_t>& raw);
};

// Size: 0x2b8
class ABeatConfigMule : public AActor {
    /* 0x02a8 */ FBeatManagerConfig config;
};

// Size: 0x60
class UBeatManager : public UObject {
    /* 0x0028 */ FBeatManagerState State;
    /* 0x0050 */ FBeatManagerConfig config;

    void DeriveFromBpm(float bpm);
    float GetBeatRise() const;
    float GetBeats() const;
    float GetMeasureRise() const;
    float GetMeasures() const;
    void UpdateBeats(UObject* WorldContext, float deltaTime);
    void UpdateCollection(UObject* WorldContext);
};

// Size: 0x10
struct FBeatManagerConfig {
    /* 0x0000 */ float bpm;
    /* 0x0008 */ UMaterialParameterCollection* beatParameterCollection;
};

// Size: 0x24
struct FBeatManagerState {
    /* 0x0000 */ float Time;
    /* 0x0004 */ float beatsPerMinute;
    /* 0x0008 */ float beatsPerSecond;
    /* 0x000c */ float beatsTotal;
    /* 0x0010 */ float beatRise;
    /* 0x0014 */ float measuresPerMinute;
    /* 0x0018 */ float measuresPerSecond;
    /* 0x001c */ float measuresTotal;
    /* 0x0020 */ float measureRise;
};

// Size: 0xf8
class UBeltCell : public UActorComponent {
    /* 0x00b8 */ FBeltCellData localCellData;
    /* 0x00f0 */ EBeltEntryResult desiredResult;
};

// Size: 0x38
struct FBeltCellData {
    /* 0x0000 */ int32_t ID;
    /* 0x0008 */ UBeltCell* handler;
    /* 0x0010 */ FBeltPos position;
    /* 0x0018 */ FBeltPath Path;
    /* 0x0028 */ float Speed;
    /* 0x002c */ FName Name;
};

// Size: 0x18
struct FBeltEdgeData {
    /* 0x0000 */ int32_t ID;
    /* 0x0004 */ float Length;
    /* 0x0008 */ FName Type;
    /* 0x0010 */ int32_t startNode;
    /* 0x0014 */ int32_t endNode;
};

// Size: 0x258
class UBeltGraph : public UActorComponent {
    /* 0x00b8 */ FBeltGraphState State;
    /* 0x0208 */ FMulticastInlineDelegate onNodeEdit;
    /* 0x0218 */ FMulticastInlineDelegate onEdgeEdit;
    /* 0x0228 */ FMulticastInlineDelegate onCellEdit;
    /* 0x0238 */ FMulticastInlineDelegate onCellPathless;
    /* 0x0248 */ FMulticastInlineDelegate onCellRescue;
};

// Size: 0x1
struct FBeltGraphConfig {
    /* 0x0000 */ bool enableProfiling;
};

// Size: 0x150
struct FBeltGraphState {
    /* 0x0000 */ TMap<int32_t, FBeltEdgeData> Edges;
    /* 0x0050 */ TMap<int32_t, FBeltNodeData> Nodes;
    /* 0x00a0 */ TMap<int32_t, FBeltCellData> Cells;
    /* 0x00f0 */ int32_t nextId;
    /* 0x00f8 */ TSet<int32_t> freeIds;
    /* 0x0148 */ double Speed;
};

// Size: 0x2a0
class UBeltNode : public USceneComponent {
    /* 0x0240 */ FBeltNodeData localNodeData;
    /* 0x0290 */ EBeltEntryAction desiredAction;
};

// Size: 0x50
struct FBeltNodeData {
    /* 0x0000 */ int32_t ID;
    /* 0x0008 */ UBeltNode* handler;
    /* 0x0010 */ FVector position;
    /* 0x0028 */ TArray<int32_t> enterEdges;
    /* 0x0038 */ TArray<int32_t> exitEdges;
    /* 0x0048 */ FName Name;
};

// Size: 0x10
struct FBeltPath {
    /* 0x0000 */ TArray<int32_t> edgeList;
};

// Size: 0x8
struct FBeltPos {
    /* 0x0000 */ int32_t edge;
    /* 0x0004 */ float Distance;
};

// Size: 0x1c
struct FBeltVisualConfig {
    /* 0x0000 */ float lagSpeed;
    /* 0x0004 */ FColor nodeColor;
    /* 0x0008 */ float nodeRadius;
    /* 0x000c */ int32_t nodeSegments;
    /* 0x0010 */ float nodeLineThickness;
    /* 0x0014 */ FColor edgeColor;
    /* 0x0018 */ float edgeLineThickness;
};

// Size: 0x10
struct FBeltVisualState {
    /* 0x0000 */ UBeltGraph* belt;
    /* 0x0008 */ bool isShowing;
};

// Size: 0xe8
class UBeltVisualizer : public UActorComponent {
    /* 0x00b8 */ FBeltVisualConfig config;
    /* 0x00d8 */ FBeltVisualState State;

    void EditEdge(const FBeltEdgeData& edge, bool Show);
    void EditNode(const FBeltNodeData& Node, bool Show);
};

// Size: 0x4
struct FBlockTerrainMinePillarData {
};

// Size: 0x1130
struct FBlockTerrainSlice {
    /* 0x0000 */ USceneComponent* Parent;
    /* 0x0008 */ FGridInstaMesh CliffMeshes;
    /* 0x0128 */ FGridInstaMesh SliceMeshes;
    /* 0x0248 */ FGridInstaMesh CoverMeshes;
    /* 0x0368 */ FGridInstaMesh OreFullMeshes;
    /* 0x0488 */ FGridInstaMesh OreSliceMeshes;
    /* 0x05a8 */ FGridInstaMesh OreTopMeshes;
    /* 0x06c8 */ TArray<FGridInstaMesh> PlantMeshes;
    /* 0x06d8 */ FGridInstaMesh GrassPropMeshes;
    /* 0x07f8 */ FGridInstaMesh RockPropMeshes;
    /* 0x0918 */ FGridInstaMesh ShallowOceanPropMeshes;
    /* 0x0a38 */ FGridInstaMesh DeepOceanPropMeshes;
    /* 0x0b58 */ FGridInstaMesh GrassPropWithShadowMeshes;
    /* 0x0c78 */ FGridInstaMesh RockPropWithShadowMeshes;
    /* 0x0d98 */ FGridInstaMesh ShallowOceanPropWithShadowMeshes;
    /* 0x0eb8 */ TArray<FGridInstaMesh> CropMeshes;
    /* 0x0ec8 */ FGridInstaMesh MineMeshes;
    /* 0x0fe8 */ FGridInstaMesh PollutionMeshes;
    /* 0x1108 */ UStaticMesh* InfiniteGroundMesh;
    /* 0x1110 */ UStaticMeshComponent* InfiniteGroundMeshComponent;
    /* 0x1118 */ UStaticMesh* InfiniteCoverMesh;
    /* 0x1120 */ UStaticMeshComponent* InfiniteCoverMeshComponent;
    /* 0x1128 */ ETerrainSliceState State;
};

// Size: 0x28
class UBlueBox : public UBlueprintFunctionLibrary {

    static FBlueBoxState Init(const UObject* WorldContext, FName codeSpace, FName codeId);
    static EBlueBoxStatus Run(const FBlueBoxInput& Input, const FBlueBoxState& startState, FBlueBoxState& resultState);
};

// Size: 0x18
struct FBlueBoxContext {
    /* 0x0000 */ USmallHoldComponent* smallHold;
    /* 0x0008 */ UWorld* World;
    /* 0x0010 */ UDataTable* Table;
};

// Size: 0x28
struct FBlueBoxDisplay {
    /* 0x0000 */ bool Show;
    /* 0x0004 */ FName Title;
    /* 0x000c */ FName Content;
    /* 0x0018 */ TArray<FName> choices;
};

// Size: 0x18
struct FBlueBoxInput {
    /* 0x0000 */ FName InputKey;
    /* 0x0008 */ FName resultKey;
    /* 0x0010 */ FName resultPayload;
};

// Size: 0x28
struct FBlueBoxOperation {
    /* 0x0000 */ FName opType;
    /* 0x0008 */ TArray<FName> Inputs;
    /* 0x0018 */ TArray<FName> Outputs;
};

// Size: 0x68
struct FBlueBoxRow : public FTableRowBase {
    /* 0x0008 */ FName ID;
    /* 0x0010 */ FName Next;
    /* 0x0018 */ FName Op;
    /* 0x0020 */ FName Arg1;
    /* 0x0028 */ FName Arg2;
    /* 0x0030 */ FName arg3;
    /* 0x0038 */ FName arg4;
    /* 0x0040 */ FName arg5;
    /* 0x0048 */ FName arg6;
    /* 0x0050 */ FName arg7;
    /* 0x0058 */ FName arg8;
    /* 0x0060 */ FName arg9;
};

// Size: 0xa0
struct FBlueBoxState {
    /* 0x0000 */ FBlueBoxDisplay display;
    /* 0x0028 */ TMap<FName, FString> Variables;
    /* 0x0078 */ FName codeId;
    /* 0x0080 */ FName errorId;
    /* 0x0088 */ FBlueBoxContext Context;
};

// Size: 0x10
struct FBookPage {
    /* 0x0000 */ UObject* uobject;
    /* 0x0008 */ UClass* uclass;
};

// Size: 0x150
class UBorderAuthority : public UActorComponent {
    /* 0x00b8 */ FBorderAuthorityConfig config;
    /* 0x00f8 */ FBorderAuthorityState State;

    void DefineBorder(FBorderTag& Tag, const FBorderPlan& plan);
    FBorderPlan GeneratePlan(FIntVector position, FIntVector Size) const;
    void SetConfig(FBorderAuthorityConfig nc);
};

// Size: 0x40
struct FBorderAuthorityConfig {
    /* 0x0000 */ FBorderStyle defaultStyle;
};

// Size: 0x58
struct FBorderAuthorityState {
    /* 0x0000 */ TMap<int32_t, ABorderLine*> borders;
    /* 0x0050 */ int32_t nextBorderId;
};

// Size: 0x310
class ABorderLine : public AActor {
    /* 0x02a8 */ FBorderPlan plan;
    /* 0x02f8 */ USplineComponent* Spline;
    /* 0x0300 */ TArray<USplineMeshComponent*> splineNodes;

    void ApplyPlan(FBorderPlan np);
};

// Size: 0x50
struct FBorderPlan {
    /* 0x0000 */ FBorderStyle style;
    /* 0x0040 */ TArray<FIntVector> Positions;
};

// Size: 0x40
struct FBorderStyle {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ UMaterialInterface* Material;
    /* 0x0010 */ float nodeDistance;
    /* 0x0014 */ float hoverHeight;
    /* 0x0018 */ FVector worldOffset;
    /* 0x0030 */ float midDist;
    /* 0x0034 */ float subOffset;
    /* 0x0038 */ uint8_t pointType;
    /* 0x0039 */ bool renderShadow;
    /* 0x003a */ bool renderDepth;
    /* 0x003b */ bool renderInverse;
};

// Size: 0x4
struct FBorderTag {
    /* 0x0000 */ int32_t borderId;
};

// Size: 0x250
class UCarryPoint : public USceneComponent {
    /* 0x0240 */ AActor* attachedCargo;
    /* 0x0248 */ UPhysicsConstraintComponent* Constraint;

    void AttachCargo(AActor* cargo);
    AActor* DetachCargo();
    AActor* GetCargo() const;
    bool HasCargo() const;
};

// Size: 0x290
class UCellBridge : public USceneComponent {
    /* 0x0240 */ FCellBridgeConfig config;
    /* 0x0250 */ FCellBridgeState State;
    /* 0x0268 */ bool hasInited;

    void ForceRedraw();
    void Redraw();
    void SetConfig(FCellBridgeConfig nc);
};

// Size: 0x10
struct FCellBridgeConfig {
    /* 0x0000 */ int32_t Size;
    /* 0x0008 */ UTextureRenderTarget2D* RenderTarget;
};

// Size: 0x2b8
class ACellBridgeConfigMule : public AActor {
    /* 0x02a8 */ FCellBridgeConfig config;
};

// Size: 0x18
struct FCellBridgeState {
    /* 0x0000 */ TArray<uint8_t> pixels;
    /* 0x0010 */ bool IsDirty;
};

// Size: 0x28
class UCheatDoer : public UBlueprintFunctionLibrary {

    static void EngineExec(UObject* WorldContext, FString Cmd);
    static void ToggleFps(UObject* WorldContext);
};

// Size: 0x180
class UCircus : public UActorComponent {
    /* 0x00b8 */ FCircusConfig config;
    /* 0x00e0 */ FCircusState State;

    UClass* GetActorClass(FName clownType) const;
    UStaticMesh* GetPreviewMesh(FName clownType) const;
    TArray<FName> ListClownTypes() const;
    FName LookupEntityIdFromPoint(FIntVector Point) const;
};

// Size: 0x2e8
class ACircusClownBase : public AActor {
    /* 0x02a8 */ FCircusMemberState State;
    /* 0x02c4 */ FName primeType;
    /* 0x02d0 */ USmallHoldComponent* smallHold;
    /* 0x02d8 */ UStagePrepEntity* stageEntity;
    /* 0x02e0 */ UDyehouse* Dyehouse;

    void OnRep_State();
};

// Size: 0x28
struct FCircusConfig {
    /* 0x0000 */ UDataTable* clownTable;
    /* 0x0008 */ FRotator clownRotation;
    /* 0x0020 */ float clownHeight;
};

// Size: 0x28
struct FCircusEdit {
    /* 0x0000 */ FName EntityID;
    /* 0x0008 */ FIntVector Point;
    /* 0x0014 */ FName Type;
    /* 0x001c */ FName Team;
    /* 0x0024 */ EHexDir Dir;
};

// Size: 0x28
struct FCircusMember {
    /* 0x0000 */ FName EntityID;
    /* 0x0008 */ AActor* primeActor;
    /* 0x0010 */ FName primeType;
    /* 0x0018 */ FName Team;
    /* 0x0020 */ EHexDir Rotation;
};

// Size: 0x1c
struct FCircusMemberState {
    /* 0x0000 */ FName EntityID;
    /* 0x0008 */ FName Team;
    /* 0x0010 */ FName primeType;
    /* 0x0018 */ EHexDir Rotation;
};

// Size: 0xa0
struct FCircusPayroll {
    /* 0x0000 */ TMap<FName, FCircusMember> members;
    /* 0x0050 */ TMap<FIntVector, FName> memberIdByPoint;
};

// Size: 0xa0
struct FCircusState {
    /* 0x0000 */ FCircusPayroll payroll;
};

// Size: 0xd0
class UClockComponent : public UActorComponent {
    /* 0x00b8 */ USmallHoldComponent* smallHold;
    /* 0x00c0 */ float secondsSinceStart;
    /* 0x00c4 */ float baseTimeSpeed;
    /* 0x00c8 */ float runtimeTimeSpeed;

    bool AdjustDeltaTime(float& deltaTime);
    static UClockComponent* FindClock(UObject* WorldContext);
    static FString FormatPlayTimeFromSeconds(int32_t Seconds);
    static FString FormatTimeFromSeconds(int32_t Seconds);
    float GetPlaytime() const;
    void Init(float newBaseTimeSpeed);
    void MarkFinalPlaytime(FString mapId);
    static float ReadMapPlaytime(UGenericSaveGame* Save, FString mapId);
    void SetTimeSpeed(float Multiplier);
};

// Size: 0x30
struct FClownRow : public FTableRowBase {
    /* 0x0008 */ FName ID;
    /* 0x0010 */ UClass* ActorClass;
    /* 0x0018 */ UStaticMesh* PreviewMesh;
    /* 0x0020 */ UTexture2D* Icon;
    /* 0x0028 */ bool isPrime;
    /* 0x0029 */ bool isDecoration;
};

// Size: 0x368
class AControllablePawn : public APawn {
    /* 0x0328 */ USceneComponent* Root;
    /* 0x0330 */ USceneComponent* focus;
    /* 0x0338 */ bool shouldSnapToGrid;
    /* 0x0339 */ bool canGoThroughBlocks;
    /* 0x033c */ float zoomRatio;
    /* 0x0340 */ float tiltRatio;
    /* 0x0344 */ bool showCursor;
    /* 0x0348 */ FRotator rotationRatio;
    /* 0x0360 */ bool shouldIgnoreReceivedBounces;

    void AlterRotation(FRotator Delta);
    void AlterTilt(float Delta);
    void AlterZoomRatio(float Delta);
    FVector GetFocus() const;
    FRotator GetRotation() const;
    FVector Move(float Delta, FVector Target, float speedRatio);
    void ReceiveBouncedFocus(FVector position);
    void SendBounceFocus(FVector position);
    void SetCanGoThroughBlocks(bool can);
    void SetFocus(FVector position);
    void SetRotation(FRotator rot);
    void SetShouldSnapToGrid(bool should);
    void SetShowCursor(bool isShown);
    void SetTilt(float Tilt);
    void SetZoomRatio(float nZoomRatio);
};

// Size: 0x28
class UCreditsCompute : public UBlueprintFunctionLibrary {

    static FCreditsDetails GetCredits(FString rawCredits);
};

// Size: 0x10
struct FCreditsDetails {
    /* 0x0000 */ TArray<FCreditsLine> lines;
};

// Size: 0x30
struct FCreditsLine {
    /* 0x0000 */ bool isHeader;
    /* 0x0008 */ FString Text;
    /* 0x0018 */ TArray<FString> multiText;
    /* 0x0028 */ bool isSection;
};

// Size: 0x48
struct FCropMasterSyncData : public FTableRowBase {
    /* 0x0008 */ float GrowthPeriodInYears;
    /* 0x000c */ float ConsumptionRemainder;
    /* 0x0010 */ float NutrientSaturation;
    /* 0x0014 */ float NutrientStarvation;
    /* 0x0018 */ float DecayPeriodInYears;
    /* 0x001c */ float NutrientMinimum;
    /* 0x0020 */ float LightTarget;
    /* 0x0024 */ float LightPenalty;
    /* 0x0028 */ float RockPenalty;
    /* 0x002c */ float PollutionPenalty;
    /* 0x0030 */ float MaximumYield;
    /* 0x0034 */ float YieldGrowthThreshold;
    /* 0x0038 */ uint8_t FrostGrowthThreshold;
    /* 0x0039 */ uint8_t FrostRotThreshold;
    /* 0x003c */ FName RequiredUnlock;
};

// Size: 0xc
struct FCropOption {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ bool bUnlocked;
};

// Size: 0x28
struct FCursorDetails {
    /* 0x0000 */ FVector2D moveDrag;
    /* 0x0010 */ float Height;
    /* 0x0014 */ float lagSpeed;
    /* 0x0018 */ UStaticMesh* meshModel;
    /* 0x0020 */ bool hideMesh;
};

// Size: 0x2c0
class ACutsceneBase : public AActor {
    /* 0x02a8 */ FCutsceneConfig config;

    TArray<APlayerController*> FindListeningControllers();
    void FinishCutscene();
    FCutsceneConfig GetConfig() const;
    void ReceiveInput(ENaviUiIntent Key);
    void ReceiveMovement(FVector2D diff);
    void SendInput(ENaviUiIntent Key);
    void SendMovement(FVector2D diff);
    bool WantsExclusiveControl() const;
};

// Size: 0x18
struct FCutsceneConfig {
    /* 0x0000 */ FString Name;
    /* 0x0010 */ bool hasSideeffect;
    /* 0x0011 */ bool canCancel;
    /* 0x0012 */ bool canForward;
    /* 0x0013 */ bool wantExclusiveControl;
    /* 0x0014 */ bool hasPriority;
};

// Size: 0x28
class UCutsceneIssue : public UBlueprintFunctionLibrary {

    static void Spawn(UObject* WorldContext, FString Type, FVector position, FString Payload);
};

// Size: 0x28
class ICutsceneListenerInterface : public UInterface {

    void OnCutsceneEnd(ACutsceneBase* Cutscene);
    void OnCutsceneStart(ACutsceneBase* Cutscene);
};

// Size: 0x10
struct FCutsceneState {
    /* 0x0000 */ bool IsPlaying;
    /* 0x0008 */ APlayerController* Controller;
};

// Size: 0x20
struct FDateAndTime {
};

// Size: 0x208
class UDesireBoardComponent : public UActorComponent {
    /* 0x00b8 */ int32_t nextDesireReportId;
    /* 0x00c0 */ TMap<int32_t, FDesireReport> desiresById;
    /* 0x01b0 */ int32_t nextDesireClaimId;
    /* 0x01b8 */ TMap<int32_t, FDesireClaim> claimsById;
};

// Size: 0x8
struct FDesireCategoryAndSub {
    /* 0x0000 */ EDesireCategory Category;
    /* 0x0004 */ int32_t subCategory;
};

// Size: 0x18
struct FDesireClaim {
    /* 0x0000 */ int32_t claimId;
    /* 0x0004 */ FDesireReportRef reportRef;
    /* 0x0008 */ AActor* claimer;
    /* 0x0010 */ int32_t claimedCapacity;
};

// Size: 0x8
struct FDesireClaimRef {
    /* 0x0000 */ int32_t claimId;
    /* 0x0004 */ FDesireReportRef reportRef;
};

// Size: 0x110
class UDesireClaimerComponent : public UActorComponent {
    /* 0x00b8 */ UDesireBoardComponent* board;
    /* 0x00c0 */ TSet<FDesireClaimRef> activeClaims;
};

// Size: 0x110
class UDesireIssuerComponent : public UActorComponent {
    /* 0x00b8 */ UDesireBoardComponent* board;
    /* 0x00c0 */ TSet<FDesireReportRef> activeReports;
};

// Size: 0x40
struct FDesireReport {
    /* 0x0000 */ AActor* Owner;
    /* 0x0008 */ int32_t ID;
    /* 0x000c */ FDesireReportRef ref;
    /* 0x0010 */ FVector Location;
    /* 0x0028 */ EDesireCategory Category;
    /* 0x002c */ int32_t subCategory;
    /* 0x0030 */ int32_t capacity;
    /* 0x0034 */ int32_t claimed;
    /* 0x0038 */ bool isDepleting;
};

// Size: 0x4
struct FDesireReportRef {
    /* 0x0000 */ int32_t reportId;
};

// Size: 0x160
class UDyehouse : public UActorComponent {
    /* 0x00b8 */ UClass* configMule;
    /* 0x00c0 */ FDyehouseConfig config;
    /* 0x0110 */ FDyehouseState State;

    void ClearDye(UPrimitiveComponent* prim);
    void ReDye(UPrimitiveComponent* prim, FName ruleset);
};

// Size: 0x50
struct FDyehouseConfig {
    /* 0x0000 */ TMap<FName, FDyehouseRuleset> rulesets;
};

// Size: 0x2f8
class ADyehouseConfigMule : public AActor {
    /* 0x02a8 */ FDyehouseConfig config;
};

// Size: 0x50
struct FDyehouseRuleset {
    /* 0x0000 */ TMap<UMaterialInterface*, UMaterialInterface*> dyeMatch;
};

// Size: 0x50
struct FDyehouseState {
    /* 0x0000 */ FDyehouseRuleset resetRulset;
};

enum class EActivityPriority {
    None = 0,
    Notice = 1,
    Optional = 2,
    Important = 3,
    Extreme = 4,
    EActivityPriority_MAX = 5,
};

enum class EBackingLocation {
    PlaySaves = 0,
    Maps = 1,
    CustommMaps = 2,
    EBackingLocation_MAX = 3,
};

enum class EBeltEntryAction {
    Detect = 0,
    Ignore = 1,
    EnterAlways = 2,
    EBeltEntryAction_MAX = 3,
};

enum class EBeltEntryResult {
    Invalid = 0,
    Handled = 1,
    Unhandled = 2,
    EBeltEntryResult_MAX = 3,
};

enum class EBlueBoxStatus {
    None = 0,
    WaitingOnInput = 1,
    Finished = 2,
    InvalidState = 3,
    EBlueBoxStatus_MAX = 4,
};

enum class ECursorState {
    None = 0,
    Explore = 1,
    BuildPreview = 2,
    Idle = 3,
    ECursorState_MAX = 4,
};

enum class EDesireCategory {
    None = 0,
    Pickup = 1,
    DropOff = 2,
    Construct = 3,
    Employment = 4,
    Resident = 5,
    SupplyFood = 6,
    SupplyFuel = 7,
    RestaurantSeating = 8,
    EDesireCategory_MAX = 9,
};

enum class EEase {
    Linear = 0,
    SineIn = 1,
    SineOut = 2,
    SineInOut = 3,
    QuadIn = 4,
    QuadOut = 5,
    QuadInOut = 6,
    CubicIn = 7,
    CubicOut = 8,
    CubicInOut = 9,
    QuartIn = 10,
    QuartOut = 11,
    QuartInOut = 12,
    QuintIn = 13,
    QuintOut = 14,
    QuintInOut = 15,
    ExpoIn = 16,
    ExpoOut = 17,
    ExpoInOut = 18,
    CircIn = 19,
    CircOut = 20,
    CircInOut = 21,
    BackIn = 22,
    BackOut = 23,
    BackInOut = 24,
    ElasticIn = 25,
    ElasticOut = 26,
    ElasticInOut = 27,
    BounceIn = 28,
    BounceOut = 29,
    BounceInOut = 30,
    None = 31,
    EEase_MAX = 32,
};

enum class EFabricPolygonType {
    None = 0,
    Structure = 1,
    Navigation = 2,
    WorkExclusive = 4,
    WorkNonExclusive = 8,
    EFabricPolygonType_MAX = 9,
};

enum class EFarmCropMeshDivision {
    OneByOne = 0,
    TwoByTwo = 1,
    FourByFour = 2,
    EFarmCropMeshDivision_MAX = 3,
};

enum class EGridCellType {
    Open = 0,
    Block = 1,
    Road = 2,
    Water = 3,
    Shore = 4,
    Track = 5,
    Catchement = 6,
    Catchement_IN = 7,
    Catchement_OUT = 8,
    ForestNode = 9,
    WaterNode = 10,
    OilNode = 11,
    IronNode = 12,
    CopperNode = 13,
    CoalNode = 14,
    LimestoneNode = 15,
    Ocean = 16,
    EGridCellType_MAX = 17,
};

enum class EGuideInput {
    None = 0,
    Movement = 1,
    Accept = 2,
    Cancel = 3,
    SpecialUp = 4,
    SpecialLeft = 5,
    Hotkey1 = 6,
    Hotkey2 = 7,
    Hotkey3 = 8,
    Hotkey4 = 9,
    Menu = 10,
    Rotate = 11,
    Raise = 12,
    Lower = 13,
    Undo = 14,
    Hotkey5 = 15,
    RailToggle = 16,
    Up = 17,
    Right = 18,
    Down = 19,
    Left = 20,
    UI_Special1 = 21,
    EGuideInput_MAX = 22,
};

enum class EGuidePremade {
    None = 0,
    AcceptReject = 1,
    Accept = 2,
    MoveGo = 3,
    MoveAcceptBack = 4,
    MoveAcceptClose = 5,
    Theater = 6,
    MainMenu = 7,
    MoveAccept = 8,
    Back = 9,
    BackAccept = 10,
    BackGo = 11,
    Cancel = 12,
    CancelAccept = 13,
    Close = 14,
    TrainControls = 15,
    TrainControlsCam = 16,
    EGuidePremade_MAX = 17,
};

enum class EGuideVerb {
    None = 0,
    Movement = 1,
    Accept = 2,
    Go = 3,
    Okay = 4,
    Cancel = 5,
    Back = 6,
    No = 7,
    Reject = 8,
    Build = 9,
    Buy = 10,
    Destroy = 11,
    Skip = 12,
    Close = 13,
    Pause = 14,
    Terraform = 15,
    Mark = 16,
    Raise = 17,
    Lower = 18,
    Rotate = 19,
    Finish = 20,
    Undo = 21,
    TrainView = 22,
    Sell = 23,
    Configure = 24,
    Reverse = 25,
    Cliffform = 26,
    Clone = 27,
    ShowAllCargo = 28,
    ShowRouteCargo = 29,
    ShowCargoInputs = 30,
    ShowCargoOutputs = 31,
    TrainViewCycle = 32,
    TrainViewHideUi = 33,
    Flip = 34,
    Shop = 35,
    Continue = 36,
    Rail_AutoHeight = 37,
    Rail_ManualHeight = 38,
    Toggle_Grid = 39,
    Investigate = 40,
    Resources = 41,
    EGuideVerb_MAX = 42,
};

enum class EHeatRecipientState {
    Hot = 0,
    Warm = 1,
    Chilly = 2,
    Cold = 3,
    Freezing = 4,
    EHeatRecipientState_MAX = 5,
};

enum class EHexDir {
    UpUp = 0,
    RightUp = 1,
    RightDown = 2,
    DownDown = 3,
    LeftDown = 4,
    LeftUp = 5,
    EHexDir_MAX = 6,
};

enum class EIconGroup {
    None = 0,
    Key = 1,
    Cargo = 2,
    Engine = 3,
    Controls = 4,
    Building = 5,
    Upgrade = 6,
    Pop = 7,
    Music = 8,
    Ranks = 9,
    Resource = 10,
    BItem = 11,
    BUnit = 12,
    BMarker = 13,
    Nautical = 14,
    EIconGroup_MAX = 15,
};

enum class EInputIconButton {
    None = 0,
    Start = 1,
    Select = 2,
    Face_Up = 3,
    Face_Right = 4,
    Face_Down = 5,
    Face_Left = 6,
    DPad = 7,
    DPad_Up = 8,
    DPad_Right = 9,
    DPad_Down = 10,
    DPad_Left = 11,
    Trigger_Right = 12,
    Trigger_Left = 13,
    Shoulder_Right = 14,
    Shoulder_Left = 15,
    Analog_Right = 16,
    Analog_Left = 17,
    AnalogPress_Right = 18,
    AnalogPress_Left = 19,
    Mouse_LeftClick = 20,
    Mouse_RightClick = 21,
    Mouse_MiddleClick = 22,
    Mouse_Mouse4 = 23,
    Mouse_Mouse5 = 24,
    Key_Space = 25,
    Key_Enter = 26,
    Key_Esc = 27,
    Key_Backspace = 28,
    Key_Tab = 29,
    Key_Capslock = 30,
    Key_Pageup = 31,
    Key_Pagedown = 32,
    Key_End = 33,
    Key_Home = 34,
    Key_Left = 35,
    Key_Up = 36,
    Key_Right = 37,
    Key_Down = 38,
    Key_Insert = 39,
    Key_Delete = 40,
    Key_Zero = 41,
    Key_One = 42,
    Key_Two = 43,
    Key_Three = 44,
    Key_Four = 45,
    Key_Five = 46,
    Key_Six = 47,
    Key_Seven = 48,
    Key_Eight = 49,
    Key_Nine = 50,
    Key_A = 51,
    Key_B = 52,
    Key_C = 53,
    Key_D = 54,
    Key_E = 55,
    Key_F = 56,
    Key_G = 57,
    Key_H = 58,
    Key_I = 59,
    Key_J = 60,
    Key_K = 61,
    Key_L = 62,
    Key_M = 63,
    Key_N = 64,
    Key_O = 65,
    Key_P = 66,
    Key_Q = 67,
    Key_R = 68,
    Key_S = 69,
    Key_T = 70,
    Key_U = 71,
    Key_V = 72,
    Key_W = 73,
    Key_X = 74,
    Key_Y = 75,
    Key_Z = 76,
    Key_WASD_ARROW_GENERIC = 77,
    Key_Semicolon = 78,
    Key_period = 79,
    Key_add = 80,
    Key_subtract = 81,
    Key_leftShift = 82,
    Key_RightShift = 83,
    Key_hyphen = 84,
    Key_equals = 85,
    Key_decimal = 86,
    Key_divide = 87,
    Key_exclamation = 88,
    Key_dollar = 89,
    Key_caret = 90,
    Key_ampersand = 91,
    Key_leftParen = 92,
    Key_rightParen = 93,
    Key_underscore = 94,
    Key_section = 95,
    Key_a_accentGrave = 96,
    Key_e_accentGrave = 97,
    Key_e_accentAigu = 98,
    Key_c_cedile = 99,
    Key_leftAlt = 100,
    Key_rightAlt = 101,
    Key_multiply = 102,
    Key_leftBracket = 103,
    Key_rightBracket = 104,
    Key_tilde = 105,
    Key_backslash = 106,
    Key_comma = 107,
    Key_slash = 108,
    Key_f1 = 109,
    Key_f2 = 110,
    Key_f3 = 111,
    Key_f4 = 112,
    Key_f5 = 113,
    Key_f6 = 114,
    Key_f7 = 115,
    Key_f8 = 116,
    Key_f9 = 117,
    Key_f10 = 118,
    Key_f11 = 119,
    Key_f12 = 120,
    Key_numpad1 = 121,
    Key_numpad2 = 122,
    Key_numpad3 = 123,
    Key_numpad4 = 124,
    Key_numpad5 = 125,
    Key_numpad6 = 126,
    Key_numpad7 = 127,
    Key_numpad8 = 128,
    Key_numpad9 = 129,
    Key_LeftCtrl = 130,
    Key_RightCtrl = 131,
    EInputIconButton_MAX = 132,
};

enum class EInteractionType {
    None = 0,
    Pickup = 1,
    Drop = 2,
    Use = 3,
    EInteractionType_MAX = 4,
};

enum class EInteractionVerb {
    Waiting = 0,
    Pickingup = 1,
    Droping = 2,
    Using = 3,
    Fishing = 4,
    Working = 5,
    Labouring = 6,
    Watering = 7,
    Constructing = 8,
    EInteractionVerb_MAX = 9,
};

enum class EMapType {
    Custom = 0,
    Campaign = 1,
    Challenge = 2,
    Developer = 3,
    Sandbox = 4,
    EMapType_MAX = 5,
};

enum class EMasterSyncRequestStatus {
    None = 0,
    Waiting = 1,
    Done = 2,
    EMasterSyncRequestStatus_MAX = 3,
};

enum class EMetaMetricOp {
    Equal = 0,
    Greater = 1,
    Lesser = 2,
    GreaterEqual = 3,
    LesserEqual = 4,
    EMetaMetricOp_MAX = 5,
};

enum class ENaviFormType {
    None = 0,
    Header = 1,
    SubHeader = 2,
    Text = 3,
    Selector = 4,
    InputOneLine = 5,
    InputNumerical = 6,
    Save = 7,
    Cancel = 8,
    EnumSelector = 9,
    ENaviFormType_MAX = 10,
};

enum class ENaviGridAttribute {
    None = 0,
    StealFocus = 1,
    ENaviGridAttribute_MAX = 2,
};

enum class ENaviHandleMethod {
    PassToChild = 0,
    StopNow = 1,
    ENaviHandleMethod_MAX = 2,
};

enum class ENaviResultHandleMethod {
    PassToParent = 0,
    StopNow = 1,
    ENaviResultHandleMethod_MAX = 2,
};

enum class ENaviUiHighlightStyle {
    Square = 0,
    Circle = 1,
    Diamond = 2,
    ENaviUiHighlightStyle_MAX = 3,
};

enum class ENaviUiIntent {
    None = 0,
    Accept = 1,
    Back = 2,
    Up = 3,
    Right = 4,
    Down = 5,
    Left = 6,
    SpecialUp = 7,
    SpecialDown = 8,
    SpecialRight = 9,
    SpecialLeft = 10,
    FaceLeft = 11,
    FaceTop = 12,
    ENaviUiIntent_MAX = 13,
};

enum class ENotificationPriority {
    Low = 0,
    Medium = 1,
    High = 2,
    Urgent = 3,
    ENotificationPriority_MAX = 4,
};

enum class EOceanPlaneResult {
    EmptyMesh = 0,
    PartialMesh = 1,
    FullMesh = 2,
    EOceanPlaneResult_MAX = 3,
};

enum class EPixelFedBackendId {
    Invalid = 0,
    NoAA = 1,
    FXAA = 2,
    TAA = 3,
    TSR = 4,
    DLSS = 5,
    FSR = 6,
    XeSS = 7,
    Switch2 = 8,
    EPixelFedBackendId_MAX = 9,
};

enum class EPollutionUpdate {
    None = 0,
    Zero = 1,
    Full = 2,
    Skip = 3,
    EPollutionUpdate_MAX = 4,
};

enum class EPopGroup {
    None = 0,
    Profit = 1,
    Cost = 2,
    Warning = 3,
    Message = 4,
    Salvage = 5,
    Upkeep = 6,
    Bark = 7,
    CityGrowth = 8,
    EPopGroup_MAX = 9,
};

enum class EPropSpawnType {
    Box = 0,
    Point = 1,
    EPropSpawnType_MAX = 2,
};

enum class EQuestConditionRule {
    None = 0,
    ProductionRate = 1,
    CityLevel = 2,
    TotalProduced = 3,
    TotalUsed = 4,
    PercentComplete = 5,
    AverageExport = 6,
    AverageProduction = 7,
    TotalExport = 8,
    EQuestConditionRule_MAX = 9,
};

enum class EQuestProblemSeverity {
    None = 0,
    Error = 1,
    Warning = 2,
    EQuestProblemSeverity_MAX = 3,
};

enum class EQuestStage {
    None = 0,
    Start = 1,
    Stage1 = 2,
    Stage2 = 3,
    Stage3 = 4,
    Stage4 = 5,
    Stage5 = 6,
    Stage6 = 7,
    Stage7 = 8,
    Stage8 = 9,
    Stage9 = 10,
    Victory = 11,
    EQuestStage_MAX = 12,
};

enum class EQuestStatusUnit {
    None = 0,
    Percentage = 1,
    Rate = 2,
    Level = 3,
    EQuestStatusUnit_MAX = 4,
};

enum class EResultRank {
    None = 0,
    RankC = 1,
    RankB = 2,
    RankA = 3,
    RankS = 4,
    EResultRank_MAX = 5,
};

enum class ESteamWorkshopDownloadStatus {
    NOT_DOWNLOADED = 0,
    DOWNLOADED_NEEDS_COPIED = 1,
    DOWNLOADED_READY = 2,
    ESteamWorkshopDownloadStatus_MAX = 3,
};

enum class EStoryOps {
    None = 0,
    Theater = 1,
    Region = 2,
    Cutscene = 3,
    StartMenu = 4,
    Credits = 5,
    Overworld = 6,
    DemoEnd = 7,
    Give = 8,
    Stage = 9,
    Storyworld = 10,
    EStoryOps_MAX = 11,
};

enum class EStorySlot {
    Campaign = 0,
    Demo = 1,
    Press = 2,
    Scenario = 3,
    Story = 4,
    EStorySlot_MAX = 5,
};

enum class ETerrainBlockage {
    XbbYbbZbb = 0,
    XbbYbbZbo = 2,
    XbbYbbZob = 1,
    XbbYbbZoo = 3,
    XbbYboZbb = 8,
    XbbYboZbo = 10,
    XbbYboZob = 9,
    XbbYboZoo = 11,
    XbbYobZbb = 4,
    XbbYobZbo = 6,
    XbbYobZob = 5,
    XbbYobZoo = 7,
    XbbYooZbb = 12,
    XbbYooZbo = 14,
    XbbYooZob = 13,
    XbbYooZoo = 15,
    XboYbbZbb = 32,
    XboYbbZbo = 34,
    XboYbbZob = 33,
    XboYbbZoo = 35,
    XboYboZbb = 40,
    XboYboZbo = 42,
    XboYboZob = 41,
    XboYboZoo = 43,
    XboYobZbb = 36,
    XboYobZbo = 38,
    XboYobZob = 37,
    XboYobZoo = 39,
    XboYooZbb = 44,
    XboYooZbo = 46,
    XboYooZob = 45,
    XboYooZoo = 47,
    XobYbbZbb = 16,
    XobYbbZbo = 18,
    XobYbbZob = 17,
    XobYbbZoo = 19,
    XobYboZbb = 24,
    XobYboZbo = 26,
    XobYboZob = 25,
    XobYboZoo = 27,
    XobYobZbb = 20,
    XobYobZbo = 22,
    XobYobZob = 21,
    XobYobZoo = 23,
    XobYooZbb = 28,
    XobYooZbo = 30,
    XobYooZob = 29,
    XobYooZoo = 31,
    XooYbbZbb = 48,
    XooYbbZbo = 50,
    XooYbbZob = 49,
    XooYbbZoo = 51,
    XooYboZbb = 56,
    XooYboZbo = 58,
    XooYboZob = 57,
    XooYboZoo = 59,
    XooYobZbb = 52,
    XooYobZbo = 54,
    XooYobZob = 53,
    XooYobZoo = 55,
    XooYooZbb = 60,
    XooYooZbo = 62,
    XooYooZob = 61,
    XooYooZoo = 63,
    ETerrainBlockage_MAX = 64,
};

enum class ETerrainFarmCellCropState {
    Nothing = 0,
    Growing = 64,
    Harvested = 128,
    Rotten = 192,
    ETerrainFarmCellCropState_MAX = 193,
};

enum class ETerrainFarmFieldPhase {
    Sowing = 0,
    Growing = 1,
    Harvesting = 2,
    ETerrainFarmFieldPhase_MAX = 3,
};

enum class ETerrainFlag {
    Surveyed = 128,
    Tilled = 64,
    Solid = 32,
    Terraformed = 16,
    WasBlocked = 8,
    ETerrainFlag_MAX = 129,
};

enum class ETerrainGeneratorIslandGeology {
    Main = 0,
    Atoll = 1,
    Crater = 2,
    Spike = 3,
    Cliff = 4,
    Hill = 5,
    Flat = 6,
    Sandbank = 7,
    ETerrainGeneratorIslandGeology_MAX = 8,
};

enum class ETerrainGeneratorIslandSurface {
    Noise = 0,
    Green = 1,
    Meadow = 2,
    Forest = 3,
    Barren = 4,
    ETerrainGeneratorIslandSurface_MAX = 5,
};

enum class ETerrainGeneratorOreFactor {
    Major = 0,
    Minor = 1,
    ETerrainGeneratorOreFactor_MAX = 2,
};

enum class ETerrainMetaDataType {
    Tilled = 0,
    Nutrients = 1,
    Rocks = 2,
    Terraformed = 3,
    Ore = 4,
    Heat = 5,
    Light = 6,
    Decay = 7,
    Pollution = 8,
    Surface = 9,
    WaterHeight = 10,
    WaterRemoval = 11,
    OceanWaves = 12,
    Navigation = 13,
    ETerrainMetaDataType_MAX = 14,
};

enum class ETerrainNavigationAccessibility {
    Accessible = 0,
    Enclosed = 1,
    Blocked = 2,
    Blocking = 3,
    ETerrainNavigationAccessibility_MAX = 4,
};

enum class ETerrainRayCastResult {
    None = 0,
    Vegetation = 1,
    Terrain = 2,
    VegetationAndTerrain = 3,
    ETerrainRayCastResult_MAX = 4,
};

enum class ETerrainSliceState {
    BelowSlice = 0,
    CurrentSlice = 1,
    AboveSlice = 2,
    ETerrainSliceState_MAX = 3,
};

enum class ETerrainSubtype {
    None = 0,
    Wood = 1,
    Berries = 2,
    Dummy = 3,
    Flax = 4,
    Blocker = 5,
    Collider = 6,
    Dummy2 = 7,
    ETerrainSubtype_MAX = 8,
};

enum class ETheaterStyle {
    Normal = 0,
    Rushed = 1,
    Precise = 2,
    ETheaterStyle_MAX = 3,
};

enum class ETiledBlockTerrainPlantRotation {
    Fixed = 0,
    Free = 1,
    Linked = 2,
    ETiledBlockTerrainPlantRotation_MAX = 3,
};

enum class ETooltipStyle {
    Normal = 0,
    Cursive = 1,
    Bold = 2,
    ETooltipStyle_MAX = 3,
};

enum class EUnlockCategory {
    AlwaysUnlocked = 0,
    Cheap = 1,
    Normal = 2,
    Expensive = 3,
    EUnlockCategory_MAX = 4,
};

enum class EUnlockScope {
    None = 0,
    Local = 1,
    Region = 2,
    Globe = 3,
    EUnlockScope_MAX = 4,
};

enum class EUnlockTreeAttributes {
    None = 0,
    CanBuy = 1,
    CanNegotiate = 2,
    IsHidden = 3,
    EUnlockTreeAttributes_MAX = 4,
};

enum class EUnlockTreeLockStatus {
    None = 0,
    Locked = 1,
    GlobalUnlocked = 2,
    LocalUnlocked = 3,
    BeingUnlocked = 4,
    EUnlockTreeLockStatus_MAX = 5,
};

enum class EVolumeRatio {
    None = 0,
    Half = 1,
    Full = 2,
    EVolumeRatio_MAX = 3,
};

enum class EWarehouseLocation {
    Prime = 0,
    Save = 1,
    Custom = 2,
    EWarehouseLocation_MAX = 3,
};

enum class EWeatherSpawnBehaviour {
    OnceAtOffset = 0,
    EWeatherSpawnBehaviour_MAX = 1,
};

enum class EWeatherType {
    Normal = 0,
    Rain = 1,
    Snow = 2,
    BrightSun = 3,
    HighWind = 4,
    HeavyFog = 5,
    EWeatherType_MAX = 6,
};

// Size: 0x28
class UEaseCurve : public UBlueprintFunctionLibrary {

    static float Ease(EEase variety, float progress);
};

// Size: 0x10
struct FElectionState {
    /* 0x0000 */ TArray<FElectionStateSubEntry> Entries;
};

// Size: 0x48
struct FElectionStateSubEntry {
    /* 0x0000 */ FName Mode;
    /* 0x0008 */ FName stringId;
    /* 0x0010 */ bool IsEnabled;
    /* 0x0014 */ FName Key;
    /* 0x001c */ FName Payload;
    /* 0x0028 */ TArray<FName> multiStringIds;
    /* 0x0038 */ TArray<FName> multiPayloads;
};

// Size: 0x170
class UFabric : public UActorComponent {
    /* 0x00b8 */ double MaxMargin;
};

// Size: 0x118
struct FFabricPatch {
    /* 0x0000 */ FPolygon ColliderArea;
    /* 0x0058 */ FPolygon ExpansionArea;
    /* 0x00b0 */ float MaximumExpansion;
    /* 0x00b8 */ FPolygon CurrentArea;
};

// Size: 0x360
class UFabricPatchComponent : public USceneComponent {
    /* 0x0240 */ FFabricPatch FabricPatch;
};

// Size: 0x2d0
class UFabricPolygonComponent : public USceneComponent {
    /* 0x0240 */ FPolygon Polygon;
    /* 0x0298 */ bool bEditable;
    /* 0x0299 */ EFabricPolygonType Type;
    /* 0x02a0 */ TArray<EFabricPolygonType> CollisionProfile;
    /* 0x02b0 */ TArray<EFabricPolygonType> SubtractionProfile;
    /* 0x02c0 */ double SubtractionMargin;
};

// Size: 0x50
struct FFabricState {
    /* 0x0000 */ TMap<FName, FPolygonData> Polygons;
};

// Size: 0xb0
struct FFarmCrop {
    /* 0x0000 */ FName Name;
    /* 0x0048 */ TArray<FFarmCropMesh> Meshes;
    /* 0x0058 */ UStaticMesh* GrowingMesh;
    /* 0x0060 */ UStaticMesh* HarvestedMesh;
    /* 0x0068 */ UStaticMesh* RottenMesh;
    /* 0x0070 */ FVector MinScale;
    /* 0x0088 */ FVector MaxScale;
    /* 0x00a0 */ float MinHeightOffset;
    /* 0x00a4 */ float MaxHeightOffset;
    /* 0x00a8 */ EFarmCropMeshDivision MeshDivision;
};

// Size: 0x40
struct FFarmCropConfig {
    /* 0x0000 */ TArray<FFarmCrop> Crops;
    /* 0x0010 */ float YearsForFullNutrientRecovery;
    /* 0x0014 */ float RecoverySlowdownDuringGrowth;
    /* 0x0018 */ float MaxRecoveryTemperature;
    /* 0x001c */ float MinRecoveryTemperature;
    /* 0x0020 */ float StarvationRotCheckInterval;
    /* 0x0024 */ float FrostRotTemperatureDifference;
    /* 0x0028 */ float FrostRotCheckInterval;
    /* 0x002c */ float FrostGrowthTemperatureDifference;
    /* 0x0030 */ int32_t SowingTemperatureDifference;
    /* 0x0038 */ UDataTable* MasterSyncData;
};

// Size: 0x68
class UFarmCropConfigMule : public UObject {
    /* 0x0028 */ FFarmCropConfig config;
};

// Size: 0x48
struct FFarmCropMesh {
    /* 0x0000 */ float MaxGrowth;
    /* 0x0008 */ UStaticMesh* Mesh;
    /* 0x0010 */ FVector MinScale;
    /* 0x0028 */ FVector MaxScale;
    /* 0x0040 */ float MinHeightOffset;
    /* 0x0044 */ float MaxHeightOffset;
};

// Size: 0x180
class UFlavourBox : public UActorComponent {
    /* 0x00b8 */ FFlavourConfig config;
    /* 0x0160 */ FVector2D timingRange;
    /* 0x0170 */ float heightOffset;
    /* 0x0174 */ float waitingTime;
    /* 0x0178 */ FName CurrentState;

    void InstantBark();
};

// Size: 0xa8
struct FFlavourConfig {
    /* 0x0000 */ FName barkGroup;
    /* 0x0008 */ TMap<FName, FName> stateBarkGroups;
    /* 0x0058 */ TMap<FName, FName> eventBarkGroups;
};

// Size: 0x340
class AFogOfWar : public AActor {
    /* 0x0300 */ double Extent;
    /* 0x0308 */ double AngleResolution;
    /* 0x0310 */ double BorderThickness;
    /* 0x0318 */ double BorderVisibilityFraction;
    /* 0x0320 */ double MeshHeight;
    /* 0x0328 */ UMaterialInstance* Material;
    /* 0x0330 */ UProceduralMeshComponent* Mesh;
};

// Size: 0x2e0
class AFootprintMaker : public AActor {
    /* 0x02a8 */ FGridArea madeArea;
    /* 0x02c0 */ bool xBiasPositive;
    /* 0x02c1 */ bool yBiasPositive;
    /* 0x02c4 */ FIntVector addSize;
    /* 0x02d0 */ FIntVector addOffset;
    /* 0x02dc */ EGridCellType addType;

    void AddSizedCells();
    void AddSurroundingCatchment();
    void ClearAll();
};

// Size: 0x1f0
class UGenericSaveGame : public USaveGame {
    /* 0x0028 */ uint32_t UserIndex;
    /* 0x0030 */ FString SaveSlotName;
    /* 0x0040 */ FMulticastInlineDelegate uponSaveOccured;
    /* 0x0050 */ TMap<FString, FString> dbStrings;
    /* 0x00a0 */ TMap<FString, int32_t> dbNumbers;
    /* 0x00f0 */ FUnlockLayer UnlockLayer;
    /* 0x0140 */ FMetaMetricStorageScope achievementHistoryScope;

    void CheckSaveTimeout(float Delta);
    void ClearAllWithPrefix(FString Prefix);
    void ClearNumber(FString Key);
    void ClearString(FString Key);
    float GetNumber(FString Key) const;
    FString GetString(FString Key) const;
    void GiveUnlock(FName unlockId);
    bool HasNumber(FString Key) const;
    bool HasString(FString Key) const;
    bool HasUnlock(FName unlockId) const;
    TArray<FName> ListUnlocks() const;
    void MarkAsNeverSaveable();
    void RemoveUnlock(FName unlockId);
    void Save();
    void SaveSkipSafety();
    void SetNumber(FString Key, float Value);
    void SetString(FString Key, FString Value);
};

// Size: 0xe0
class UGlobe : public UObject {
    /* 0x0028 */ FGlobeState State;
    /* 0x00d8 */ FGlobeConfig config;

    FMissionStatus ComputeMissionStatus(FString mapId, float Seconds) const;
    FGlobeMapInfo GetMapInfo(FString mapId) const;
    int32_t GetParTimeMinutes(FString mapId) const;
    TArray<FString> ListAllMapIds() const;
    TArray<FString> ListMapIdsByType(EMapType Type) const;
};

// Size: 0x8
struct FGlobeConfig {
    /* 0x0000 */ UDataTable* mapMetaTable;
};

// Size: 0x2b0
class AGlobeConfigMule : public AActor {
    /* 0x02a8 */ FGlobeConfig config;
};

// Size: 0x10
struct FGlobeMapIds {
    /* 0x0000 */ TArray<FString> mapIds;
};

// Size: 0x68
struct FGlobeMapInfo {
    /* 0x0000 */ FString mapId;
    /* 0x0010 */ FString titleKeyId;
    /* 0x0020 */ FString descKeyId;
    /* 0x0030 */ FString minimap;
    /* 0x0040 */ int32_t parTimeMinutes;
    /* 0x0048 */ FVector2D Size;
    /* 0x0058 */ int32_t startBank;
    /* 0x005c */ EMapType mapType;
    /* 0x005d */ bool requiresUnlock;
    /* 0x0060 */ FName unlockId;
};

// Size: 0x58
struct FGlobeMapMetaRow : public FTableRowBase {
    /* 0x0008 */ FString Name;
    /* 0x0018 */ float parTime;
    /* 0x0020 */ FString Category;
    /* 0x0030 */ FString biome;
    /* 0x0040 */ FString missionTag;
    /* 0x0050 */ FName RequiredUnlock;
};

// Size: 0x28
class UGlobeMinimap : public UBlueprintFunctionLibrary {

    static FString GenerateMinimap(const FMapDataHolding& Data);
    static FString MinimapSeperator();
};

// Size: 0xb0
struct FGlobeState {
    /* 0x0000 */ FGlobeMapIds allMapIds;
    /* 0x0010 */ TMap<EMapType, FGlobeMapIds> mapIdsByType;
    /* 0x0060 */ TMap<FString, FGlobeMapInfo> infos;
};

// Size: 0x18
struct FGridArea {
    /* 0x0000 */ int32_t Height;
    /* 0x0008 */ TArray<FGridPoint> Offsets;
};

// Size: 0x8
struct FGridCell {
    /* 0x0000 */ EGridCellType Type;
    /* 0x0001 */ bool IsClaimed;
    /* 0x0004 */ int32_t landClaimIndex;
};

// Size: 0x100
class UGridFeelComponent : public UActorComponent {
    /* 0x00b8 */ FGridFeelConfig config;
    /* 0x00e0 */ FGridFeelState State;

    FGridFeelConfig GetConfig() const;
    static FVector IncrementMovement(const FGridFeelConfig& C, FGridFeelState& S, float TimeDelta, FVector Directions);
    void ProcessMovement(float TimeDelta, FVector Directions);
};

// Size: 0x28
struct FGridFeelConfig {
    /* 0x0000 */ FGridFeelTuning tuning;
    /* 0x0008 */ bool is3d;
    /* 0x0009 */ bool normalizeDirections;
    /* 0x0010 */ FVector CellSize;
};

// Size: 0x20
struct FGridFeelState {
    /* 0x0000 */ FVector lastFrameInput;
    /* 0x0018 */ float cooldown;
};

// Size: 0x8
struct FGridFeelTuning {
    /* 0x0000 */ float waitFromStart;
    /* 0x0004 */ float waitBetweenContinue;
};

// Size: 0x48
struct FGridLand {
    /* 0x0000 */ FGridArea Area;
    /* 0x0018 */ FRotator Rotation;
    /* 0x0030 */ FVector2D position;
    /* 0x0040 */ AActor* claimer;
};

// Size: 0x28
class UGridMath : public UBlueprintFunctionLibrary {

    static FVector CenterInGrid(FVector Location);
    static FVector FromInt(const FIntVector position);
    static FVector GetGridCenter(FVector2D Location);
    static FVector GetGridTop(FVector2D Location);
    static FVector GetScale();
    static FVector2D RotatePosition(FVector2D position, FRotator rot);
    static FRotator SnapRotationToGrid(FRotator rot);
    static FVector2D To2d(const FIntVector position);
    static FIntVector To3d(const FVector2D position);
    static FVector2D ToGridFromLandOffset(const FGridLand& land, const FVector2D& Offset);
    static FVector2D ToGridPosition(FVector Location);
    static FIntVector ToInt(const FVector position);
    static FVector TopInGrid(FVector Location);
    static float TravelDistance(FVector B, FVector A);
};

// Size: 0xc8
class UGridNavigation : public UActorComponent {

    FNavigationPlan PlanWalk(FVector Start, FVector destination) const;
};

// Size: 0x18
struct FGridPoint {
    /* 0x0000 */ FVector2D Offset;
    /* 0x0010 */ EGridCellType Type;
};

// Size: 0x1b8
class UGridSpace : public UActorComponent {
    /* 0x00b8 */ TMap<FVector2D, FGridCell> Cells;
    /* 0x0108 */ TMap<FVector2D, EGridCellType> naturalCellTypes;
    /* 0x0158 */ TMap<int32_t, FGridLand> activeLandClaims;
    /* 0x01a8 */ int32_t precacheRadius;
    /* 0x01ac */ int32_t nextLandClaimIndx;
    /* 0x01b0 */ UGridNavigation* gridNavi;

    bool CanFit(FGridLand land) const;
    bool Claim(FGridLand land);
    EGridCellType GetCellType(FVector2D position) const;
    FGridLand GetLandClaim(FVector2D position) const;
    UGridNavigation* GetNavigation() const;
    void InitNaturalCache();
    bool IsAllClaimed(FGridLand land) const;
    bool IsClaimableType(EGridCellType Type) const;
    bool IsClaimed(FVector2D position) const;
    bool ReleaseClaim(FGridLand land);
    EGridCellType SampleNautralCellType(FVector2D position) const;
};

// Size: 0x28
class UGroundRadar : public UBlueprintFunctionLibrary {

    static FVector FindGround(const UObject* WorldContext, const FVector& position);
    static bool FindGroundFromCamera(const UObject* WorldContext, FVector& worldPos, const FVector& worldDir);
    static FVector FindGroundFromCell(const UObject* WorldContext, const FIntVector& cell);
    static bool InternalFindGround(const UWorld* World, FVector& position, FVector& Normal, const FVector& worldDir);
    static uint8_t InternalSamplePhysics(const UWorld* World, FVector position);
    static uint8_t SamplePhysicsMaterial(const UObject* WorldContext, FVector position);
};

// Size: 0x18
struct FGuideEntry {
    /* 0x0000 */ EGuideInput Input;
    /* 0x0001 */ EGuideVerb verb;
    /* 0x0008 */ FString customVerb;
};

// Size: 0x260
class UGuideSpatialComponent : public USceneComponent {
    /* 0x0240 */ FGuideView shownView;
    /* 0x0250 */ UWidgetComponent* widgetParent;

    void InitWidget();
    void SetShowDisplay(bool doShow);
    void SetView(FGuideView nv);
    void UpdateDisplay(FGuideView nv);
};

// Size: 0x28
class UGuideTracker : public UBlueprintFunctionLibrary {

    static void AppendVerbDefault(FGuideView& View, EGuideVerb verb);
    static void Enable(UObject* WorldContext, bool Enable);
    static EGuideInput FindVerbDefault(EGuideVerb verb);
    static UGuideWidget* FindWidget(UObject* WorldContext);
    static FGuideView Gen(TArray<EGuideVerb> verbs);
    static FGuideView GenPremade(EGuidePremade P);
    static UGuideWidget* GetWidget(UObject* WorldContext);
    static void Hide(UObject* WorldContext);
    static FName LocKeyFromVerb(EGuideVerb verb);
    static UGuideWidget* MakeWidget(UObject* WorldContext);
    static void Show(UObject* WorldContext, FGuideView View);
    static void ShowFading(UObject* WorldContext, FGuideView View);
    static void ShowPremade(UObject* WorldContext, EGuidePremade P);
};

// Size: 0x10
struct FGuideView {
    /* 0x0000 */ TArray<FGuideEntry> Entries;
};

// Size: 0x350
class UGuideWidget : public UUserWidget {
    /* 0x0340 */ FGuideView View;

    void DisplayView(FGuideView newView);
    void SetShow(bool isShow, bool doAnimate);
    void SetView(FGuideView newView);
};

// Size: 0x2e8
class AHeatConfigurator : public AActor {
    /* 0x02a8 */ float TotalHeatPower;
    /* 0x02ac */ float HeatLevelPower;
    /* 0x02b0 */ float HeatLossPerDistanceMultiplier;
    /* 0x02b4 */ float HeatLossPerDistancePower;
    /* 0x02b8 */ float RangeMultiplier;
    /* 0x02bc */ float CenterHeatMultiplier;
    /* 0x02c0 */ float BodyHeatLossSpeed;
    /* 0x02c4 */ float BodyHeatGainSpeed;
    /* 0x02c8 */ float BodyHeatColdZoneWidth;
    /* 0x02cc */ float BodyHeatChillyZoneWidth;
    /* 0x02d0 */ float BodyHeatWarmZoneWidth;
    /* 0x02d4 */ float BodyHeatHotZoneWidth;
    /* 0x02d8 */ float FrostbiteChanceMultiplier;
    /* 0x02dc */ float FrostbiteChancePower;
    /* 0x02e0 */ float FreezingMinDelay;
    /* 0x02e4 */ float FreezingMaxDelay;
};

// Size: 0x100
class UHeatInsulatorComponent : public UActorComponent {
    /* 0x00b8 */ TArray<FIntVector> footprint;
    /* 0x00c8 */ float InsulationFactor;
};

// Size: 0xf8
class UHeatRecipientComponent : public UActorComponent {
    /* 0x00c8 */ float Insulation;
    /* 0x00cc */ float CurrentBodyHeat;
    /* 0x00d0 */ bool bIsFreezing;
    /* 0x00d1 */ bool bHasFrostbite;
    /* 0x00d4 */ float FreezingBuffer;
    /* 0x00d8 */ float FrostbiteCheckTimer;
    /* 0x00e0 */ FVector position;
};

// Size: 0x158
class UHeatSourceComponent : public UActorComponent {
    /* 0x00b8 */ TArray<FIntVector> footprint;
    /* 0x00c8 */ uint8_t CenterHeat;
    /* 0x00cc */ float RangeMultiplier;
    /* 0x00d0 */ bool PreviewHeat;
    /* 0x00d4 */ int32_t CurrentLevel;
    /* 0x00d8 */ bool bActive;
    /* 0x00e0 */ UHeatSystem* HeatSystem;
};

// Size: 0x210
class UHeatSystem : public UActorComponent {
    /* 0x00b8 */ FHeatSystemConfig config;
    /* 0x00e0 */ uint32_t GlobalHeatSeed;
    /* 0x00e4 */ uint8_t GlobalHeat;
    /* 0x00f0 */ TMap<FIntVector, FHeatSystemTracker> Tracker;
    /* 0x0140 */ TArray<UHeatSourceComponent*> HeatSources;
    /* 0x0160 */ TArray<UHeatInsulatorComponent*> HeatInsulators;
    /* 0x0180 */ TArray<UHeatRecipientComponent*> HeatRecipients;
    /* 0x01e4 */ int32_t MinimumTemperature;
    /* 0x01e8 */ int32_t HeatPerDegreeCelsius;
    /* 0x01ec */ uint8_t DefaultWinterMinHeat;
    /* 0x01ed */ uint8_t DefaultSummerMaxHeat;
    /* 0x01ee */ uint8_t HeatIncrement;
    /* 0x01f0 */ float SecondsPerYear;
    /* 0x01f4 */ float SecondsPerDay;
    /* 0x01f8 */ float TemperatureFadeDuration;
    /* 0x01fc */ float TemperatureChangePeriod;
    /* 0x0200 */ float TemperatureChangeChance;
    /* 0x0204 */ float TemperatureChangeTimeVariance;
    /* 0x0208 */ float TemperatureChangeShiftVariance;
    /* 0x020c */ uint8_t ChillyThreshold;
    /* 0x020d */ uint8_t WarmThreshold;
    /* 0x020e */ uint8_t HotThreshold;
};

// Size: 0x20
struct FHeatSystemConfig {
    /* 0x0000 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x0008 */ UTexture2D* HeatTexture;
    /* 0x0010 */ double CellSize;
    /* 0x0018 */ double CellHeightOffset;
};

// Size: 0x48
class UHeatSystemConfigMule : public UObject {
    /* 0x0028 */ FHeatSystemConfig config;
};

// Size: 0x18
struct FHeatSystemTracker {
    /* 0x0000 */ TArray<int32_t> Sources;
    /* 0x0010 */ int32_t Insulator;
};

// Size: 0x28
class UHexMath : public UBlueprintFunctionLibrary {

    static TArray<FIntVector> CalcArea(FIntVector inPoint, int32_t Radius);
    static int32_t CalcDist(FIntVector A, FIntVector B);
    static TArray<FIntVector> CalcNeighbours(FIntVector inPoint);
    static FRotator CalcWorldRotation(FIntVector Origin, FIntVector Target);
    static FName FindDirectionalName(FIntVector Start, FIntVector End);
    static EHexDir FromRotator(FRotator rot);
    static FIntVector FromWorld(FVector Location);
    static FVector2D GetHexSize();
    static FVector GetScale();
    static float InWorldDistance(FIntVector B, FIntVector A);
    static FVector InWorldSnapLocation(FVector Location);
    static FIntVector RotateRelativePoint(FIntVector inPoint, FRotator rot);
    static bool SnapActor(AActor* Actor);
    static EHexDir StepCycleDirection(EHexDir Dir, int32_t step);
    static FRotator ToRotator(EHexDir Dir);
    static FVector ToWorld(FIntVector Point);
};

// Size: 0x68
struct FHolderConfig {
    /* 0x0000 */ FBorderStyle mapBorderStyle;
    /* 0x0040 */ UMaterialParameterCollection* mapDetailParameterCollection;
    /* 0x0048 */ UClass* WeatherConfigMule;
    /* 0x0050 */ UClass* SunConfigMule;
    /* 0x0058 */ bool doOverrideDaySpeed;
    /* 0x005c */ float overrideDaySpeed;
    /* 0x0060 */ bool ignoreExtraData;
};

// Size: 0x110
class UHolderPlaceable : public UActorComponent {
    /* 0x00b8 */ FPlaceableConfig config;
};

// Size: 0x28
class UHolderPlaceableLinker : public UBlueprintFunctionLibrary {

    static UClass* GetClass(UObject* WorldContextObject, FString ID);
    static TArray<FString> ListPlaceableClasses(UObject* WorldContextObject);
};

// Size: 0x2c0
class AHolderProp : public AActor {
    /* 0x02a8 */ USceneComponent* Root;
    /* 0x02b0 */ UHolderPlaceable* placeable;
    /* 0x02b8 */ UStaticMeshComponent* Mesh;
};

// Size: 0x310
class AHoldingConfigMule : public AActor {
    /* 0x02a8 */ FHolderConfig config;
};

// Size: 0x28
class UHoldingsDisk : public UBlueprintFunctionLibrary {

    static bool DeleteMap(EBackingLocation destination, FString mapId);
    static FString GetCustomMapDirectory();
    static FString GetMapDirectory();
    static FString GetMapExtension();
    static FString GetMapPath(EBackingLocation Location, FString mapId);
    static FString GetSaveDirectory();
    static bool HasMapIds(EBackingLocation Location);
    static TArray<FString> ListMapIds(EBackingLocation Location);
    static bool ReadMap(EBackingLocation Source, FString mapId, FMapDataHolding& mapData, FPlayState& PlayState);
    static bool WriteMap(EBackingLocation destination, FString mapId, const FMapDataHolding& mapData, const FPlayState& PlayState);
};

// Size: 0x490
class UHoldingsManagerComponent : public UActorComponent {
    /* 0x00b8 */ FHolderConfig config;
    /* 0x0120 */ FMapDataHolding Data;
    /* 0x02e0 */ TMap<FIntVector, AActor*> spawnedTags;
    /* 0x0330 */ TMap<AActor*, FIntVector> spawnedActors;
    /* 0x0380 */ TMap<FIntVector, FGridLand> spawnedLands;
    /* 0x03d0 */ FBorderTag mapLimitBorder;
    /* 0x03d8 */ FPlayState PlayState;
    /* 0x0428 */ AHoldingsRelay* relay;
    /* 0x0430 */ ULedger* Ledger;
    /* 0x0438 */ TMap<FIntVector, FTerraformCellState> pendingTerraforms;
    /* 0x0488 */ int32_t lastId;

    bool CanPlace(UClass* Type, FIntVector position, FRotator Rotation);
    bool DeleteSaveDataFromDisk();
    FPlacementTag DoPlace(UClass* Type, FIntVector position, FRotator Rotation, FName ID, bool isAbsolute);
    AActor* FindBuildByPosition(FIntVector position) const;
    FIntVector FindCanoncialPosition(FIntVector position) const;
    FIntVector FindSpawnedActorPosition(AActor* Actor) const;
    FMapExtraData GatherExtraData() const;
    UClockComponent* GetClock() const;
    FMapDataHolding GetData() const;
    UGridSpace* GetGridSpace() const;
    FString GetMapId() const;
    FIntVector GetMapSize() const;
    FMapSummary GetMapSummary() const;
    bool GetPlaceableConfig(FIntVector position, FPlaceableConfig& PlaceableConfig) const;
    FQuest GetQuest(FIntVector position) const;
    FQuestLibrary GetQuestLibrary() const;
    int32_t GetStartCash() const;
    bool GetTag(FIntVector position, FPlacementTag& Tag) const;
    bool HasLoaded();
    bool HasQuest(FIntVector position) const;
    bool HasTag(FIntVector position) const;
    bool LoadDataFromDisk(EBackingLocation Source, FString mapId);
    void MarkFinish(bool playerWon);
    void NewMap(FString overrideId);
    bool PlaceTag(const FPlacementTag& Tag, bool isAbsolute);
    FPlayState PullPlayState() const;
    void PushExtraData(AActor* Target) const;
    void PushPlayState(FPlayState newPlayState);
    void RemoveQuest(FIntVector position);
    void RemoveTag(FIntVector position);
    FName RequestId();
    bool SaveDataToDisk(EBackingLocation destination);
    void SetConfig(FHolderConfig nc);
    void SetMapSize(FIntVector boundary);
    void SetMapSummary(FMapSummary ms);
    void SetQuest(FIntVector position, FQuest Q);
};

// Size: 0x348
class AHoldingsRelay : public AActor {
    /* 0x02a8 */ FMapSummary mapSummery;
    /* 0x0300 */ UGridSpace* grid;
    /* 0x0308 */ UWeatherManComponent* weather;
    /* 0x0310 */ USunComponent* sun;
    /* 0x0318 */ UBorderAuthority* Border;
    /* 0x0320 */ USmallHoldComponent* smallHold;
    /* 0x0328 */ UUnlockManComponent* unlockMan;
    /* 0x0330 */ UClockComponent* clock;
    /* 0x0338 */ UActivityTracker* activity;
    /* 0x0340 */ UUnlockResearchComponent* research;

    FMissionStatus ComputeMissionStatus() const;
    static AHoldingsRelay* FindHoldingsRelay(const UObject* WorldContext);
    int32_t FindParTimeMinutes() const;
    FMapSummary GetMapSummery();
    EResultRank GetResultRank() const;
};

// Size: 0x130
class UHoneycomb : public UActorComponent {
    /* 0x00b8 */ FHoneycombConfig config;
    /* 0x00e0 */ FHoneycombState State;

    bool DoEdit(const FHoneycombEdit& edit);
    AActor* GetActor(FIntVector Location) const;
    UClass* GetActorClass(FName cellType) const;
    bool IntegrateActor(AActor* Actor);
    TArray<FName> ListCellTypes() const;
};

// Size: 0x28
struct FHoneycombCell {
    /* 0x0000 */ AActor* primeActor;
    /* 0x0008 */ FName tileType;
    /* 0x0010 */ FName biomeType;
    /* 0x0018 */ FName Team;
    /* 0x0020 */ EHexDir Rotation;
};

// Size: 0x2f8
class AHoneycombCellBase : public AActor {
    /* 0x02a8 */ FName biomeType;
    /* 0x02b0 */ FName tileType;
    /* 0x02b8 */ FHoneycombCell State;
    /* 0x02e0 */ USmallHoldComponent* smallHold;
    /* 0x02e8 */ UStagePrepEntity* stageEntity;
    /* 0x02f0 */ UDyehouse* Dyehouse;

    void OnRep_State();
};

// Size: 0x18
struct FHoneycombCellRow : public FTableRowBase {
    /* 0x0008 */ FName ID;
    /* 0x0010 */ UClass* ActorClass;
};

// Size: 0x28
struct FHoneycombConfig {
    /* 0x0000 */ UDataTable* cellTable;
    /* 0x0008 */ FRotator cellRotation;
    /* 0x0020 */ bool ignoreExtraData;
};

// Size: 0x2c
struct FHoneycombEdit {
    /* 0x0000 */ FIntVector Point;
    /* 0x000c */ int32_t Radius;
    /* 0x0010 */ FName tileType;
    /* 0x0018 */ FName biomeType;
    /* 0x0020 */ EHexDir Dir;
    /* 0x0024 */ FName Team;
};

// Size: 0x50
struct FHoneycombMap {
    /* 0x0000 */ TMap<FIntVector, FHoneycombCell> Cells;
};

// Size: 0x50
struct FHoneycombState {
    /* 0x0000 */ FHoneycombMap Map;
};

// Size: 0xc8
class UIconBroker : public UObject {
    /* 0x0028 */ FIconConfig config;

    static bool AddTextureAsIcon(UTexture2D* Icon, EIconGroup Group, FString Key);
    static UTexture2D* GetIconFromInt(EIconGroup Group, int32_t Index);
    static UTexture2D* GetIconFromKey(EIconGroup Group, FString Key);
    static void MarkTextureDirty(UTexture2D* Icon);
    static bool SaveTextureToDisk(UTexture2D* Icon, EIconGroup Group, FString Key);
};

// Size: 0xa0
struct FIconConfig {
    /* 0x0000 */ TMap<FString, UDataTable*> platformKeyIcons;
    /* 0x0050 */ TMap<EIconGroup, UDataTable*> groupIcons;
};

// Size: 0x348
class AIconConfigMule : public AActor {
    /* 0x02a8 */ FIconConfig config;
};

// Size: 0x10
struct FIconDataRowBase : public FTableRowBase {
    /* 0x0008 */ UTexture2D* Icon;
};

// Size: 0x28
class UImageHandler : public UObject {

    static FString ComputeImagePath(FString SlotName);
    static FString ComputeImageSlot(FString SlotName);
    static bool DeleteImageOnDisk(FString SlotName);
    static bool IsImageOnDisk(FString SlotName);
    static UTexture2D* ReadImageFromDisk(FString SlotName);
    static bool UseWrapper();
    static bool WriteImageToDisk(UTextureRenderTarget2D* TextureRenderTarget, FString SlotName);
    static void log(FString Msg);
};

// Size: 0x60
struct FInputIconConfigRow : public FTableRowBase {
    /* 0x0008 */ EPlatformCategory Platform;
    /* 0x0010 */ TMap<EInputIconButton, UTexture2D*> iconTextures;
};

// Size: 0xe8
class UInputIconManager : public UObject {
    /* 0x0028 */ FInputIconState State;
    /* 0x00d8 */ FMulticastInlineDelegate notifyChangeInIconSet;

    UTexture2D* GetInputIcon(EInputIconButton button);
    bool SetPreferedPlatformIconSet(EPlatformCategory desiredIconSet);
};

// Size: 0x58
struct FInputIconSet {
    /* 0x0000 */ EPlatformCategory Platform;
    /* 0x0008 */ TMap<EInputIconButton, UTexture2D*> iconTextures;
};

// Size: 0xb0
struct FInputIconState {
    /* 0x0000 */ TMap<EPlatformCategory, FInputIconSet> availableIconSets;
    /* 0x0050 */ EPlatformCategory currentPlatform;
    /* 0x0058 */ FInputIconSet currentIcons;
};

// Size: 0xc
struct FIntPair {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ int32_t val;
};

// Size: 0x128
class UIntelEffect : public UActorComponent {
    /* 0x00b8 */ FIntelEffectState State;
    /* 0x0118 */ FIntelEffectConfig config;
};

// Size: 0x10
struct FIntelEffectConfig {
    /* 0x0000 */ TArray<FIntelEffectPlan> plans;
};

// Size: 0x30
struct FIntelEffectPlan {
    /* 0x0000 */ TArray<FComponentReference> Targets;
    /* 0x0010 */ FString metric;
    /* 0x0020 */ FVector2D operatingBand;
};

// Size: 0x60
struct FIntelEffectState {
    /* 0x0000 */ TMap<FString, float> metrics;
    /* 0x0050 */ TArray<bool> statusByIndex;
};

// Size: 0xc8
class UInteractableComponent : public UActorComponent {
    /* 0x00b8 */ TArray<FInteractionSummary> defaultSummaries;

    void DoInteraction(EInteractionType Type, AActor* doer);
    bool HasInteraction(EInteractionType Type) const;
    FInteractionSummary ReadInteraction(EInteractionType Type) const;
    TArray<FInteractionSummary> ReadInteractions() const;
};

// Size: 0x10
struct FInteractionSummary {
    /* 0x0000 */ float effortRequired;
    /* 0x0004 */ EInteractionType Category;
    /* 0x0005 */ EInteractionVerb verb;
    /* 0x0008 */ UInteractableComponent* interactable;
};

// Size: 0x280
class UInteractorComponent : public USceneComponent {
    /* 0x0240 */ FInteractorConfig config;
    /* 0x0250 */ UCapsuleComponent* capsule;
    /* 0x0258 */ UInteractableComponent* focus;
    /* 0x0260 */ AActor* shownFocusSymbol;
    /* 0x0268 */ TArray<UInteractableComponent*> focusOptions;

    UInteractableComponent* GetFocus() const;
    AActor* GetInteractableActor() const;
    bool HasFocus() const;
    void OnOverlapEnd(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32_t OtherBodyIndex);
    void OnOverlapStart(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32_t OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);
    void RemoveFocus(UInteractableComponent* interactable);
    void SetConfig(FInteractorConfig newConfig);
    void SetFocus(UInteractableComponent* interactable);
    void SetHighlight(AActor* Actor, bool shouldHightlight);
};

// Size: 0x10
struct FInteractorConfig {
    /* 0x0000 */ bool highlightFocus;
    /* 0x0004 */ int32_t highlightStencilValue;
    /* 0x0008 */ UClass* focusSymbol;
};

// Size: 0xd0
class UKnowMoreComponent : public UActorComponent {
    /* 0x00b8 */ FKnowMoreConfig config;
    /* 0x00c0 */ UKnowMoreWidgetBase* shownWidget;
    /* 0x00c8 */ APlayerController* owningController;

    UKnowMoreWidgetBase* DisplayKnowMoreWidget(APlayerController* Owner);
    UClass* GetWidgetClass() const;
    void RemoveKnowMoreWidget();
    void SetWidgetClass(UClass* newWidgetClass);
    void UpdateWidget();
};

// Size: 0x8
struct FKnowMoreConfig {
    /* 0x0000 */ UClass* WidgetClass;
};

// Size: 0x3b8
class UKnowMoreWidgetBase : public UNaviUi {
    /* 0x03a8 */ APlayerController* asker;
    /* 0x03b0 */ AActor* Subject;

    bool DesiresConsumeActions();
    bool DesiresConsumeMovement();
    void Init(APlayerController* newAsker, AActor* newSubject);
    bool IsMoneyUsed();
    void OnRemove();
};

// Size: 0x250
class ULedger : public USceneComponent {
    /* 0x0240 */ UBeltGraph* belt;
};

// Size: 0x18
struct FLimitArea {
    /* 0x0000 */ FIntVector position;
    /* 0x000c */ FIntVector Extents;
};

// Size: 0x58
struct FLocConfig {
    /* 0x0000 */ TMap<FName, UDataTable*> langs;
    /* 0x0050 */ FName defaultLang;
};

// Size: 0x300
class ALocConfigMule : public AActor {
    /* 0x02a8 */ FLocConfig config;
};

// Size: 0x18
struct FLocDataRowBase : public FTableRowBase {
    /* 0x0008 */ FString Value;
};

// Size: 0x28
class ULocKey : public UBlueprintFunctionLibrary {

    static FName CargoStringKey(FString cargoId);
    static FName RankStringKey(int32_t Rank);
    static FName VehicleStringKey(FString vehId);
    static FName VerbStringKey(int32_t verb);
};

// Size: 0x188
class ULocManager : public UObject {
    /* 0x0028 */ FLocConfig config;
    /* 0x0080 */ FLocState State;
    /* 0x0180 */ UOptionManager* OptionManager;

    static int32_t CountGroupOptions(FName keyGroup);
    static TArray<FName> FindAllGroupOptions(FName keyGroup);
    static FName FormatGroupOption(FName keyGroup, int32_t Index);
    static FString FormatMoney(int32_t moneyValue);
    FName GetActiveLanguage() const;
    static TArray<FName> GetGrabBagRandomizedGroupOptions(FName keyGroup);
    static FString GetWordFromKey(FName Key);
    static FString GetWordFromKeyWithReplace(FName Key, TArray<FName> Values);
    static bool HasKey(FName Key);
    bool HasLanguage(FName lang);
    static FName PickGroupOption(FName keyGroup);
};

// Size: 0x100
struct FLocState {
    /* 0x0000 */ FName Language;
    /* 0x0008 */ TMap<FName, FString> keyToWord;
    /* 0x0058 */ FName preferredLang;
    /* 0x0060 */ TMap<FName, FRuntimeLang> runtimeLangs;
    /* 0x00b0 */ TMap<FName, FRuntimeLang> runtimeExpansions;
};

// Size: 0x340
class ULocTextBlock : public UTextBlock {
    /* 0x0328 */ FName Key;

    void SetKey(FName NewKey);
    void SetKeyWithArgs(FName NewKey, TArray<FName> args);
    void SetStringKey(FName NewKey);
};

// Size: 0x2f8
class AMailConfigMule : public AActor {
    /* 0x02a8 */ FMailManagerConfig config;
};

// Size: 0x38
struct FMailLetter {
    /* 0x0000 */ FName Type;
    /* 0x0008 */ TArray<FName> payloadNames;
    /* 0x0018 */ TArray<FString> payloadStrings;
    /* 0x0028 */ TArray<float> payloadNumbers;
};

// Size: 0x88
struct FMailLetterRow : public FTableRowBase {
    /* 0x0008 */ FName ID;
    /* 0x0010 */ FName swapGroupOverrideId;
    /* 0x0018 */ FName sender;
    /* 0x0020 */ TSoftObjectPtr<USoundBase> voiceover;
    /* 0x0048 */ FName p1_key;
    /* 0x0050 */ FName p1_vo;
    /* 0x0058 */ FName p2_key;
    /* 0x0060 */ FName p2_vo;
    /* 0x0068 */ FName p3_key;
    /* 0x0070 */ FName p3_vo;
    /* 0x0078 */ FName p4_key;
    /* 0x0080 */ FName p4_vo;
};

// Size: 0x3a8
class UMailLetterWidget : public UNaviUi {

    void UpdateDisplay(FMailLetter L);
};

// Size: 0x88
class UMailManager : public UObject {
    /* 0x0028 */ FMailManagerState State;
    /* 0x0038 */ FMailManagerConfig config;

    UNaviUi* GenerateLetterWindow(UObject* WorldContext);
    static UMailManager* Get(const UObject* WorldContext);
    bool HasLetter() const;
    bool PullLetter(FMailLetter& L);
    bool PushLetter(FMailLetter L);
};

// Size: 0x50
struct FMailManagerConfig {
    /* 0x0000 */ TMap<FName, UClass*> matchedWidgets;
};

// Size: 0x10
struct FMailManagerState {
    /* 0x0000 */ TArray<FMailLetter> pendingLetters;
};

// Size: 0x1c0
struct FMapDataHolding {
    /* 0x0000 */ int32_t formatVersion;
    /* 0x0008 */ FMapSummary summary;
    /* 0x0060 */ FQuestLibrary quests;
    /* 0x00b0 */ FMapLimits limits;
    /* 0x00c0 */ FMapPlacements placements;
    /* 0x00d0 */ FMapHeights heights;
    /* 0x0120 */ FMapExtraData extraData;
    /* 0x0170 */ FStorageState storage;
};

// Size: 0x50
struct FMapExtraData {
    /* 0x0000 */ TMap<FIntVector, FMapSmallData> datas;
};

// Size: 0x50
struct FMapHeights {
    /* 0x0000 */ TMap<FIntVector, int32_t> Cells;
};

// Size: 0x10
struct FMapLimits {
    /* 0x0000 */ TArray<FLimitArea> allowances;
};

// Size: 0x10
struct FMapPlacements {
    /* 0x0000 */ TArray<FPlacementTag> Tags;
};

// Size: 0x50
struct FMapSmallData {
    /* 0x0000 */ TMap<FName, int32_t> db;
};

// Size: 0x58
struct FMapSummary {
    /* 0x0000 */ FString ID;
    /* 0x0010 */ FString Title;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ FString thumbnailId;
    /* 0x0040 */ EMapType mapType;
    /* 0x0041 */ EClimate mapClimate;
    /* 0x0042 */ EUnlockCategory unlockCategory;
    /* 0x0043 */ EVolumeRatio pollutionRatio;
    /* 0x0044 */ FIntVector mapSize;
    /* 0x0050 */ int32_t startCash;
    /* 0x0054 */ int32_t parTimeMinutes;
};

// Size: 0xc8
struct FMasterSyncConfig {
    /* 0x0000 */ FString baseUrl;
    /* 0x0010 */ bool updateOnlyInDev;
    /* 0x0011 */ bool updateOnInit;
    /* 0x0012 */ bool markDirty;
    /* 0x0013 */ bool neverUpdateInStandalone;
    /* 0x0018 */ TArray<FMasterSyncSheet> sheets;
    /* 0x0028 */ TMap<FName, UDataTable*> linkedTables;
    /* 0x0078 */ TMap<FName, UDataTable*> modTables;
};

// Size: 0x370
class AMasterSyncConfigMule : public AActor {
    /* 0x02a8 */ FMasterSyncConfig config;
};

// Size: 0x18
struct FMasterSyncLinkage {
    /* 0x0000 */ FString pageName;
    /* 0x0010 */ UDataTable* Table;
};

// Size: 0x140
class UMasterSyncManager : public UObject {
    /* 0x0028 */ FMasterSyncConfig config;
    /* 0x00f0 */ FMasterSyncState State;

    UDataTable* GetLinkedTable(FName tableName);
    UDataTable* GetModTable(FName tableName);
    bool IsSheetUpdating(FString sheetId) const;
    bool IsUpdating() const;
    bool IsUpdatingAllowed() const;
    TArray<FString> ListAvailableSheets() const;
    void StartSheetUpdate(FString sheetId);
    void StartUpdateAll();
};

// Size: 0x28
struct FMasterSyncRequest {
    /* 0x0000 */ FString sheetId;
    /* 0x0010 */ FString URL;
    /* 0x0020 */ EMasterSyncRequestStatus Status;
};

// Size: 0x20
struct FMasterSyncSheet {
    /* 0x0000 */ FString sheetId;
    /* 0x0010 */ TArray<FMasterSyncLinkage> links;
};

// Size: 0x50
struct FMasterSyncState {
    /* 0x0000 */ TMap<FString, FMasterSyncRequest> activeRequests;
};

// Size: 0x118
class UMetaMetric : public UObject {
    /* 0x0028 */ FMetaMetricConfig config;
    /* 0x0038 */ FMetaMetricContext Context;
    /* 0x0060 */ FMetaMetricRunState runstate;
    /* 0x0110 */ UBackbone* Backbone;

    TArray<FMetaMetricDebugState> CalcDebugData() const;
    void GenerateEgsCsv();
    void GenerateVdf();
    void GenerateWingdkXml();
    FMetaMetricContext GetContext() const;
    void MarkContext(FMetaMetricContext newContext);
    void ReportAbsolute(FName metric, FName filterValue, int32_t Delta);
    void ReportAdditive(FName metric, FName filterValue, int32_t Delta);
};

// Size: 0x10
struct FMetaMetricConfig {
    /* 0x0000 */ UDataTable* achievements;
    /* 0x0008 */ double cooldownSeconds;
};

// Size: 0x2b8
class AMetaMetricConfigMule : public AActor {
    /* 0x02a8 */ FMetaMetricConfig config;
};

// Size: 0x28
struct FMetaMetricContext {
    /* 0x0000 */ bool isEditor;
    /* 0x0001 */ bool isPlay;
    /* 0x0008 */ FString mapId;
    /* 0x0018 */ FString biome;
};

// Size: 0x10
struct FMetaMetricDebugState {
    /* 0x0000 */ FName achievementKey;
    /* 0x0008 */ int32_t progressValue;
    /* 0x000c */ bool achieved;
};

// Size: 0xb0
struct FMetaMetricRunState {
    /* 0x0000 */ TSet<FName> alreadySessionGivenAchievements;
    /* 0x0050 */ TSet<FName> allHistoricGivenAchievements;
    /* 0x00a0 */ double timeOfLastSend;
    /* 0x00a8 */ bool wantDelayedSend;
};

// Size: 0x50
struct FMetaMetricStorageMetric {
    /* 0x0000 */ TMap<FName, int32_t> valueByFilter;
};

// Size: 0xa0
struct FMetaMetricStorageScope {
    /* 0x0000 */ TSet<FName> unlockedAchievements;
    /* 0x0050 */ TMap<FName, FMetaMetricStorageMetric> metrics;
};

// Size: 0x28
class UMiddleOut : public UBlueprintFunctionLibrary {

    static FVector FindOffsetToCenterOfActor(AActor* Actor);
    static FVector FindWorldCenterOfActor(AActor* Actor);
};

// Size: 0x60
struct FMissionStatus {
    /* 0x0000 */ EResultRank bestRankPossible;
    /* 0x0008 */ TMap<EResultRank, FRankStatus> allStatsues;
    /* 0x0058 */ bool hasTimes;
};

// Size: 0xb8
class UModAPI : public UObject {
    /* 0x0028 */ UBackbone* Backbone;
    /* 0x0030 */ UOptionManager* optMan;
    /* 0x0038 */ UMasterSyncManager* masterSync;
    /* 0x0040 */ UModManager* modMan;
    /* 0x0048 */ FModApiState State;
    /* 0x0058 */ FMulticastInlineDelegate onLoadingFinished;
    /* 0x0068 */ FMulticastInlineDelegate onConstructionSpawned;
    /* 0x0078 */ FMulticastInlineDelegate onBuildingSpawned;
    /* 0x0088 */ FMulticastInlineDelegate onWhiskerSpawned;
    /* 0x0098 */ FMulticastInlineDelegate onOptionChanged;
    /* 0x00a8 */ FMulticastInlineDelegate onDayStart;

    void AddDataTable(UObject* WorldContext, FName datatableName, UDataTable* Table);
    bool AddDataTableRow(UObject* WorldContext, FName datatableName, FName rowId);
    bool AddNewStrings(UObject* WorldContext, FName langId, TMap<FName, FString> idStringPairs);
    bool AddNewTranslation(UObject* WorldContext, FString modId, FString translationName);
    void DumpAllDataTablesToLogFolder(UObject* WorldContext);
    void DumpDataTableToLogFolder(UObject* WorldContext, FName datatableName);
    void DumpEnglishToLogFolder(UObject* WorldContext);
    static UModAPI* GetModAPI(const UObject* WorldContext);
    bool HasDataTable(UObject* WorldContext, FName datatableName);
    TArray<FName> ListDataTables(UObject* WorldContext);
    TArray<FName> ListLanguageIds(UObject* WorldContext);
    void LogMessage(UObject* WorldContext, FString Msg, bool doPrependDate);
    FString ReadDataTableValue(UObject* WorldContext, FName datatableName, FName rowId, FName ColumnName);
    FString ReadModOptionValue(UObject* WorldContext, FString optionId, FString fallbackValue);
    FString ReadModTextFile(UObject* WorldContext, FString modName, FString Filename);
    bool RegisterModOptions(UObject* WorldContext, FString optionId, FString optionDisplayName, TArray<FString> Values, FString DefaultValue, FString optionDescription);
    void SetWhiskerNamePool(TArray<FString> Names);
    bool WriteDataTableValue(UObject* WorldContext, FName datatableName, FName rowId, FName ColumnName, FString valueStringified);
};

// Size: 0x10
struct FModApiState {
};

// Size: 0x80
class UModManager : public UObject {
    /* 0x0028 */ UBackbone* Backbone;
    /* 0x0030 */ FModState State;

    static void TriggerMapLeave(UObject* WorldContext);
    void TriggerMapMods(UObject* WorldContext);
    void TriggerStartupMods(UObject* WorldContext);
};

// Size: 0x50
struct FModState {
};

// Size: 0x88
struct FModTag {
    /* 0x0000 */ FString ID;
    /* 0x0010 */ FString Name;
    /* 0x0020 */ int32_t byteSize;
    /* 0x0028 */ FString author;
    /* 0x0038 */ FString folder;
    /* 0x0048 */ FString pakFilePath;
    /* 0x0058 */ FString pakName;
    /* 0x0068 */ bool IsEnabled;
    /* 0x006c */ int32_t Priority;
    /* 0x0070 */ bool isMounted;
    /* 0x0078 */ AActor* startupActor;
    /* 0x0080 */ bool hasPerformedStartup;
};

// Size: 0x28
class UMouzer : public UBlueprintFunctionLibrary {

    static void AutoMouse(AController* C);
    static bool CaptureMousePlusReset(UObject* WorldContext);
    static bool DoesPlatformWantMouse();
    static void HideMouse(AController* C);
    static bool ResetMousePosition(UObject* WorldContext);
    static bool ShouldHaveMouse();
};

// Size: 0x2e0
class AMusicPlayerReflectionSpeaker : public AActor {
    /* 0x02a8 */ FName defaultMusicId;
    /* 0x02b0 */ UDataTable* musicTable;
    /* 0x02b8 */ bool usePreferences;
    /* 0x02c0 */ UAudioComponent* Audio;
    /* 0x02c8 */ FMusicPlayerState State;

    void DecrementMusic();
    FMusicRow GetMusicRow(FName ID) const;
    FMusicPlayerState GetPlayerState() const;
    void IncrementMusic();
    TArray<FName> ListMusicIds() const;
    TArray<FName> ListOwnedMusicIds() const;
    void PlayMusic(FName musicId);
    void SetPaused(bool IsPaused);
    void TogglePausePlay();
};

// Size: 0x18
struct FMusicPlayerState {
    /* 0x0000 */ bool IsPlaying;
    /* 0x0004 */ FName playingMusicId;
    /* 0x000c */ float musicLength;
    /* 0x0010 */ float playingTime;
    /* 0x0014 */ bool isInfinite;
};

// Size: 0x3a8
class UMusicPlayerUi : public UNaviUi {
};

// Size: 0x60
struct FMusicRow : public FTableRowBase {
    /* 0x0008 */ float Length;
    /* 0x0010 */ FString nameStringKey;
    /* 0x0020 */ FString bandStringKey;
    /* 0x0030 */ FName requiredUnlockId;
    /* 0x0038 */ TSoftObjectPtr<USoundBase> cue;
};

// Size: 0x38
struct FNaviConfirm {
    /* 0x0000 */ int32_t instId;
    /* 0x0008 */ FString titleStringKey;
    /* 0x0018 */ FString descStringKey;
    /* 0x0028 */ TArray<FNaviConfirm_Choice> Items;
};

// Size: 0x20
struct FNaviConfirm_Choice {
    /* 0x0000 */ FString titleStringKey;
    /* 0x0010 */ FString Payload;
};

// Size: 0x3a8
class UNaviForm : public UNaviUi {

    void SetFormPlan(FNaviFormPlan plan);
};

// Size: 0x3b8
class UNaviFormItem : public UNaviUi {
    /* 0x03a8 */ FString ID;

    void DisplayFromPlan(FNaviFormItemPlan plan);
    void SendFormItemChange(FString Value);
    void SetFormPlan(FNaviFormItemPlan plan);
};

// Size: 0x38
struct FNaviFormItemPlan {
    /* 0x0000 */ ENaviFormType Type;
    /* 0x0008 */ FString ID;
    /* 0x0018 */ TArray<FString> Options;
    /* 0x0028 */ FString DefaultValue;
};

// Size: 0x3b8
class UNaviFormItem_NoFocus : public UNaviFormItem {
};

// Size: 0x10
struct FNaviFormPlan {
    /* 0x0000 */ TArray<FNaviFormItemPlan> Items;
};

// Size: 0x4c8
class UNaviGrid : public UNaviUi {
    /* 0x03a8 */ FNaviGridState gridState;
    /* 0x04b8 */ FNaviGridConfig gridConfig;

    void AddGridChild(FVector cell, UNaviUi* newChild);
    bool AttemptNavigation(ENaviUiIntent intent);
    int32_t ComputeMaxSearchDist() const;
    FNaviPrimeGridLayout ComputePrimeGridLayout();
    FVector FindCurrentCell() const;
    FVector FindNearestCell(FVector Start, FVector SearchDir) const;
    bool IntegrateSubGrid(UNaviSubGrid* subGrid);
    TArray<FVector> ListFilledCells() const;
    TArray<UNaviUi*> ListGridMembers() const;
    void OnSubGridChange();
    void RelayoutPrimeGrid();
    void RemoveAllGridChildren();
    UNaviUi* RemoveGridChild(FVector cell);
    bool SetPriorityGridChild(UNaviUi* Child);
};

// Size: 0xc
struct FNaviGridConfig {
    /* 0x0000 */ bool ignoreHistory;
    /* 0x0004 */ int32_t minSearchDistance;
    /* 0x0008 */ int32_t nearSearchDistance;
};

// Size: 0x110
struct FNaviGridState {
    /* 0x0000 */ TMap<FVector, UNaviUi*> Items;
    /* 0x0050 */ TMap<UNaviUi*, FVector> itemToCell;
    /* 0x00a0 */ FVector preferedCell;
    /* 0x00b8 */ TMap<ENaviUiIntent, UNaviUi*> hotkeyRegistry;
    /* 0x0108 */ UNaviUi* priorityTabReceiver;
};

// Size: 0x1
struct FNaviHotkeyRegistry {
};

// Size: 0x28
struct FNaviList {
    /* 0x0000 */ int32_t instId;
    /* 0x0008 */ FString titleStringKey;
    /* 0x0018 */ TArray<FNaviList_Item> Items;
};

// Size: 0x28
struct FNaviList_Item {
    /* 0x0000 */ FString titleStringKey;
    /* 0x0010 */ FString Payload;
    /* 0x0020 */ bool IsActive;
};

// Size: 0xb0
struct FNaviPrimeGridLayout {
    /* 0x0000 */ UNaviUi* defaultFocusedMember;
    /* 0x0008 */ TMap<UNaviUi*, FVector> gridMembers;
    /* 0x0058 */ TMap<ENaviUiIntent, UNaviUi*> hotkeyRegistry;
    /* 0x00a8 */ int32_t tabReceptionPriority;
};

// Size: 0x3f8
class UNaviSettings : public UNaviUi {

    void AcceptPendingChanges();
    TArray<FString> CalcCategoryChoices(FString Category);
    TArray<FString> CalcCategoryList();
    FNaviSettingsOption CalcOptionState(FString optionId);
    FNaviSettingsScreenState CalcScreenState(FString CategoryId);
    void SetPendingChange(FString optionId, FString Value);
};

// Size: 0x50
struct FNaviSettingsOption {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ FString ID;
    /* 0x0020 */ FNaviSettingsOptionChoice CurrentValue;
    /* 0x0040 */ TArray<FNaviSettingsOptionChoice> choices;
};

// Size: 0x20
struct FNaviSettingsOptionChoice {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ FString Payload;
};

// Size: 0x40
struct FNaviSettingsScreenState {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ FString currentCategory;
    /* 0x0020 */ TArray<FString> Categories;
    /* 0x0030 */ TArray<FNaviSettingsOption> Options;
};

// Size: 0x3b8
class UNaviSubGrid : public UNaviUi {
    /* 0x03a8 */ UNaviGrid* hostGrid;
    /* 0x03b0 */ bool isAlsoNaviUi;

    FNaviSubGridLayout ComputeSubGridLayout();
    void ReportSubGridChanged();
};

// Size: 0x108
struct FNaviSubGridLayout {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UNaviUi* defaultFocusedMember;
    /* 0x0010 */ TMap<UNaviUi*, FVector> gridMembers;
    /* 0x0060 */ TSet<ENaviGridAttribute> Attributes;
    /* 0x00b0 */ TMap<ENaviUiIntent, UNaviUi*> hotkeyRegistry;
    /* 0x0100 */ int32_t tabReceptionPriority;
};

// Size: 0x3a8
class UNaviUi : public UUserWidget {
    /* 0x0340 */ FMulticastInlineDelegate OnResultOccuredDelegate;
    /* 0x0350 */ FMulticastInlineDelegate OnFocusChangeDelegate;
    /* 0x0360 */ UNaviUi* Parent;
    /* 0x0368 */ TArray<UNaviUi*> Children;
    /* 0x0378 */ FString internal_id;
    /* 0x0388 */ bool internal_hasFocus;
    /* 0x0390 */ UNaviUi* internal_priorityChild;
    /* 0x0398 */ float timeOfLastMovement;

    void AddChild(UNaviUi* childMenu);
    bool CanHaveFocus() const;
    static void CleanupAfterCombobox();
    static void CleanupAfterVirtualKeyboard();
    int32_t CountChildren();
    void DoStealFocus(UNaviUi* originOfSteal);
    static TArray<UWidget*> FindDecendentsOfClasses(UWidget* searchRoot, TArray<UClass*> candidateClasses, bool ignoreHidden);
    static UWidget* FindFirstParentOfClasses(UWidget* searchRoot, TArray<UClass*> candidateClasses, int32_t maxDepth);
    static UWidget* FindFirstParentWithTooltip(UWidget* searchRoot, int32_t maxDepth);
    static void ForceFocusCombobox(UComboBoxString* ComboBox);
    static void ForceOpenVirtualKeyboard(UEditableText* EditableText);
    static void ForcePressButton(Ubutton* buttonWidget);
    bool ForceTooltipShown(UNaviUi* searchRoot, bool showTooltip, int32_t searchDepth);
    FString GetId() const;
    static ENaviUiIntent GetIntentFromMovement(FVector2D diff);
    UNaviUi* GetNaviParent() const;
    UNaviUi* GetNextPriorityChild(int32_t Offset) const;
    UNaviUi* GetPriorityChild() const;
    ENaviHandleMethod HandleInput(ENaviUiIntent Key);
    FString HandleInternalEvent(FName eventId, FString StringInput, int32_t IntInput);
    ENaviResultHandleMethod HandleResult(FNaviUiResult Result);
    bool HandleTabShift(int32_t tabDelta);
    bool HasChildren();
    bool HasFocus() const;
    bool HasParent() const;
    bool HasPriorityChild() const;
    bool IsEmpty();
    static bool IsEnabledWithinSearchDepth(UWidget* searchRoot, int32_t maxDepth);
    bool IsRoot() const;
    void OnChildAdded(UNaviUi* newChild);
    void OnChildRemoved(UNaviUi* lostChild);
    void OnFocusChanged(bool nowHasFocus);
    void OnPriorityChildChanged(UNaviUi* nowPriorityChild);
    void OnSelfRemoved();
    void RemoveAllChildren();
    void RemoveChild(UNaviUi* childMenu);
    void ResetToDefaultPriorityChild();
    void RotatePriorityChild(int32_t Offset);
    void SendInput(ENaviUiIntent Key);
    void SendMovement(FVector2D diff);
    void SendResult(FNaviUiResult Result);
    void SendTabShift(int32_t tabDelta);
    void SetNaviFocus(bool nowHasFocus);
    void SetPriorityChild(UNaviUi* nextPriorityChild);
    void StealFocus();
    bool WantsAllInput();
};

// Size: 0x28
struct FNaviUiResult {
    /* 0x0000 */ UNaviUi* Origin;
    /* 0x0008 */ FString Payload;
    /* 0x0018 */ FString Key;
};

// Size: 0x48
struct FNavigationPlan {
    /* 0x0000 */ TArray<FVector> waypoints;
    /* 0x0010 */ bool IsValid;
    /* 0x0018 */ FVector Start;
    /* 0x0030 */ FVector destination;
};

// Size: 0xc
struct FNetExchangeConfig {
    /* 0x0000 */ float minRefreshTime;
    /* 0x0004 */ float refreshTimeout;
    /* 0x0008 */ bool isLan;
};

// Size: 0x40
struct FNetExchangeLobby {
    /* 0x0000 */ FString ID;
    /* 0x0010 */ FString HostName;
    /* 0x0020 */ FString mapName;
    /* 0x0030 */ int32_t playerCount;
    /* 0x0034 */ int32_t MaxCount;
    /* 0x0038 */ int32_t Ping;
    /* 0x003c */ bool pingIsKnown;
};

// Size: 0x18
struct FNetExchangeResults {
    /* 0x0000 */ bool isLan;
    /* 0x0008 */ TArray<FNetExchangeLobby> lobbies;
};

// Size: 0x28
struct FNetExchangeState {
    /* 0x0000 */ FNetExchangeStatus Status;
    /* 0x0010 */ FNetExchangeResults Results;
};

// Size: 0xc
struct FNetExchangeStatus {
    /* 0x0000 */ float refreshCountdown;
    /* 0x0004 */ bool canRefresh;
    /* 0x0005 */ bool inRefresh;
    /* 0x0008 */ float refreshTimeoutCountdown;
};

// Size: 0x3e0
class UNetExchangeUi : public UNaviUi {
    /* 0x03a8 */ FNetExchangeConfig config;
    /* 0x03b8 */ FNetExchangeState State;

    bool IsInputBlocked() const;
    bool IsRefreshAllowed() const;
    void SetBlockerActive(bool IsActive);
    void UpdateResults(FNetExchangeResults Data);
    void UpdateStatus(FNetExchangeStatus Data);
};

// Size: 0x1c8
class UNetMan : public UObject {
    /* 0x0028 */ FNetManConfig config;
    /* 0x0050 */ FNetManState State;

    bool CanSearch(const UObject* WorldContext) const;
    bool ScheduleLogin(const UObject* WorldContext);
    bool ScheduleStartSearch(const UObject* WorldContext, bool searchLan);
    bool ScheduleStartupSession(const UObject* WorldContext, FNetManSessionPlan plan);
    bool StartLogin(const UObject* WorldContext);
    bool StartSearch(const UObject* WorldContext, bool searchLan);
    bool StartupSession(const UObject* WorldContext, FNetManSessionPlan plan);
};

// Size: 0x28
struct FNetManConfig {
    /* 0x0000 */ bool usePresence;
    /* 0x0004 */ float refreshRateLimit;
    /* 0x0008 */ int32_t mpVersion;
    /* 0x000c */ int32_t maxSearchResults;
    /* 0x0010 */ float searchTimeout;
    /* 0x0018 */ FString PlayMap;
};

// Size: 0x18
struct FNetManLogin {
    /* 0x0000 */ bool isAttemptingLogin;
    /* 0x0001 */ bool hasLoginFinished;
};

// Size: 0x18
struct FNetManSchedule {
    /* 0x0000 */ bool isLoginPending;
    /* 0x0004 */ FNetManSessionPlan pendingSessionPlan;
    /* 0x0014 */ bool isSessionPending;
    /* 0x0015 */ bool pendingSearchIsLand;
    /* 0x0016 */ bool isSearchPending;
};

// Size: 0x30
struct FNetManSearch {
    /* 0x0000 */ bool inSearch;
    /* 0x0001 */ bool hasResults;
    /* 0x0004 */ float timeOfLastRefresh;
    /* 0x0008 */ FNetManSearchResults Results;
};

// Size: 0x40
struct FNetManSearchLobby {
    /* 0x0000 */ FString HostName;
    /* 0x0010 */ FString mapName;
    /* 0x0020 */ FString address;
    /* 0x0030 */ int32_t MaxCount;
    /* 0x0034 */ int32_t playerCount;
    /* 0x0038 */ float Ping;
    /* 0x003c */ bool isFull;
    /* 0x003d */ bool canJoin;
};

// Size: 0x18
struct FNetManSearchResults {
    /* 0x0000 */ bool isLan;
    /* 0x0008 */ TArray<FNetManSearchLobby> lobbies;
};

// Size: 0x14
struct FNetManSession {
    /* 0x0000 */ bool isSessionActive;
    /* 0x0001 */ bool isStartingSession;
    /* 0x0004 */ FNetManSessionPlan plan;
};

// Size: 0x10
struct FNetManSessionPlan {
    /* 0x0000 */ bool isLan;
    /* 0x0004 */ int32_t playerCount;
    /* 0x0008 */ FName mapName;
};

// Size: 0xa8
struct FNetManState {
    /* 0x0020 */ FString lastError;
    /* 0x0030 */ FNetManLogin Login;
    /* 0x0048 */ FNetManSession session;
    /* 0x0060 */ FNetManSearch search;
    /* 0x0090 */ FNetManSchedule schedule;
};

// Size: 0xd0
class UNotificationBoard : public UActorComponent {

    bool HasPendingItem() const;
    void PushItem(FNotificationItem Item);
    FNotificationItem RetrievePendingItem();
};

// Size: 0x28
struct FNotificationItem {
    /* 0x0000 */ ENotificationPriority Priority;
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Desc;
};

// Size: 0x3f0
class UNotificationWidgetBase : public UUserWidget {

    float CalcDisplayTime(FNotificationItem Item) const;
    FNotificationItem GetItem(int32_t ID) const;
    bool IsAtCapacity() const;
    void ItemShowEnd(int32_t ID);
    void ItemShowStart(int32_t ID, FNotificationItem Item);
    bool ShouldHurry() const;
};

// Size: 0x28
class UNotify : public UBlueprintFunctionLibrary {

    static void High(UObject* WorldContextObject, FString Desc, FString Title);
    static void Low(UObject* WorldContextObject, FString Desc, FString Title);
    static void Medium(UObject* WorldContextObject, FString Desc, FString Title);
    static void Urgent(UObject* WorldContextObject, FString Desc, FString Title);
};

// Size: 0x468
class AOceanPlane : public AActor {
    /* 0x02a8 */ float TestMipBias;
    /* 0x02ac */ float TestWaterRoughness;
    /* 0x02b0 */ float TestFoamRoughness;
    /* 0x02b4 */ float TestWaterSpecular;
    /* 0x02b8 */ float TestFoamSpecular;
    /* 0x02bc */ int32_t CurrentSlice;
    /* 0x02c4 */ float Scale;
    /* 0x02c8 */ float LengthScale0;
    /* 0x02cc */ float LengthScale1;
    /* 0x02d0 */ float LengthScale2;
    /* 0x02d8 */ double MinimumCameraHeight;
    /* 0x02e0 */ double DisplacementFadeOutHeight;
    /* 0x02e8 */ double DisplacementFadeInHeight;
    /* 0x02f0 */ FOceanParameters SimulationParameters;
    /* 0x0340 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x0348 */ UMaterialInterface* SurfaceMaterial;
    /* 0x0350 */ UMaterialInterface* SurfaceMaterialNoMetaData;
    /* 0x0358 */ UMaterialInterface* SurfaceMaterialLOD;
    /* 0x0360 */ UMaterialInterface* SurfaceMaterialNoMetaDataLOD;
    /* 0x0368 */ UMaterialInterface* SliceMaterial;
    /* 0x0370 */ UMaterialInterface* SliceMaterialNoMetaData;
    /* 0x0378 */ EMipFilter MipFilter;
    /* 0x0379 */ EOceanSimulationFidelity SimulationFidelity;
    /* 0x037a */ bool bUsePreviousFrameTextures;
    /* 0x037c */ int32_t chunkSize;
    /* 0x0380 */ UMaterialInstanceDynamic* DynamicSurfaceMaterial;
    /* 0x0388 */ UMaterialInstanceDynamic* DynamicSurfaceMaterialLOD;
    /* 0x0390 */ UMaterialInstanceDynamic* DynamicSurfaceMaterialNoMetaData;
    /* 0x0398 */ UMaterialInstanceDynamic* DynamicSurfaceMaterialNoMetaDataLOD;
    /* 0x03a0 */ UTextureRenderTarget2D* DisplacementAndTurbulence0;
    /* 0x03a8 */ UTextureRenderTarget2D* Derivatives0;
    /* 0x03b0 */ UTextureRenderTarget2D* DisplacementPreviousFrame0;
    /* 0x03b8 */ UTextureRenderTarget2D* DerivativesPreviousFrame0;
    /* 0x03c0 */ UTextureRenderTarget2D* DisplacementAndTurbulence1;
    /* 0x03c8 */ UTextureRenderTarget2D* Derivatives1;
    /* 0x03d0 */ UTextureRenderTarget2D* DisplacementPreviousFrame1;
    /* 0x03d8 */ UTextureRenderTarget2D* DerivativesPreviousFrame1;
    /* 0x03e0 */ UTextureRenderTarget2D* DisplacementAndTurbulence2;
    /* 0x03e8 */ UTextureRenderTarget2D* Derivatives2;
    /* 0x03f0 */ UTextureRenderTarget2D* DisplacementPreviousFrame2;
    /* 0x03f8 */ UTextureRenderTarget2D* DerivativesPreviousFrame2;
    /* 0x0400 */ int32_t MeshResolution;
    /* 0x0404 */ float SliceHeight;
    /* 0x0408 */ int32_t ChunkMargin;
    /* 0x040c */ FIntVector Origin;
    /* 0x0418 */ UStaticMesh* FullSurfaceMesh;
    /* 0x0420 */ TArray<FOceanPlaneSlice> Slices;

    void ApplyTestMipBias();
    void SetReflectionParameters(float MipBias, float WaterRoughness, float FoamRoughness, float WaterSpecular, float FoamSpecular);
    void SetSimulationFidelity(EOceanSimulationFidelity NewFidelity);
    void SetTimeMultiplier(int32_t Multiplier);
    void SetWindSpeed(float windSpeed);
    void ToggleSimulation();
};

// Size: 0x10
struct FOceanPlaneChunk {
    /* 0x0000 */ UAsyncMeshBuilder* MeshBuilder;
    /* 0x0008 */ bool bFullSurface;
};

// Size: 0x48
struct FOceanPlaneSlice {
    /* 0x0000 */ TArray<FOceanPlaneChunk> Chunks;
    /* 0x0010 */ UAsyncMeshBuilder* MeshBuilder;
    /* 0x0018 */ UStaticMesh* InfiniteSurfaceMesh;
    /* 0x0020 */ UStaticMeshComponent* InfiniteSurfaceComponent;
    /* 0x0028 */ UStaticMesh* InfiniteSliceMesh;
    /* 0x0030 */ UStaticMeshComponent* InfiniteSliceComponent;
    /* 0x0038 */ UInstancedStaticMeshComponent* SurroundingSurfaceComponent;
    /* 0x0040 */ ETerrainSliceState State;
};

// Size: 0x88
struct FOptionChoice {
    /* 0x0000 */ FString ID;
    /* 0x0010 */ FString Title;
    /* 0x0020 */ FString Description;
    /* 0x0030 */ FString Category;
    /* 0x0040 */ bool ruleIsVisiblity;
    /* 0x0041 */ bool ruleIsLock;
    /* 0x0048 */ FString ruleTargetId;
    /* 0x0058 */ TArray<FString> ruleTargetValues;
    /* 0x0068 */ FString DefaultValue;
    /* 0x0078 */ TArray<FString> validValues;
};

// Size: 0xa0
struct FOptionConfig {
    /* 0x0000 */ TMap<FString, FOptionChoice> choices;
    /* 0x0050 */ TMap<FString, USoundClass*> audioClasses;
};

// Size: 0x348
class AOptionConfigMule : public AActor {
    /* 0x02a8 */ FOptionConfig OptionConfig;
};

// Size: 0x108
class UOptionManager : public UObject {
    /* 0x0040 */ FMulticastInlineDelegate onKeybindUpdated;
    /* 0x0050 */ FOptionConfig config;
    /* 0x00f0 */ UProfileManager* ProfileManager;
    /* 0x00f8 */ UBackbone* Backbone;
    /* 0x0100 */ UPixelFed* PixelFed;

    bool ApplyGraphics();
    int32_t GetAutosaveIntervalSeconds();
    FKey GetBoundKeyForOptionId(FString optionId, bool wantGamepad) const;
    TArray<FString> GetCategories() const;
    FKey GetDefaultKeyForKeybind(FString keybindOptionId) const;
    FOptionChoice GetOptionChoice(FString optionId) const;
    TArray<FString> GetOptionChoicesOfCategory(FString Category) const;
    FString GetValue(FString optionId) const;
    bool GetValueEnabled(FString optionId) const;
    bool HasValue(FString optionId) const;
    static bool IsKeybindConfigurable(FString KeyBind);
    static FString KeyToString(FKey Key);
    void ReapplyMouseLock();
    void ReloadKeybinds();
    void ReloadOptions();
    void ResetGraphicsToDefaults();
    void ResetKeybindsToDefaults();
    void ResetToDefaults();
    void SetValue(FString optionId, FString Value);
    static FKey StringToKey(FString Key);
};

// Size: 0x580
class AOrbitalCamera : public AControllablePawn {
    /* 0x0368 */ bool isMovable;
    /* 0x0369 */ bool ignoreInputs;
    /* 0x036a */ bool focusFollowsMouse;
    /* 0x036b */ bool centerFocus;
    /* 0x036c */ bool focusIsGrounded;
    /* 0x036d */ bool pawnIsGrounded;
    /* 0x036e */ bool cameraIsAboveGround;
    /* 0x0370 */ float cameraGroundClearance;
    /* 0x0374 */ float moveSpeedMin;
    /* 0x0378 */ float moveSpeedMax;
    /* 0x0380 */ TMap<EPlatformCategory, float> moveSpeedPlatformAdjuster;
    /* 0x03d0 */ float zoomSpeed;
    /* 0x03d4 */ float rotateSpeed;
    /* 0x03d8 */ bool rotationMaintainsFocus;
    /* 0x03e0 */ FRotator resetRotation;
    /* 0x03f8 */ FVector2D zoomDistances;
    /* 0x0408 */ float zoomStartRatio;
    /* 0x040c */ bool doAdjustFocusAfterZoom;
    /* 0x040d */ bool zoomIsSmooth;
    /* 0x0410 */ float zoomSmoothSpeed;
    /* 0x0414 */ bool zoomPushesAngle;
    /* 0x0418 */ FVector2D zoomGoalAngles;
    /* 0x0428 */ float zoomAnglePushSpeed;
    /* 0x042c */ float tiltSpeed;
    /* 0x0430 */ float tiltSpeed_altZoom;
    /* 0x0438 */ FVector2D tiltAngles;
    /* 0x0448 */ float tiltStartRatio;
    /* 0x044c */ float armYawOffset;
    /* 0x0450 */ float armHeightOffset;
    /* 0x0458 */ FVector2D mouseOrbitScale;
    /* 0x0468 */ float mouseOrbitCutoff;
    /* 0x046c */ float mouseOrbitTimeCutoff;
    /* 0x0470 */ bool isEdgeScrollEnabled;
    /* 0x0474 */ float edgeScrollSpeed;
    /* 0x0478 */ FVector2D edgeScrollSafeZone;
    /* 0x0488 */ bool enableDof;
    /* 0x048c */ float apetureClose;
    /* 0x0490 */ float apetureMid;
    /* 0x0494 */ float apetureFar;
    /* 0x0498 */ FVector topLeftBound;
    /* 0x04b0 */ FVector bottomRightBound;
    /* 0x04c8 */ bool isMouseNowOrbit;
    /* 0x04c9 */ bool isMouseNowDrag;
    /* 0x04ca */ bool isZoomNowTilt;
    /* 0x04cb */ bool isFocusRotationalSnap;
    /* 0x04d0 */ FVector2D lastFrameMousePosition;
    /* 0x04e0 */ FMulticastInlineDelegate onMouseOrbit;
    /* 0x04f0 */ FMulticastInlineDelegate onTilt;
    /* 0x0500 */ FMulticastInlineDelegate onMouseEdgePan;
    /* 0x0510 */ FVector lastMouseDragPoint;
    /* 0x0528 */ float rootZLevelForMouseDrag;
    /* 0x0530 */ FRotator StartRotation;
    /* 0x0548 */ float mouseOrbitChange;
    /* 0x054c */ float mouseOrbitTime;
    /* 0x0550 */ FVector guranteedSafetyPoint;
    /* 0x0568 */ UStaticMeshComponent* Mesh;
    /* 0x0570 */ UCineCameraComponent* Camera;
    /* 0x0578 */ USpringArmComponent* arm;

    void DumpStateToLog();
    bool FindWorldPositionAtScreenCenter(FVector& worldPos) const;
    void ResetCamera();
    void ResetFocus();
    void ResetOrbit();
};

// Size: 0x2a8
class UOreDistributor : public UActorComponent {
    /* 0x00f0 */ FRandomXorshiftWrapper Randomizer;
};

// Size: 0x38
struct FOreDistributorConfig {
    /* 0x0000 */ TArray<FOreDistributorOre> Ores;
    /* 0x0010 */ int32_t NonOreYield;
    /* 0x0014 */ float OreVeinGapChance;
    /* 0x0018 */ TArray<float> TraceDistances;
    /* 0x0028 */ TArray<FOreDistributorPlant> Plants;
};

// Size: 0x60
class UOreDistributorConfigMule : public UObject {
    /* 0x0028 */ FOreDistributorConfig config;
};

// Size: 0x28
struct FOreDistributorOre {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t Yield;
    /* 0x000c */ int32_t MinClusterSize;
    /* 0x0010 */ int32_t MaxClusterSize;
    /* 0x0014 */ float StraigthDepthClusterMultiplier;
    /* 0x0018 */ float AbsoluteDepthClusterMultiplier;
    /* 0x001c */ float MaxStrengthDepth;
    /* 0x0020 */ float LayerHeight;
    /* 0x0024 */ float LayerThickness;
};

// Size: 0x50
struct FOreDistributorPlant {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ int32_t Yield;
    /* 0x000c */ float BaseWeight;
    /* 0x0010 */ float AbsoluteHeightWeightBias;
    /* 0x0014 */ float RockWeightBias;
    /* 0x0018 */ float GrassWeightBias;
    /* 0x001c */ float BeachWeightBias;
    /* 0x0020 */ float ForestWeightBias;
    /* 0x0028 */ UClass* Noise;
    /* 0x0030 */ UNoise* LoadedNoise;
    /* 0x0038 */ int32_t MinClusterSize;
    /* 0x003c */ int32_t MaxClusterSize;
    /* 0x0040 */ int32_t Height;
    /* 0x0044 */ float MainIslandFertilityPercentage;
    /* 0x0048 */ float MainIslandMultiplicator;
};

// Size: 0xc
struct FOreLayerData {
};

// Size: 0x2
struct FOrientConfig {
    /* 0x0000 */ bool verticalOrient;
    /* 0x0001 */ bool autoPickTarget;
};

// Size: 0x8
struct FOrientState {
    /* 0x0000 */ USceneComponent* Target;
};

// Size: 0x90
class UPixelFed : public UObject {
    /* 0x0028 */ FPixelFedState State;
    /* 0x0088 */ UBackbone* Backbone;

    void FindFps(const UObject* WorldContext, float& fps, float& fpsSmoothed);
    bool GetShowFps() const;
};

// Size: 0x168
struct FPixelFedBackend {
    /* 0x0000 */ EPixelFedBackendId backendId;
    /* 0x0008 */ FString backendName;
    /* 0x0018 */ int32_t Version;
    /* 0x001c */ int32_t versionMinor;
    /* 0x0020 */ FName englishName;
    /* 0x0028 */ FPixelFedBackendChoices choices;
    /* 0x0160 */ bool isInstalled;
    /* 0x0161 */ bool isAvailable;
};

// Size: 0x138
struct FPixelFedBackendChoices {
    /* 0x0000 */ EPixelFedBackendId desiredBackendId;
    /* 0x0008 */ FString backendName;
    /* 0x0018 */ bool isAvailable;
    /* 0x0019 */ bool hasQualityChoices;
    /* 0x0020 */ FString qualitySettingKey;
    /* 0x0030 */ TArray<FName> qualityChoices;
    /* 0x0040 */ TMap<FName, int32_t> qualityChoiceToCVarValue;
    /* 0x0090 */ FName qualityActive;
    /* 0x0098 */ FName qualityPrefered;
    /* 0x00a0 */ bool hasFrameGenChoices;
    /* 0x00a8 */ FString frameGenSettingKey;
    /* 0x00b8 */ TArray<FName> frameGenChoices;
    /* 0x00c8 */ FName frameGenActive;
    /* 0x00d0 */ FName frameGenPrefered;
    /* 0x00d8 */ bool hasSharpnessChoices;
    /* 0x00e0 */ FString sharpnessSettingKey;
    /* 0x00f0 */ TArray<FName> sharpnessChoices;
    /* 0x0100 */ FName sharpnessActive;
    /* 0x0108 */ FName sharpnessPrefered;
    /* 0x0110 */ bool hasDynResChoices;
    /* 0x0118 */ TArray<FName> dynResChoices;
    /* 0x0128 */ FName dynResActive;
    /* 0x0130 */ FName dynResPrefered;
};

// Size: 0x38
struct FPixelFedConfiguration {
    /* 0x0000 */ EPixelFedBackendId backendId;
    /* 0x0001 */ bool qualitySet;
    /* 0x0004 */ FName qualityValue;
    /* 0x000c */ bool percentSet;
    /* 0x0010 */ int32_t overrideScreenPercentage;
    /* 0x0014 */ bool frameGenSet;
    /* 0x0018 */ FName frameGenValue;
    /* 0x0020 */ bool sharpnessSet;
    /* 0x0024 */ FName sharpnessValue;
    /* 0x002c */ bool dynResSet;
    /* 0x0030 */ FName dynResValue;
};

// Size: 0x18
struct FPixelFedFullChoiceState {
    /* 0x0000 */ EPixelFedBackendId activeBackendId;
    /* 0x0008 */ TArray<FPixelFedBackendChoices> backendChoices;
};

// Size: 0x60
struct FPixelFedState {
    /* 0x0000 */ TMap<EPixelFedBackendId, FPixelFedBackend> backends;
    /* 0x0050 */ int32_t frameGenMultiplier;
    /* 0x0054 */ bool showFps;
    /* 0x0058 */ float lastFrameFps;
    /* 0x005c */ EPixelFedBackendId platformPreferedBackendId;
    /* 0x005d */ EPixelFedBackendId activeBackendId;
    /* 0x005e */ EPixelFedBackendId playerPreferedBackendId;
};

// Size: 0x58
struct FPlaceableConfig {
    /* 0x0000 */ FString stringKey;
    /* 0x0010 */ FString inputsStringKey;
    /* 0x0020 */ FString outputsStringKey;
    /* 0x0030 */ bool snapToGrid;
    /* 0x0031 */ bool canHaveQuests;
    /* 0x0038 */ FGridArea footprint;
    /* 0x0050 */ UClass* industryClass;
};

// Size: 0x40
struct FPlacementTag {
    /* 0x0000 */ FIntVector position;
    /* 0x0010 */ FRotator Rotation;
    /* 0x0028 */ FString ClassPath;
    /* 0x0038 */ FName ID;
};

// Size: 0x8
struct FPlatformConfig {
    /* 0x0000 */ int32_t desiredControllerCount;
    /* 0x0004 */ bool highperf_systemDesired;
    /* 0x0005 */ bool highperf_playerDesired;
    /* 0x0006 */ bool renderUiOnly;
    /* 0x0007 */ bool wantDof;
};

// Size: 0x50
class UPlatformManager : public UObject {
    /* 0x0028 */ FPlatformConfig config;
    /* 0x0030 */ FString versionLabel;
    /* 0x0040 */ UBackbone* Backbone;
    /* 0x0048 */ UStoveIntegrator* stove;

    void All_UpdateLocalOverrideControls();
    void ConsiderHdr();
    static void ConsiderIfMouseAllowed(APlayerController* PlayerController);
    void DisableControllerMappings();
    static bool DoFixTextureOodleBroken(UTexture2D* TextureAsset);
    bool EnsureSaveAreaAvailable();
    static int32_t FindPlatformUserIndex();
    static int32_t GetMaxPlatformSaveFileCount();
    static bool IsTextureOodleBroken(UTexture2D* TextureAsset);
    void MarkCategoryOfNextSave(FString Category, FString Subtitle);
    void MarkDofEnabled(bool IsEnabled);
    void MarkDynamicResolutionEnabled(bool IsEnabled);
    void MarkOnScreenMessagesEnabled(bool IsEnabled);
    void MarkPerfMode_Preference(bool preferHighPerf);
    void MarkPerfMode_System(bool forceHighPerf);
    void MarkUiOnlyRendering(bool isUiOnly);
    bool OnSteamdeckEnsureAllInputsBound();
    bool OnSwitchEnsureSaveAreaAvailable();
    void OnSwitchModeChange(bool isBoosted);
    void PS4_SetupPlatformHooks();
    bool ReportRequiredPlayerCount(int32_t playerCount);
    bool Switch_CheckControllers(int32_t& desiredCount);
    static float TranslateAudoVolumeToNonLinear(float linearRatio);
};

// Size: 0x50
struct FPlayState {
    /* 0x0000 */ FStorageState storage;
};

// Size: 0x2d0
class APollutionConfigurator : public AActor {
    /* 0x02a8 */ FVector2f Wind;
    /* 0x02b0 */ float WindImpact;
    /* 0x02b4 */ float SourceMultiplier;
    /* 0x02b8 */ uint16_t ConstantDecay;
    /* 0x02bc */ float FractionalDecay;
    /* 0x02c0 */ uint16_t PropagationThreshold;
    /* 0x02c4 */ float DiffusionPressureFactor;
    /* 0x02c8 */ float PropagationSpeed;
    /* 0x02cc */ float BlockageFactor;

    static FVector GetWindDirection();
};

// Size: 0x270
class UPollutionSourceComponent : public USceneComponent {
    /* 0x0240 */ TArray<FIntVector> footprint;
    /* 0x0250 */ uint16_t pollutionPerSecond;
};

// Size: 0x4
struct FPollutionUpdateChunk {
    /* 0x0000 */ EPollutionUpdate UpdateType;
    /* 0x0001 */ uint8_t OffsetX;
    /* 0x0002 */ uint8_t OffsetY;
    /* 0x0003 */ uint8_t Z;
};

// Size: 0x28
struct FPopArg {
    /* 0x0000 */ FString Message;
    /* 0x0010 */ FLinearColor Color;
    /* 0x0020 */ UTexture2D* Icon;
};

// Size: 0x48
struct FPopConfig {
    /* 0x0000 */ bool Looping;
    /* 0x0004 */ float Lifetime;
    /* 0x0008 */ float fadeInTime;
    /* 0x000c */ float fadeOutTime;
    /* 0x0010 */ EEase heightEase;
    /* 0x0011 */ EEase fadeInEase;
    /* 0x0012 */ EEase fadeOutEase;
    /* 0x0014 */ float Height;
    /* 0x0018 */ FPopArg defaultArg;
    /* 0x0040 */ UClass* popWidgetClass;
};

// Size: 0x300
class APopConfigMule : public AActor {
    /* 0x02a8 */ FPopIssueConfig config;
    /* 0x02f8 */ bool allowPops;
};

// Size: 0x28
class UPopIssue : public UBlueprintFunctionLibrary {

    static void Bark(UObject* WorldContext, FVector Pos, FString Message);
    static void CityGrowPing(UObject* WorldContext, FVector Pos);
    static void Cost(UObject* WorldContext, FVector Pos, int32_t Cost);
    static FString GetMoneySign(UObject* WorldContext);
    static void Message(UObject* WorldContext, FVector Pos, FString Message);
    static void Profit(UObject* WorldContext, FVector Pos, int32_t Profit, bool isSalvage);
    static void Salvage(UObject* WorldContext, FVector Pos, int32_t Profit);
    static void Upkeep(UObject* WorldContext, FVector Pos, int32_t Cost);
    static void Warning(UObject* WorldContext, FVector Pos, FString Warning);
};

// Size: 0x50
struct FPopIssueConfig {
    /* 0x0000 */ TMap<EPopGroup, FPopConfig> groupConfigs;
};

// Size: 0x340
class APopNotice : public AActor {
    /* 0x02a8 */ FPopConfig config;
    /* 0x02f0 */ FPopState State;
    /* 0x0338 */ UWidgetComponent* widgetParent;
};

// Size: 0x48
struct FPopState {
    /* 0x0000 */ FPopArg arg;
    /* 0x0028 */ float Time;
    /* 0x0030 */ FVector StartOffset;
};

// Size: 0x340
class UPopWidgetBase : public UUserWidget {

    void SetArg(FPopArg newArg);
    void SetOpacity(float Opacity);
};

// Size: 0x3a0
class APositionalCamera : public AControllablePawn {
    /* 0x0368 */ float moveSpeed;
    /* 0x036c */ float zoomMin;
    /* 0x0370 */ float zoomMax;
    /* 0x0390 */ UUxTrackingCamera* trackingCamera;
    /* 0x0398 */ USceneComponent* Cursor;

    FVector AdjustPosition(FVector desired) const;
    bool IsBlocked(FVector In) const;
    void UpdatePosition();
};

// Size: 0x2d0
class UPreviewerComponent : public USceneComponent {
    /* 0x0240 */ FPreviewerConfig config;
    /* 0x0260 */ FPreviewerState State;
    /* 0x02c0 */ FPreviewerMembers M;

    void ApplyCollision(AActor* act) const;
    void ApplyMaterial(AActor* act, UMaterialInterface* mat) const;
    FVector CalcOffsetForCenter() const;
    FRotator CalculateRotation() const;
    void DisableParticles(AActor* act) const;
    FVector GetCurrentPosition() const;
    FVector GetGoalPosition() const;
    AActor* GetPreviewActor() const;
    void ProgressMovement(float deltaTime);
};

// Size: 0x20
struct FPreviewerConfig {
    /* 0x0000 */ float lagSpeed;
    /* 0x0004 */ float maxAngle;
    /* 0x0008 */ float hoverHeight;
    /* 0x000c */ float sizeDescaler;
    /* 0x0010 */ FVector2D Drag;
};

// Size: 0x8
struct FPreviewerMembers {
    /* 0x0000 */ UChildActorComponent* childActor;
};

// Size: 0x60
struct FPreviewerState {
    /* 0x0000 */ UClass* previewedActor;
    /* 0x0008 */ UMaterialInterface* OverrideMaterial;
    /* 0x0010 */ FVector latentPosition;
    /* 0x0028 */ FVector previewPosition;
    /* 0x0040 */ FRotator previewRotation;
    /* 0x0058 */ USceneComponent* followTarget;
};

// Size: 0x8
struct FProfileConfig {
    /* 0x0000 */ UClass* desiredSaveGameClass;
};

// Size: 0x2b0
class AProfileConfigMule : public AActor {
    /* 0x02a8 */ FProfileConfig config;
};

// Size: 0x88
class UProfileManager : public UObject {
    /* 0x0028 */ FProfileConfig config;
    /* 0x0030 */ UGenericSaveGame* primeSave;
    /* 0x0038 */ TMap<int32_t, UGenericSaveGame*> loadedSaves;
};

// Size: 0x340
class UProgressWidget : public UUserWidget {

    void SetDetails(FProgressWidgetDetails nd);
    void SetProgress(float R);
};

// Size: 0x18
struct FProgressWidgetDetails {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ float startRatio;
};

// Size: 0x40
struct FPropInfo {
    /* 0x0000 */ FInstaMeshTag Tag;
    /* 0x0008 */ FVector position;
    /* 0x0020 */ FRotator Rotation;
    /* 0x0038 */ float Scale;
};

// Size: 0x98
struct FPropPlan {
    /* 0x0000 */ TArray<UStaticMesh*> Meshes;
    /* 0x0010 */ EPropSpawnType spawnType;
    /* 0x0018 */ FVector Offset;
    /* 0x0030 */ FVector randomDist;
    /* 0x0048 */ float MinScale;
    /* 0x004c */ float MaxScale;
    /* 0x0050 */ float Weight;
    /* 0x0054 */ float chance;
    /* 0x0058 */ float minHeight;
    /* 0x005c */ float maxHeight;
    /* 0x0060 */ float minSteepness;
    /* 0x0064 */ float maxSteepness;
    /* 0x0068 */ float minNaturality;
    /* 0x006c */ float minAlternative;
    /* 0x0070 */ float maxAlternative;
    /* 0x0074 */ float minYaw;
    /* 0x0078 */ float maxYaw;
    /* 0x007c */ float minRoll;
    /* 0x0080 */ float maxRoll;
    /* 0x0084 */ float minPitch;
    /* 0x0088 */ float maxPitch;
    /* 0x008c */ bool bRotateToSlope;
    /* 0x0090 */ int32_t Density;
};

// Size: 0x10
struct FPropPlanSet {
    /* 0x0000 */ TArray<FPropPlan> plans;
};

// Size: 0x310
class UPropRigger : public USceneComponent {
    /* 0x0240 */ FPropRiggerConfig config;
    /* 0x02a8 */ FPropRiggerState State;
    /* 0x0308 */ AHoldingsRelay* relay;

    void SetClimate(EClimate NewClimate);
    void SetConfig(FPropRiggerConfig newConfig);
    void UpdateCell(const FIntVector& cell, bool bArtificial, bool bRespawn);
};

// Size: 0xb0
struct FPropRiggerCellState {
    /* 0x0000 */ FPropPlan plan;
    /* 0x0098 */ TArray<FPropInfo> SpawnedProps;
    /* 0x00a8 */ int32_t RandomSeed;
};

// Size: 0x68
struct FPropRiggerConfig {
    /* 0x0000 */ bool usePropsInShipping;
    /* 0x0008 */ TMap<EClimate, FPropPlanSet> planSets;
    /* 0x0058 */ FInstaMeshConfig InstaMeshConfig;
};

// Size: 0x310
class APropRiggerConfigMule : public AActor {
    /* 0x02a8 */ FPropRiggerConfig config;
};

// Size: 0x60
struct FPropRiggerState {
    /* 0x0000 */ UInstaMesh* InstaMesh;
    /* 0x0008 */ TMap<FIntVector, FPropRiggerCellState> CellStates;
    /* 0x0058 */ EClimate currentClimate;
};

// Size: 0x24
struct FQuest {
    /* 0x0000 */ FName Title;
    /* 0x0008 */ FName Description;
    /* 0x0010 */ FQuestCondition Condition;
    /* 0x0020 */ EQuestStage requiredStage;
    /* 0x0021 */ EQuestStage rewardStage;
};

// Size: 0x10
struct FQuestCondition {
    /* 0x0000 */ int32_t placementId;
    /* 0x0004 */ EQuestConditionRule ruleVariety;
    /* 0x0008 */ float requirement;
    /* 0x000c */ int32_t Filter;
};

// Size: 0x50
struct FQuestLibrary {
    /* 0x0000 */ TMap<FIntVector, FQuest> quests;
};

// Size: 0x28
struct FQuestProblem {
    /* 0x0000 */ EQuestProblemSeverity Severity;
    /* 0x0008 */ FString errorTitleStringId;
    /* 0x0018 */ FString errorDescStringId;
};

// Size: 0x50
struct FQuestSolveMetrics {
    /* 0x0000 */ TMap<EQuestConditionRule, float> Values;
};

// Size: 0xb8
struct FQuestSolveState {
    /* 0x0000 */ EQuestStage unlockedStage;
    /* 0x0008 */ TMap<FIntVector, FQuestSolveMetrics> metrics;
    /* 0x0058 */ TMap<FIntVector, bool> evaluationStatus;
    /* 0x00a8 */ TArray<FIntVector> valuationOrder;
};

// Size: 0x148
class UQuestSolver : public UObject {
    /* 0x0028 */ FQuestLibrary Library;
    /* 0x0078 */ FQuestSolveState State;
    /* 0x0130 */ UHoldingsManagerComponent* holdingsMan;
    /* 0x0138 */ FMulticastInlineDelegate OnStageChange;

    void ApplyLibrary(FQuestLibrary newLib);
    FQuestStatusReport CalcReport() const;
    FIntVector FindAttentionPoint();
    EQuestStage GetUnlockedStage() const;
    void LinkHoldings(UHoldingsManagerComponent* nh);
    void ReportMetric(FIntVector Loc, EQuestConditionRule metric, float X, int32_t Filter);
    static FQuestValidation ValidateLibrary(const FQuestLibrary& L);
};

// Size: 0x48
struct FQuestStatus {
    /* 0x0000 */ bool solved;
    /* 0x0008 */ FString Title;
    /* 0x0018 */ FString Description;
    /* 0x0028 */ FString goalHintKeyId;
    /* 0x0038 */ float Numerator;
    /* 0x003c */ float Denominator;
    /* 0x0040 */ EQuestStatusUnit counterUnit;
};

// Size: 0x18
struct FQuestStatusReport {
    /* 0x0000 */ bool Show;
    /* 0x0001 */ bool wasValid;
    /* 0x0008 */ TArray<FQuestStatus> statuses;
};

// Size: 0x18
struct FQuestValidation {
    /* 0x0000 */ bool wasValid;
    /* 0x0008 */ TArray<FQuestProblem> problems;
};

// Size: 0x10
struct FRankStatus {
    /* 0x0000 */ EResultRank Rank;
    /* 0x0004 */ int32_t goalSeconds;
    /* 0x0008 */ int32_t currentSeconds;
    /* 0x000c */ int32_t remainingSeconds;
};

// Size: 0x270
class URestlessMotionComponent : public USceneComponent {
    /* 0x0240 */ float motionRange;
    /* 0x0244 */ float motionPeriod;
    /* 0x0248 */ FVector basePosition;
    /* 0x0260 */ double Time;
};

// Size: 0x58
struct FRuntimeLang {
    /* 0x0000 */ FName Language;
    /* 0x0008 */ TMap<FName, FString> keyToWord;
};

// Size: 0xf8
class USaveLibrary : public UObject {
    /* 0x0028 */ FSaveLibraryState State;

    bool DeleteFromDisk(FString Filename);
    static FString FilterEditableString(FString InString, int32_t maxLength);
    static FString FilterFileName(FString InName);
    static FString FilterNumbericalEntry(FString InName, int32_t MinValue, int32_t MaxValue);
    FString GenerateNonConflictingName(FString Filename);
    FSaveLibraryIndex GetSaveIndex() const;
    bool HasOpenSlot() const;
    bool HasSaveByName(FString Filename);
    bool HasSlotForFilename(FString Filename) const;
    void ReportSaveDeletion(FString Filename);
};

// Size: 0x90
struct FSaveLibraryEntry {
    /* 0x0000 */ FName ID;
    /* 0x0008 */ int64_t Timestamp;
    /* 0x0010 */ FString Filename;
    /* 0x0020 */ FString Title;
    /* 0x0030 */ TMap<FString, FString> Attributes;
    /* 0x0080 */ UTexture2D* Thumbnail;
    /* 0x0088 */ UTextureRenderTarget2D* thumbnailRT;
};

// Size: 0x10
struct FSaveLibraryIndex {
    /* 0x0000 */ TArray<FSaveLibraryEntry> Entries;
};

// Size: 0xd0
struct FSaveLibraryState {
    /* 0x0000 */ UBackbone* Backbone;
    /* 0x0008 */ FSaveLibraryIndex Index;
    /* 0x0018 */ TMap<int32_t, FString> slotToSavename;
    /* 0x0068 */ TMap<FString, int32_t> savenameToSlot;
    /* 0x00b8 */ TArray<int32_t> openSlots;
};

// Size: 0x38
struct FSaveSelectItem {
    /* 0x0000 */ FName saveId;
    /* 0x0008 */ FName mapId;
    /* 0x0010 */ FName Version;
    /* 0x0018 */ TArray<FName> Flags;
    /* 0x0028 */ int32_t playtime;
    /* 0x0030 */ UTexture2D* graphic;
};

// Size: 0x18
struct FSaveSelectState {
    /* 0x0000 */ TArray<FSaveSelectItem> Items;
    /* 0x0010 */ int32_t activeIndex;
};

// Size: 0x3c8
class USaveSelectUi : public UNaviUi {
    /* 0x03a8 */ FSaveSelectState State;
    /* 0x03c0 */ UDataTable* mapTable;

    void HideConfirm();
    void MarkActiveIndex(int32_t Index);
    void ShowConfirm(FNaviConfirm conf);
    void UpdateDisplay(FSaveSelectState ns);
};

// Size: 0x210
struct FSessionBundle {
    /* 0x0000 */ FMapDataHolding mapData;
    /* 0x01c0 */ FPlayState PlayState;
};

// Size: 0x28
class UShaderCompileHelper : public UBlueprintFunctionLibrary {

    static int32_t GetPendingShaderCompilationCount();
    static bool IsCompilingShaders();
};

// Size: 0x50
struct FShopItem {
    /* 0x0000 */ int32_t Cost;
    /* 0x0008 */ FString nameStringKey;
    /* 0x0018 */ FString descStringKey;
    /* 0x0028 */ FName unlockId;
    /* 0x0030 */ FString Category;
    /* 0x0040 */ bool canBuy;
    /* 0x0041 */ bool alreadyOwns;
    /* 0x0042 */ EIconGroup iconGroup;
    /* 0x0044 */ FName iconKey;
};

// Size: 0x4
struct FShopMetaStatus {
    /* 0x0000 */ int32_t Money;
};

// Size: 0x18
struct FShopState {
    /* 0x0000 */ TArray<FShopItem> Items;
    /* 0x0010 */ FShopMetaStatus Status;
};

// Size: 0x418
class UShopUi : public UNaviUi {
    /* 0x03a8 */ FShopState State;
    /* 0x03c0 */ FShopItem desiredItem;
    /* 0x0410 */ UDataTable* unlockTable;

    void HideConfirm();
    void ShowConfirm(FNaviConfirm conf);
    void UpdateDisplay(FShopState ns);
};

// Size: 0x180
class USmallHoldComponent : public UActorComponent {
    /* 0x00b8 */ TArray<FIntPair> db_raw;
    /* 0x00c8 */ TMap<FName, int32_t> db;
    /* 0x0118 */ TArray<FStringPair> db_strings_raw;
    /* 0x0128 */ TMap<FName, FName> db_strings;
    /* 0x0178 */ bool isNumDelayed;
    /* 0x0179 */ bool isStringDelayed;

    bool Find(FName Key, int32_t& Value) const;
    bool FindString(FName Key, FName& Value) const;
    void FlushDelays();
    bool Has(FName Key) const;
    bool HasString(FName Key) const;
    void OnRep_Num();
    void OnRep_String();
    int32_t Read(FName Key) const;
    FName ReadString(FName Key) const;
    TArray<FName> ScanByPrefix(FString Prefix) const;
    void Write(const FName& Key, int32_t val);
    void WriteDelayed(const FName& Key, int32_t val);
    void WriteString(FName Key, FName val);
    void WriteStringDelayed(FName Key, FName val);
};

// Size: 0xa8
struct FSnapclipConfig {
    /* 0x0000 */ FVector2D Resolution;
    /* 0x0010 */ FVector uniformSize;
    /* 0x0028 */ bool isOrtho;
    /* 0x002c */ float cameraFov;
    /* 0x0030 */ bool isCanvasFill;
    /* 0x0031 */ bool isSubjectOnly;
    /* 0x0032 */ bool autoCenterSubject;
    /* 0x0038 */ FVector cameraPosition;
    /* 0x0050 */ FVector subjectPosition;
    /* 0x0068 */ FRotator subjectRotation;
    /* 0x0080 */ FLinearColor ClearColor;
    /* 0x0090 */ FVector faraway;
};

// Size: 0x360
class ASnapclipConfigMule : public AActor {
    /* 0x02a8 */ FSnapclipManagerConfig config;
};

// Size: 0x138
class USnapclipManager : public UObject {
    /* 0x0028 */ FSnapclipManagerConfig config;
    /* 0x00e0 */ TMap<UClass*, UTexture2D*> Cache;
    /* 0x0130 */ ASnapclipMule* mule;

    void DoPreCache();
    UTexture2D* GetSnapclip(const UObject* WorldContext, UClass* Subject);
};

// Size: 0xb8
struct FSnapclipManagerConfig {
    /* 0x0000 */ FSnapclipConfig defaultRenderConfig;
    /* 0x00a8 */ TArray<FString> booksToPreRender;
};

// Size: 0x2b0
class ASnapclipMule : public AActor {
    /* 0x02a8 */ USnapclipRecorder* recorder;
};

// Size: 0x60
struct FSnapclipOrder {
    /* 0x0000 */ TArray<UClass*> Targets;
    /* 0x0010 */ TMap<UClass*, UTexture2D*> renders;
};

// Size: 0x300
class USnapclipRecorder : public USceneComponent {
    /* 0x0240 */ FSnapclipConfig config;
    /* 0x02e8 */ USceneCaptureComponent2D* capture2d;
    /* 0x02f0 */ UChildActorComponent* childActor;

    UTexture2D* RenderActor(UClass* C);
    void RenderOrder(FSnapclipOrder& order);
    void SetConfig(FSnapclipConfig nc);
};

// Size: 0x10
struct FSplitWordCombo {
    /* 0x0000 */ TArray<FSplitWordEntry> splits;
};

// Size: 0x18
struct FSplitWordEntry {
    /* 0x0000 */ FString word;
    /* 0x0010 */ bool isNewline;
};

// Size: 0x28
class UStagePrep : public UBlueprintFunctionLibrary {

    static bool DeleteMap(EWarehouseLocation warehouse, FName stageId);
    static FName GenerateFreshStageId();
    static FString GetCustomDirectory();
    static FString GetPrimeDirectory();
    static FString GetSaveDirectory();
    static FString GetStageExtension();
    static FString GetStagePath(EWarehouseLocation Location, FName stageId);
    static bool HasStageIds(EWarehouseLocation Location);
    static TArray<FString> ListStageIds(EWarehouseLocation Location);
    static bool MemorizeStageToDisk(const UObject* WorldContext, EWarehouseLocation warehouse, FName stageId);
    static bool SpawnStageFromDisk(const UObject* WorldContext, EWarehouseLocation warehouse, FName stageId, TArray<AActor*>& spawnedActors);
};

// Size: 0xc0
class UStagePrepEntity : public UActorComponent {
    /* 0x00b8 */ FName EntityID;
};

// Size: 0xe8
struct FStagePrepEntityState {
    /* 0x0000 */ FName EntityID;
    /* 0x0008 */ FString ClassPath;
    /* 0x0018 */ FVector Location;
    /* 0x0030 */ FRotator Rotation;
    /* 0x0048 */ TMap<FName, int32_t> Data;
    /* 0x0098 */ TMap<FName, FName> Names;
};

// Size: 0x78
struct FStagePrepState {
    /* 0x0000 */ FStagePrepSummery summery;
    /* 0x0028 */ TMap<FName, FStagePrepEntityState> Entities;
};

// Size: 0x28
struct FStagePrepSummery {
    /* 0x0000 */ FName stageId;
    /* 0x0008 */ FString titleStringId;
    /* 0x0018 */ FString descStringId;
};

// Size: 0x290
class UStatefulCursor : public USceneComponent {
    /* 0x0240 */ FCursorDetails details;
    /* 0x0270 */ UStaticMeshComponent* Mesh;
    /* 0x0278 */ USpringArmComponent* springArm;
    /* 0x0280 */ USceneComponent* rotationTaker;

    FCursorDetails GetDetails() const;
    void GotoState(ECursorState NextState);
    void SetDetails(FCursorDetails nextDetails);
};

// Size: 0x28
class UStaticInputConfig : public UBlueprintFunctionLibrary {

    static FName Action_AddTrainCar();
    static FName Action_Back();
    static FName Action_Back_Mouse();
    static FName Action_BranchAlt();
    static FName Action_BuyTrain();
    static FName Action_Cheat();
    static FName Action_ClearTrainCars();
    static FName Action_Clone();
    static FName Action_ConfigureTrain();
    static FName Action_CycleToolsLeft();
    static FName Action_CycleToolsRight();
    static FName Action_DepthOfField();
    static FName Action_EnterTrainCam();
    static FName Action_Fire();
    static FName Action_FollowTrain();
    static FName Action_Hire();
    static FName Action_Lower();
    static FName Action_MakerModifierKey();
    static FName Action_NextCam();
    static FName Action_NextColor();
    static FName Action_NextFilter();
    static FName Action_NextSong();
    static FName Action_Orbit();
    static FName Action_Orbit_Mouse();
    static FName Action_Pause();
    static FName Action_PlaySong();
    static FName Action_PrevCam();
    static FName Action_PrevColor();
    static FName Action_PrevFilter();
    static FName Action_PrevSong();
    static FName Action_QuestDetails();
    static FName Action_Raise();
    static FName Action_RemoveTrainCar();
    static FName Action_ResetCamera();
    static FName Action_RotateObject();
    static FName Action_RotateTrain();
    static FName Action_Screenshot();
    static FName Action_Select();
    static FName Action_Select_Mouse();
    static FName Action_SellTrain();
    static FName Action_ShowEngineDetails();
    static FName Action_StopTrain();
    static FName Action_SwitchToBank();
    static FName Action_SwitchToBuilding();
    static FName Action_SwitchToCliffforming();
    static FName Action_SwitchToDelete();
    static FName Action_SwitchToMakerDelete();
    static FName Action_SwitchToNewIndustry();
    static FName Action_SwitchToNewTrain();
    static FName Action_SwitchToPatching();
    static FName Action_SwitchToPlacing();
    static FName Action_SwitchToRail();
    static FName Action_SwitchToRoading();
    static FName Action_SwitchToStaticPropPlacing();
    static FName Action_SwitchToStation();
    static FName Action_SwitchToTerraforming();
    static FName Action_SwitchToVoucher();
    static FName Action_ToggleDaytime();
    static FName Action_ToggleGrid();
    static FName Action_ToggleHud();
    static FName Action_Undo();
    static FName Action_Upgrade();
    static FName Axis_LookRotate_Analog();
    static FName Axis_PanForward_Analog();
    static FName Axis_PanForward_DPad();
    static FName Axis_PanForward_Kb();
    static FName Axis_PanRight_Analog();
    static FName Axis_PanRight_DPad();
    static FName Axis_PanRight_Kb();
    static FName Axis_Tilt_Analog();
    static FName Axis_Tilt_Kb();
    static FName Axis_Tophat();
    static FName Axis_Zoom_Analog();
    static FName Axis_Zoom_Mouse();
};

// Size: 0x28
class UStaticSound : public UObject {

    static void Screenspace(UObject* WorldContext, FName sfxName);
    static void Worldspace(UObject* WorldContext, FVector Pos, FName sfxName);
};

// Size: 0x28
class UStaticStageConfig : public UBlueprintFunctionLibrary {

    static FName C2OverWorld();
    static FName CreditWorld();
    static FName DemoEnd();
    static void EditMap(const UObject* WorldContext, FString mapId);
    static int32_t FindUserIndex();
    static int32_t GetDlc1StoreId();
    static FString GetDlc1StorePageUrl();
    static int32_t GetWhisketwoodStoreId();
    static FString GetWhisketwoodStorePageUrl();
    static FName MainMenu();
    static FName MapEditor();
    static FName MovieWorld();
    static void OpenDiscordInvite(const UObject* WorldContext);
    static void OpenDiscussionPage(const UObject* WorldContext);
    static void OpenDlc1StorePage(const UObject* WorldContext);
    static void OpenLegalAgreement(const UObject* WorldContext);
    static void OpenNewsletterPage(const UObject* WorldContext);
    static void OpenRedditPage(const UObject* WorldContext);
    static void OpenStorePage(const UObject* WorldContext);
    static void OpenSupportEmail(const UObject* WorldContext);
    static void OpenTwitterPage(const UObject* WorldContext);
    static void OpenWhiskerwoodStorePage(const UObject* WorldContext);
    static void OpenWorkshop(const UObject* WorldContext);
    static FName OverWorld();
    static void PlayFreeRoam(const UObject* WorldContext);
    static void PlayFreeRoamC2(const UObject* WorldContext);
    static void PlayMainMenu(const UObject* WorldContext);
    static void PlayMap(const UObject* WorldContext, FString mapId);
    static void PlayMapCheckpoint(const UObject* WorldContext, FString mapId);
    static void PlayMapFromEditor(const UObject* WorldContext, FString mapId);
    static void PlayMapSave(const UObject* WorldContext, FString mapId);
    static void PlayMovie(const UObject* WorldContext, FString movieName);
    static void PlaySandbox(const UObject* WorldContext);
    static void PlayTheatre(const UObject* WorldContext, FString playId);
    static FName PlayWorld();
    static void QuitGame(const UObject* WorldContext);
    static FName Sandbox();
    static void ShowLoadCover(const UObject* WorldContext);
    static FName StoryEnd();
    static FName TheatreWorld();
};

// Size: 0x28
class UStaticUiConfig : public UBlueprintFunctionLibrary {

    static int32_t UiLayerDialog();
    static int32_t UiLayerGuide();
    static int32_t UiLayerHud();
    static int32_t UiLayerLoading();
    static int32_t UiLayerMenu();
    static int32_t UiLayerWindow();
};

// Size: 0x38
struct FSteamWorkshopMapState {
    /* 0x0000 */ ESteamWorkshopDownloadStatus Status;
    /* 0x0008 */ FString workshopPath;
    /* 0x0018 */ FString Name;
    /* 0x0028 */ int64_t workshopId;
    /* 0x0030 */ int64_t byteSize;
};

// Size: 0x28
class USteamWorkshopUtil : public UObject {

    static bool OpenSteamStorePageInOverlay(int32_t storeId);
};

// Size: 0x50
struct FStorageBox {
    /* 0x0000 */ TMap<FName, double> Items;
};

// Size: 0x10
struct FStorageConfig {
    /* 0x0000 */ FName globalBox;
    /* 0x0008 */ FName defaultBox;
};

// Size: 0x2f0
class UStorageKeeper : public USceneComponent {
    /* 0x0240 */ FStorageConfig config;
    /* 0x0250 */ FStorageState State;
    /* 0x02a0 */ TMap<FName, FName> Groups;
};

// Size: 0x50
struct FStorageState {
    /* 0x0000 */ TMap<FName, FStorageBox> Boxes;
};

// Size: 0x10
struct FStoryConfig {
    /* 0x0000 */ UDataTable* storyTable;
    /* 0x0008 */ FName fallbackPageId;
};

// Size: 0x2b8
class AStoryConfigMule : public AActor {
    /* 0x02a8 */ FStoryConfig config;
};

// Size: 0x40
class UStoryManager : public UObject {
    /* 0x0028 */ UBackbone* Backbone;
    /* 0x0030 */ FStoryConfig config;

    void ClearStory(const UObject* WorldContext, EStorySlot story);
    void ContinueStory(const UObject* WorldContext, EStorySlot story);
    bool GotoPageInStory(const UObject* WorldContext, EStorySlot story, FName startPageId);
    bool InAnyStory(EStorySlot& story) const;
    bool IsStoryActive(EStorySlot story) const;
    bool LeaveAnyStory();
    bool ProgressStory(const UObject* WorldContext, EStorySlot story);
};

// Size: 0x28
struct FStoryPage {
    /* 0x0000 */ FName ID;
    /* 0x0008 */ FName nextPageId;
    /* 0x0010 */ EStoryOps Operation;
    /* 0x0018 */ TArray<FString> args;
};

// Size: 0x10
struct FStoryPlan {
    /* 0x0000 */ TArray<FStoryPage> pages;
};

// Size: 0x38
struct FStoryRow : public FTableRowBase {
    /* 0x0008 */ FName nextPageId;
    /* 0x0010 */ EStoryOps Operation;
    /* 0x0018 */ FString arg_1;
    /* 0x0028 */ FString arg_2;
};

// Size: 0x28
class UStoveIntegrator : public UObject {
};

// Size: 0x10
struct FStringPair {
    /* 0x0000 */ FName Key;
    /* 0x0008 */ FName val;
};

// Size: 0x390
class USunComponent : public USceneComponent {
    /* 0x0240 */ FSunConfig config;
    /* 0x0380 */ UDirectionalLightComponent* sun;
    /* 0x0388 */ USkyLightComponent* ambient;

    void ApplyConfig(FSunConfig nc);
    float PullDarkness();
    float PullDayPoint();
    void ReportClimate(EClimate nextClimate);
    void UpdateLights();
    void UpdateShadowDistance();
};

// Size: 0x140
struct FSunConfig {
    /* 0x0000 */ float brightnessFull;
    /* 0x0004 */ float brightnessNone;
    /* 0x0008 */ FRotator Angle;
    /* 0x0020 */ float sourceAngle;
    /* 0x0024 */ float sourceSoftAngle;
    /* 0x0028 */ FLinearColor colorDay;
    /* 0x0038 */ FLinearColor colorNight;
    /* 0x0048 */ bool useTempereture;
    /* 0x004c */ float lightTemperature;
    /* 0x0050 */ bool isAtmoSun;
    /* 0x0054 */ float shadowSharpen;
    /* 0x0058 */ FVector2D cameraDistanceBand;
    /* 0x0068 */ FVector2D shadowDistanceBand;
    /* 0x0078 */ FVector2D shadowSharpenBand;
    /* 0x0088 */ float sunContactShadowLength;
    /* 0x008c */ float shadowCascadeCount;
    /* 0x0090 */ float shadowDistroExpo;
    /* 0x0094 */ float shadowTransitionFraction;
    /* 0x0098 */ bool ambientIsCatpuredDuringDay;
    /* 0x009c */ FLinearColor ambientColorDay;
    /* 0x00ac */ FLinearColor ambientColorNight;
    /* 0x00bc */ float ambientBrightnessFull;
    /* 0x00c0 */ float ambientBrightnessNone;
    /* 0x00c4 */ bool ambientBlackBottom;
    /* 0x00c8 */ FLinearColor ambientBottomColor;
    /* 0x00d8 */ UTextureCube* AmbientCubemap;
    /* 0x00e0 */ TMap<EClimate, UTextureCube*> climateCubemapOverride;
    /* 0x0130 */ UMaterialInterface* lightFunction;
    /* 0x0138 */ UMaterialParameterCollection* weatherParameterCollection;
};

// Size: 0x3e8
class ASunConfigMule : public AActor {
    /* 0x02a8 */ FSunConfig config;
};

// Size: 0x30
struct FTeachBatch {
    /* 0x0000 */ FString windowTitleKey;
    /* 0x0010 */ FString batchTitleKey;
    /* 0x0020 */ TArray<FTeachLesson> lessons;
};

// Size: 0x20
struct FTeachBatchPlan {
    /* 0x0000 */ FString batchTitleKey;
    /* 0x0010 */ TArray<FTeachLessonPlan> lessons;
};

// Size: 0x158
class UTeachComponent : public UActorComponent {
    /* 0x00b8 */ FTeachConfig config;
    /* 0x00d8 */ FTeachSessionPlan currentPlan;
    /* 0x0108 */ int32_t currentBatch;
    /* 0x010c */ bool hasLiveBatch;
    /* 0x0110 */ FTeachBatch liveBatch;
    /* 0x0140 */ UTeachWidget* batchWindow;
    /* 0x0148 */ float timeNextPending;
    /* 0x0150 */ USmallHoldComponent* smallHold;

    UUserWidget* GetBatchWindow();
    bool IsTeaching() const;
    bool NextBatch();
    bool StartTeaching(FTeachSessionPlan plan, USmallHoldComponent* newSmallHold);
};

// Size: 0x20
struct FTeachConfig {
    /* 0x0000 */ bool doAutoNext;
    /* 0x0004 */ float autoNextWait;
    /* 0x0008 */ FString windowStringKey;
    /* 0x0018 */ UClass* windowClass;
};

// Size: 0x20
struct FTeachLesson {
    /* 0x0000 */ FString stringKey;
    /* 0x0010 */ bool hasLearned;
    /* 0x0018 */ ATeachLessonHandler* handler;
};

// Size: 0x2a8
class ATeachLessonHandler : public AActor {

    bool IsLearned();
};

// Size: 0x68
struct FTeachLessonPlan {
    /* 0x0000 */ FString stringKey;
    /* 0x0010 */ TMap<EPlatformCategory, FString> overrideStringKeys;
    /* 0x0060 */ UClass* handlerClass;
};

// Size: 0x30
struct FTeachSessionPlan {
    /* 0x0000 */ FTeachConfig config;
    /* 0x0020 */ TArray<FTeachBatchPlan> batches;
};

// Size: 0x2d8
class ATeachSessionPlanMule : public AActor {
    /* 0x02a8 */ FTeachSessionPlan plan;
};

// Size: 0x340
class UTeachWidget : public UUserWidget {

    void ClearDisplay();
    void UpdateDisplay(FTeachBatch Data);
    void UpdateTimer(float Seconds);
};

// Size: 0x10
struct FTerrainBlockLocation {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ int32_t Index;
};

// Size: 0x24
struct FTerrainCell {
    /* 0x0000 */ uint8_t TypesAndFlags;
    /* 0x0001 */ uint8_t Health;
    /* 0x0002 */ uint8_t Nutrients;
    /* 0x0003 */ uint8_t Rocks;
    /* 0x0004 */ uint16_t OreTracesOrPollution;
    /* 0x0006 */ uint16_t UpdatedPollution;
    /* 0x0008 */ int32_t FarmCellIndex;
    /* 0x000c */ int32_t PollutionCellIndex;
    /* 0x0010 */ int32_t DecayCellIndex;
    /* 0x0014 */ uint16_t CumulativeHeat;
    /* 0x0016 */ uint8_t EffectiveHeatOrVerticalDepth;
    /* 0x0017 */ uint8_t LightOrStraightDepth;
    /* 0x0018 */ float WindStrength;
    /* 0x001c */ float FanPressure;
    /* 0x0020 */ ETerrainBlockage Blockage;
    /* 0x0021 */ uint8_t WaterHeight;
    /* 0x0022 */ int16_t DeltaHeat;
};

// Size: 0x8
struct FTerrainCell2D {
    /* 0x0000 */ uint8_t NutrientLimit;
    /* 0x0001 */ uint8_t NutrientLimitOverflow;
    /* 0x0002 */ uint8_t Beach;
    /* 0x0003 */ int8_t SurfaceHeight;
    /* 0x0004 */ int32_t WaterEnclosureIndex;
};

// Size: 0x160
struct FTerrainCellTypeLibrary {
};

// Size: 0x10
struct FTerrainCoverIndices {
    /* 0x0000 */ int32_t Directions[4];
};

// Size: 0x58
struct FTerrainCoverInstances {
    /* 0x0000 */ UInstancedStaticMeshComponent* Meshes;
    /* 0x0008 */ TMap<FIntPoint, FTerrainCoverIndices> Indices;
};

// Size: 0x1c
struct FTerrainDecayCell {
    /* 0x0000 */ FIntVector DataLocation;
    /* 0x000c */ int32_t CellIndex;
    /* 0x0010 */ float MineAgeCountdown;
    /* 0x0014 */ float OceanFloorWetnessCountdown;
    /* 0x0018 */ uint8_t MineAge;
    /* 0x0019 */ uint8_t OceanFloorWetness;
};

// Size: 0x48
struct FTerrainFarmCell {
    /* 0x0000 */ FIntVector DataLocation;
    /* 0x000c */ int32_t CellIndex;
    /* 0x0010 */ int32_t FieldIndex;
    /* 0x0014 */ float PendingNutrientChange;
    /* 0x0018 */ int32_t CropIndex;
    /* 0x001c */ float ElapsedGrowth;
    /* 0x0020 */ float PotentialYield;
    /* 0x0024 */ float FrostCheckCountdown;
    /* 0x0028 */ float StarvationCheckCountdown;
    /* 0x002c */ int32_t GrowingNumberCached;
    /* 0x0030 */ TArray<uint8_t> CropStates;
    /* 0x0040 */ uint8_t HarvestedYield;
};

// Size: 0x80
struct FTerrainFarmField {
    /* 0x0000 */ int32_t CropIndex;
    /* 0x0004 */ uint8_t EarlyHarvestActive;
    /* 0x0005 */ uint8_t FertilizerActive;
    /* 0x0006 */ uint8_t RemovingRocksActive;
    /* 0x0007 */ uint8_t HasTendingFarmer;
    /* 0x0008 */ TMap<int32_t, float> YieldRemainders;
    /* 0x0058 */ ETerrainFarmFieldPhase Phase;
    /* 0x0074 */ int32_t GrowingCellNumberCached;
    /* 0x0078 */ int32_t SownCellNumberCached;
};

// Size: 0x2f0
class UTerrainGenerator : public UActorComponent {
    /* 0x02a0 */ UNoise* LoadedTerrainNoise;
    /* 0x02a8 */ UNoise* LoadedRockNoise;
    /* 0x02b0 */ UNoise* LoadedGrassNoise;
    /* 0x02b8 */ UNoise* LoadedBeachNoise;
    /* 0x02c0 */ UNoise* LoadedShoreNoise128;
    /* 0x02c8 */ UNoise* LoadedIslandNoise256;
    /* 0x02d0 */ UNoise* LoadedIslandNoise512;
    /* 0x02d8 */ UNoise* LoadedIslandNoise1024;
    /* 0x02e0 */ UNoise* LoadedModificationNoise;
    /* 0x02e8 */ UNoise* LoadedOceanFloorNoise;
};

// Size: 0x1c0
struct FTerrainGeneratorConfig {
    /* 0x0000 */ TMap<ETerrainGeneratorIslandGeology, FTerrainGeneratorIslandParameters> IslandParameters;
    /* 0x0050 */ UClass* TerrainNoise;
    /* 0x0058 */ UClass* GrassNoise;
    /* 0x0060 */ UClass* RockNoise;
    /* 0x0068 */ UClass* BeachNoise;
    /* 0x0070 */ float BeachOffset;
    /* 0x0074 */ float BeachDistanceWeight;
    /* 0x0078 */ float BeachNoiseMin;
    /* 0x007c */ int32_t OceanFloorDepth;
    /* 0x0080 */ float SurfaceBias;
    /* 0x0084 */ float CenterDistance;
    /* 0x0088 */ float GoldIslandChance;
    /* 0x0090 */ TMap<int32_t, ETerrainGeneratorOreFactor> MainOreFactors;
    /* 0x00e0 */ TMap<int32_t, ETerrainGeneratorOreFactor> SecondaryOreFactors;
    /* 0x0130 */ TMap<int32_t, ETerrainGeneratorOreFactor> TertiaryOreFactors;
    /* 0x0180 */ TArray<float> OreBiases;
    /* 0x0190 */ UClass* ShoreNoise128;
    /* 0x0198 */ UClass* IslandNoise256;
    /* 0x01a0 */ UClass* IslandNoise512;
    /* 0x01a8 */ UClass* IslandNoise1024;
    /* 0x01b0 */ UClass* ModificationNoise;
    /* 0x01b8 */ UClass* OceanFloorNoise;
};

// Size: 0x1e8
class UTerrainGeneratorConfigMule : public UObject {
    /* 0x0028 */ FTerrainGeneratorConfig config;
};

// Size: 0x108
struct FTerrainGeneratorIsland {
};

// Size: 0x28
struct FTerrainGeneratorIslandParameters {
    /* 0x0000 */ float MinWeight;
    /* 0x0004 */ float MaxWeight;
    /* 0x0008 */ int32_t MinExpansion;
    /* 0x000c */ int32_t MaxExpansion;
    /* 0x0010 */ int32_t MinDistance;
    /* 0x0014 */ float ShuffleReduction;
    /* 0x0018 */ TArray<ETerrainGeneratorIslandSurface> Surfaces;
};

// Size: 0x48
struct FTerrainGeneratorMeta {
};

// Size: 0x14
struct FTerrainHeatAnimationCell {
    /* 0x0000 */ FIntVector DataLocation;
    /* 0x000c */ int32_t CellIndex;
    /* 0x0010 */ float Timer;
};

// Size: 0x80
struct FTerrainImposterConfig {
    /* 0x0000 */ FIntVector Origin;
    /* 0x000c */ FIntVector Extent;
    /* 0x0018 */ TMap<FName, float> GenerationParameters;
    /* 0x0068 */ UMaterialInterface* SurfaceMaterial;
    /* 0x0070 */ UMaterialInterface* UnderwaterMaterial;
    /* 0x0078 */ UMaterialInterface* CliffMaterial;
};

// Size: 0xa8
class UTerrainImposterConfigMule : public UObject {
    /* 0x0028 */ FTerrainImposterConfig config;
};

// Size: 0x58
struct FTerrainOreInstances {
    /* 0x0000 */ UInstancedStaticMeshComponent* Meshes;
    /* 0x0008 */ TMap<FIntPoint, int32_t> Indices;
};

// Size: 0x14
struct FTerrainPollutionCell {
    /* 0x0000 */ FIntVector DataLocation;
    /* 0x000c */ int32_t CellIndex;
    /* 0x0010 */ uint16_t OutputPerSecond;
    /* 0x0012 */ uint16_t DeletionCountdown;
};

// Size: 0x18
struct FTerrainSliceInstances {
    /* 0x0000 */ UInstancedStaticMeshComponent* Meshes;
    /* 0x0008 */ TArray<FIntPoint> Locations;
};

// Size: 0x20
struct FTerrainSliceLocation {
    /* 0x0000 */ UStaticMesh* Mesh;
    /* 0x0008 */ int32_t Index;
    /* 0x000c */ int32_t Variant;
    /* 0x0010 */ UStaticMesh* SlicedMesh;
    /* 0x0018 */ int32_t SlicedIndex;
};

// Size: 0x60
struct FTerrainWaterEnclosure {
    /* 0x0000 */ TSet<FIntPoint> Locations;
    /* 0x0050 */ int32_t CellHeight;
    /* 0x0054 */ float DrainRemainder;
    /* 0x0058 */ float OceanWavesCountdown;
    /* 0x005c */ uint8_t WaterHeight;
    /* 0x005d */ uint8_t OceanWaves;
};

// Size: 0x70
struct FTheaterRow : public FTableRowBase {
    /* 0x0008 */ FName nextTheaterId;
    /* 0x0010 */ bool canSkip;
    /* 0x0011 */ ETheaterStyle p1_style;
    /* 0x0018 */ FString p1_key;
    /* 0x0028 */ ETheaterStyle p2_style;
    /* 0x0030 */ FString p2_key;
    /* 0x0040 */ ETheaterStyle p3_style;
    /* 0x0048 */ FString p3_key;
    /* 0x0058 */ ETheaterStyle p4_style;
    /* 0x0060 */ FString p4_key;
};

// Size: 0x3b8
class UTheaterUi : public UNaviUi {
    /* 0x03a8 */ UDataTable* theaterTable;
    /* 0x03b0 */ FName theaterId;

    FTheaterRow FindRowData(FName ID);
    void ReportAnimationFinish();
    void StartAnimation();
    void StartTheater(FName newTheaterId);
};

// Size: 0x7d8
class ATiledBlockTerrain : public AActor {
    /* 0x02a8 */ FTiledTerrainConfig config;
    /* 0x0538 */ UClass* TerrainTiles;
    /* 0x0540 */ TArray<FBlockTerrainSlice> Slices;
    /* 0x0550 */ FIntVector Origin;
    /* 0x055c */ int32_t SliceIndex;
    /* 0x0560 */ ATiledBlockTerrainHighlight* Highlight;
    /* 0x0568 */ FIntVector HighlightDataLocation;
    /* 0x0578 */ FFarmCropConfig FarmCropConfig;
    /* 0x06d0 */ TSet<FIntPoint> FoamDataLocations;
    /* 0x0720 */ TSet<FIntPoint> FoamUpdateDataLocations;
    /* 0x0770 */ ATiledVoxelTerrain* LOD;
    /* 0x0778 */ TMap<FIntVector, FBlockTerrainMinePillarData> MinePillarData;
    /* 0x07c8 */ double DrawDistance;
    /* 0x07d0 */ float PropDensity;
    /* 0x07d4 */ bool bAlwaysUseGroundLOD;
};

// Size: 0x78
struct FTiledBlockTerrainCover {
    /* 0x0000 */ UStaticMesh* Full;
    /* 0x0008 */ UStaticMesh* Corner000;
    /* 0x0010 */ UStaticMesh* Corner100;
    /* 0x0018 */ UStaticMesh* Corner010;
    /* 0x0020 */ UStaticMesh* Corner110;
    /* 0x0028 */ UStaticMesh* Corner111;
    /* 0x0030 */ UStaticMesh* Edge00;
    /* 0x0038 */ UStaticMesh* Edge10;
    /* 0x0040 */ UStaticMesh* Edge01;
    /* 0x0048 */ UStaticMesh* Edge11;
    /* 0x0050 */ UStaticMesh* CornerInside0;
    /* 0x0058 */ UStaticMesh* CornerInside1;
    /* 0x0060 */ UStaticMesh* EdgeDouble;
    /* 0x0068 */ UStaticMesh* Turn;
    /* 0x0070 */ UStaticMesh* Circle;
};

// Size: 0x2c0
class ATiledBlockTerrainHighlight : public AActor {
    /* 0x02a8 */ int32_t CurrentMeshIndex;
    /* 0x02ac */ bool bVisibility;
    /* 0x02b0 */ TArray<UStaticMeshComponent*> Meshes;
};

// Size: 0x10
struct FTiledBlockTerrainOre {
    /* 0x0000 */ TArray<FTiledBlockTerrainOreVariant> Variants;
};

// Size: 0x18
struct FTiledBlockTerrainOreVariant {
    /* 0x0000 */ UStaticMesh* Full;
    /* 0x0008 */ UStaticMesh* Slice;
    /* 0x0010 */ UStaticMesh* Top;
};

// Size: 0x10
struct FTiledBlockTerrainPlant {
    /* 0x0000 */ TArray<FTiledBlockTerrainPlantPart> Parts;
};

// Size: 0x110
struct FTiledBlockTerrainPlantPart {
    /* 0x0000 */ TArray<UStaticMesh*> Variants;
    /* 0x0010 */ FTransform Transform;
    /* 0x0070 */ FTransform Variance;
    /* 0x00d0 */ FVector ScaleVariance;
    /* 0x00e8 */ bool bLinkScaleVariance;
    /* 0x00f0 */ FRotator RotationVariance;
    /* 0x0108 */ bool bLinkRotationVariance;
    /* 0x0109 */ bool bRenderHighlightOutline;
};

// Size: 0x18
struct FTiledBlockTerrainTile {
    /* 0x0000 */ TArray<FTiledBlockTerrainTileParts> Parts;
    /* 0x0010 */ UStaticMesh* Slice;
};

// Size: 0x20
struct FTiledBlockTerrainTileParts {
    /* 0x0000 */ UStaticMesh* Full;
    /* 0x0008 */ UStaticMesh* Top;
    /* 0x0010 */ UStaticMesh* Cover;
    /* 0x0018 */ UStaticMesh* ocean;
};

// Size: 0x190
class UTiledBlockTerrainTiles : public UObject {
    /* 0x0028 */ TArray<FTiledBlockTerrainTile> Blocks;
    /* 0x0038 */ TMap<FName, FTiledBlockTerrainOre> Ores;
    /* 0x0088 */ TMap<FName, FTiledBlockTerrainPlant> Plants;
    /* 0x00d8 */ FTiledBlockTerrainCover Cover;
    /* 0x0150 */ UStaticMesh* MinePillar;
    /* 0x0158 */ UStaticMesh* MineBeam;
    /* 0x0160 */ UStaticMesh* MineWall;
    /* 0x0168 */ UStaticMesh* MineRetainer;
    /* 0x0170 */ UStaticMesh* MineDoublePillar;
    /* 0x0178 */ UStaticMesh* MineCeiling;
    /* 0x0180 */ double MineOffset;
    /* 0x0188 */ UStaticMesh* PollutionTile;
};

// Size: 0x1c
struct FTiledTerrainBounds {
};

// Size: 0x130
struct FTiledTerrainConfig {
    /* 0x0000 */ double Scale;
    /* 0x0008 */ FVector Offset;
    /* 0x0020 */ UMaterialParameterCollection* MetaDataParameters;
    /* 0x0028 */ UTextureRenderTargetVolume* VolumeMetaDataOne;
    /* 0x0030 */ UTextureRenderTargetVolume* VolumeMetaDataTwo;
    /* 0x0038 */ UTextureRenderTarget2D* PlanarMetaDataOne;
    /* 0x0040 */ UTextureRenderTarget2D* PlanarMetaDataTwo;
    /* 0x0048 */ int32_t PropResolution;
    /* 0x0050 */ TArray<FTiledTerrainProp> OceanProps;
    /* 0x0060 */ TArray<FTiledTerrainProp> RockProps;
    /* 0x0070 */ TArray<FTiledTerrainProp> DirtProps;
    /* 0x0080 */ TArray<FTiledTerrainProp> GrassProps;
    /* 0x0090 */ TArray<FTiledTerrainProp> BeachProps;
    /* 0x00a0 */ float GrassScale;
    /* 0x00a4 */ float GrassBias;
    /* 0x00a8 */ float PlantsWpoDisableDistance;
    /* 0x00ac */ uint16_t PollutionVisualizationCutoff;
    /* 0x00b0 */ UMaterialInterface* SurfaceMaterial;
    /* 0x00b8 */ UMaterialInterface* UnderwaterMaterial;
    /* 0x00c0 */ UMaterialInterface* CliffMaterial;
    /* 0x00c8 */ UMaterialInterface* CoverMaterial;
    /* 0x00d0 */ UMaterialInterface* SliceMaterial;
    /* 0x00d8 */ FTiledTerrainHeightBlendConfig HeightBlendConfig;
    /* 0x0128 */ float CropGrowthPower;
};

// Size: 0x158
class UTiledTerrainConfigMule : public UObject {
    /* 0x0028 */ FTiledTerrainConfig config;
};

// Size: 0x878
struct FTiledTerrainData {
    /* 0x0000 */ FIntVector Origin;
    /* 0x000c */ FIntVector Extent;
    /* 0x0018 */ TArray<FTerrainCell> Cells;
    /* 0x0028 */ TArray<FTerrainCell2D> Cells2D;
    /* 0x0038 */ TArray<ETerrainNavigationAccessibility> NavigationMap;
    /* 0x0048 */ FIntPoint MainIslandDataLocation;
    /* 0x0050 */ TArray<FTerrainCell> OriginalCells;
    /* 0x0060 */ TArray<FTerrainCell2D> OriginalCells2D;
    /* 0x0070 */ FTerrainCellTypeLibrary TypeLibrary;
    /* 0x01d0 */ TArray<FName> Ores;
    /* 0x01e0 */ float FarmTickTimer;
    /* 0x01e4 */ int32_t LastFarmCellIndex;
    /* 0x01e8 */ TArray<FTerrainFarmCell> FarmCells;
    /* 0x01f8 */ TArray<FTerrainFarmField> FarmFields;
    /* 0x0208 */ FFarmCropConfig FarmCropConfig;
    /* 0x0248 */ float ExternalCropGrowthModifier;
    /* 0x024c */ float PollutionTickTimer;
    /* 0x0250 */ bool bPollutionApplication;
    /* 0x0254 */ int32_t LastPollutionCellIndex;
    /* 0x0258 */ TArray<FTerrainPollutionCell> PollutionCells;
    /* 0x0268 */ float DecayTickTimer;
    /* 0x026c */ int32_t LastDecayCellIndex;
    /* 0x0270 */ TArray<FTerrainDecayCell> DecayCells;
    /* 0x0280 */ float HeatAnimationTickTimer;
    /* 0x0284 */ int32_t LastHeatAnimationCellIndex;
    /* 0x0288 */ TArray<FTerrainHeatAnimationCell> HeatAnimationCells;
    /* 0x0298 */ TArray<FTerrainWaterEnclosure> WaterEnclosures;
    /* 0x02a8 */ int32_t WaterDrainIncrement;
    /* 0x02ac */ float WaterEvaporationPerSecond;
    /* 0x02b0 */ float WaterEvaporationMultiplier;
    /* 0x02b8 */ TArray<float> TraceDistances;
    /* 0x02c8 */ FIntVector ShipPosition;
    /* 0x02d4 */ float SecondsPerYear;
    /* 0x02d8 */ float GlobalCropYieldFactor;
    /* 0x02dc */ float MineAgeDecayPeriod;
    /* 0x02e0 */ float OceanFloorDryingPeriod;
    /* 0x02e4 */ uint8_t GlobalHeat;
    /* 0x02e5 */ bool bTemperatureFalling;
    /* 0x02e8 */ int32_t SeaFloorHeight;
    /* 0x02ec */ uint8_t NewTerrainHealth;
    /* 0x02ed */ bool bRequiresNavigationUpdate;
    /* 0x02f0 */ float NutrientDifficultyModifier;
    /* 0x02f8 */ TArray<int32_t> HarvestPriorities;
    /* 0x0308 */ TArray<int32_t> EarlyHarvestPriorities;
};

// Size: 0x50
struct FTiledTerrainHeightBlendConfig {
    /* 0x0000 */ double CliffBlendStartHeight;
    /* 0x0008 */ double CliffBlendEndHeight;
    /* 0x0010 */ double GrassBlendStartHeight;
    /* 0x0018 */ double GrassBlendEndHeight;
    /* 0x0020 */ double RockBlendStartHeight;
    /* 0x0028 */ double RockBlendEndHeight;
    /* 0x0030 */ double ShallowOceanBlendStartHeight;
    /* 0x0038 */ double ShallowOceanBlendEndHeight;
    /* 0x0040 */ double DeepOceanBlendStartHeight;
    /* 0x0048 */ double DeepOceanBlendEndHeight;
};

// Size: 0x10
struct FTiledTerrainOre {
    /* 0x0000 */ UStaticMesh* Top;
    /* 0x0008 */ UStaticMesh* Bottom;
};

// Size: 0x58
struct FTiledTerrainProp {
    /* 0x0000 */ TArray<UStaticMesh*> Variants;
    /* 0x0010 */ TArray<UStaticMesh*> DeepOceanVariants;
    /* 0x0020 */ UClass* Weight;
    /* 0x0028 */ UNoise* LoadedWeight;
    /* 0x0030 */ double MinScale;
    /* 0x0038 */ double MaxScale;
    /* 0x0040 */ int32_t minHeight;
    /* 0x0044 */ int32_t maxHeight;
    /* 0x0048 */ double Shift;
    /* 0x0050 */ bool bShadow;
    /* 0x0051 */ bool bNoRespawn;
};

// Size: 0x1
struct FTiledTerrainRayCast {
};

// Size: 0x530
class ATiledVoxelTerrain : public AActor {
    /* 0x02a8 */ TArray<FTiledVoxelTerrainSlice> Slices;
    /* 0x02b8 */ UStaticMesh* SurfaceMesh;
    /* 0x02c0 */ UStaticMesh* UnderwaterMesh;
    /* 0x02c8 */ UStaticMeshComponent* UnderwaterMeshComponent;
    /* 0x02d0 */ UStaticMeshComponent* SurfaceMeshComponent;
    /* 0x02d8 */ UStaticMesh* CliffMesh;
    /* 0x02e0 */ UStaticMeshComponent* CliffMeshComponent;
    /* 0x02e8 */ FTerrainImposterConfig ImposterConfig;
    /* 0x0368 */ UTerrainGenerator* Generator;
    /* 0x0370 */ UClass* GeneratorConfig;
    /* 0x0378 */ UOreDistributor* Distributor;
    /* 0x0380 */ UClass* DistributorConfig;
    /* 0x0388 */ bool bGenerateOnBeginPlay;
    /* 0x0390 */ UTexture2D* ImposterSurfaceTexture;
    /* 0x0398 */ UMaterialInstanceDynamic* ImposterSurfaceMaterial;
    /* 0x0500 */ TArray<FGridInstaMesh> InstancedPlantMeshes;
    /* 0x0510 */ UClass* TerrainTiles;
    /* 0x0518 */ UMaterialInterface* SurfaceMaterial;
    /* 0x0520 */ UMaterialInterface* UnderwaterMaterial;
    /* 0x0528 */ UMaterialInterface* SliceMaterial;

    void GenerateImposter();
};

// Size: 0x10
struct FTiledVoxelTerrainSlice {
    /* 0x0000 */ UAsyncMeshBuilder* MeshBuilder;
    /* 0x0008 */ ETerrainSliceState State;
};

// Size: 0x270
class UTooltipComponent : public USceneComponent {
    /* 0x0240 */ FTooltipConfig config;
    /* 0x0258 */ FTooltipTuning tuning;
    /* 0x0260 */ UWidgetComponent* WidgetComponent;
    /* 0x0268 */ float showRatio;
    /* 0x026c */ float goalRatio;

    void Hide();
    void SetShow(bool doShow);
    void Show();
};

// Size: 0x18
struct FTooltipConfig {
    /* 0x0000 */ ETooltipStyle style;
    /* 0x0008 */ FString Title;
};

// Size: 0x8
struct FTooltipTuning {
    /* 0x0000 */ float animationTime;
    /* 0x0004 */ float delayMul;
};

// Size: 0x340
class UTooltipWidgetBase : public UUserWidget {

    void SetConfig(FTooltipConfig nc);
    void SetShowRatio(float Ratio);
};

// Size: 0x38
struct FUiIconItemConfig {
    /* 0x0000 */ FString Title;
    /* 0x0010 */ UTexture2D* Icon;
    /* 0x0018 */ FString minimap;
    /* 0x0028 */ FString Payload;
};

// Size: 0x28
class UUnlockIdGen : public UBlueprintFunctionLibrary {

    static FName MapUnlockID(FString mapId);
};

// Size: 0x50
struct FUnlockLayer {
    /* 0x0000 */ TMap<FName, int32_t> ownCounts;
};

// Size: 0x178
class UUnlockManComponent : public UActorComponent {
    /* 0x00b8 */ FUnlockManState State;
    /* 0x0158 */ USmallHoldComponent* smallHold;
    /* 0x0160 */ UGenericSaveGame* Save;
    /* 0x0168 */ FString smallPrefix;

    static void AlterAllCampaignUnlocks(const UObject* WorldContext, bool willHave);
};

// Size: 0xa0
struct FUnlockManState {
    /* 0x0000 */ TSet<FName> bakedUnlockKnowledge;
    /* 0x0050 */ FUnlockLayer regionLayer;
};

// Size: 0x140
class UUnlockResearchComponent : public UActorComponent {
    /* 0x00b8 */ UUnlockManComponent* unlockMan;
    /* 0x00c0 */ FName researchUnlockId;
    /* 0x00c8 */ float researchPoints;
    /* 0x00d0 */ TSet<AActor*> linkedBuildings;
    /* 0x0120 */ UDataTable* unlockTable;
    /* 0x0128 */ UActivityTracker* activity;
    /* 0x0130 */ FMulticastInlineDelegate uponResearchFinished;

    float GetResearchPoints(FName unlockId) const;
    float GetResearchPointsRequired(FName unlockId) const;
    float GetResearchRate() const;
    float GetResearchRatio(FName unlockId) const;
    FName GetResearchTopic() const;
    bool IsResearched(FName unlockId) const;
    void ReportLinkage(AActor* building, bool isLinked);
    bool SetResearchTopic(FName unlockId);
};

// Size: 0x20
struct FUnlockTreeCategory {
    /* 0x0000 */ FString categoryStringKey;
    /* 0x0010 */ TArray<FUnlockTreeGroup> Groups;
};

// Size: 0x20
struct FUnlockTreeGroup {
    /* 0x0000 */ FString groupStringKey;
    /* 0x0010 */ TArray<FUnlockTreeItem> Items;
};

// Size: 0x48
struct FUnlockTreeItem {
    /* 0x0000 */ FName unlockId;
    /* 0x0008 */ FString titleStringKey;
    /* 0x0018 */ FString descStringKey;
    /* 0x0028 */ FString Payload;
    /* 0x0038 */ EUnlockTreeLockStatus Status;
    /* 0x0039 */ EUnlockTreeAttributes Attribute;
    /* 0x003a */ EIconGroup iconGroup;
    /* 0x003c */ FName iconKey;
};

// Size: 0x60
struct FUnlockTreeResearch {
    /* 0x0000 */ bool hasResearch;
    /* 0x0008 */ FUnlockTreeItem researchItem;
    /* 0x0050 */ int32_t currentPoints;
    /* 0x0054 */ int32_t fullPoints;
    /* 0x0058 */ int32_t ppm;
};

// Size: 0x70
struct FUnlockTreeState {
    /* 0x0000 */ FUnlockTreeResearch research;
    /* 0x0060 */ TArray<FUnlockTreeCategory> Categories;
};

// Size: 0x428
class UUnlockTreeUi : public UNaviUi {
    /* 0x03a8 */ FUnlockTreeState State;
    /* 0x0418 */ UUnlockResearchComponent* resCache;
    /* 0x0420 */ UDataTable* unlockTable;

    FUnlockTreeResearch CalcResearch();
    bool SetResearchTopic(FString unlockId);
    void UpdateDisplay(FUnlockTreeState ns);
};

// Size: 0x90
struct FUnlocksRow : public FTableRowBase {
    /* 0x0008 */ int32_t Price;
    /* 0x0010 */ FString Category;
    /* 0x0020 */ FText stringKey;
    /* 0x0030 */ FString descStringKey;
    /* 0x0040 */ bool inShop;
    /* 0x0041 */ bool isCampaign;
    /* 0x0042 */ bool shouldNotify;
    /* 0x0048 */ UClass* Asset;
    /* 0x0050 */ FString Payload;
    /* 0x0060 */ bool canResearch;
    /* 0x0064 */ float researchTime;
    /* 0x0068 */ FString researchDependency;
    /* 0x0078 */ FName accessGate;
    /* 0x0080 */ bool hasByDefault;
    /* 0x0081 */ EIconGroup iconGroup;
    /* 0x0084 */ FName iconKey;
};

// Size: 0x2a0
class UUxTrackingCamera : public USceneComponent {
    /* 0x0240 */ float zoomMin;
    /* 0x0244 */ float zoomMax;
    /* 0x0248 */ float zoomRotMin;
    /* 0x024c */ float zoomRotMax;
    /* 0x0250 */ float CameraLagSpeed;
    /* 0x0254 */ float cameraRotLagSpeed;
    /* 0x0258 */ float cameraHeight;
    /* 0x0260 */ AActor* trackingTarget;
    /* 0x0288 */ UCameraComponent* cam;
    /* 0x0290 */ USpringArmComponent* springArm;

    void SetRotation(FRotator nRotation);
    void SetZoomRatio(float nZoomRatio);
};

// Size: 0x58
struct FWalkerConfig {
    /* 0x0000 */ float walkSpeed;
    /* 0x0004 */ float glideSpeed;
    /* 0x0008 */ float forceSlope;
    /* 0x000c */ float forceSlide;
    /* 0x0010 */ FRotator rotOffset;
    /* 0x0028 */ float swimSpeedRatio;
    /* 0x002c */ float jumpImpulse;
    /* 0x0030 */ float Gravity;
    /* 0x0034 */ float gravityJumpAlt;
    /* 0x0038 */ float gravityGlideAlt;
    /* 0x003c */ float groundMagnetDistance;
    /* 0x0040 */ float frictionGround;
    /* 0x0044 */ float frictionAir;
    /* 0x0048 */ float slideStartAngle;
    /* 0x004c */ float gripGround;
    /* 0x0050 */ float gripAir;
};

// Size: 0x400
class AWalkerPawn : public AControllablePawn {
    /* 0x0368 */ FWalkerConfig config;
    /* 0x03c0 */ FWalkerState State;
    /* 0x03f8 */ UStaticMeshComponent* characterMesh;
};

// Size: 0x38
struct FWalkerState {
    /* 0x0000 */ FVector lookDirection;
    /* 0x0018 */ FVector momentum;
    /* 0x0030 */ bool wantGlide;
    /* 0x0031 */ bool inSlide;
};

// Size: 0x40
struct FWeatherCondition {
    /* 0x0000 */ float wetnessMin;
    /* 0x0004 */ float wetnessMax;
    /* 0x0008 */ float hotnessMin;
    /* 0x000c */ float hotnessMax;
    /* 0x0010 */ float windMin;
    /* 0x0014 */ float windMax;
    /* 0x0018 */ float fogMin;
    /* 0x001c */ float fogMax;
    /* 0x0020 */ float darknessMin;
    /* 0x0024 */ float darknessMax;
    /* 0x0028 */ TArray<EClimate> bannedClimates;
    /* 0x0038 */ bool requireType;
    /* 0x0039 */ EWeatherType weatherType;
};

// Size: 0x350
class AWeatherConfigMule : public AActor {
    /* 0x02a8 */ FWeatherManConfig config;
};

// Size: 0x68
struct FWeatherEffect {
    /* 0x0000 */ EWeatherSpawnBehaviour spawnBehaviour;
    /* 0x0008 */ FVector Offset;
    /* 0x0020 */ FWeatherCondition Condition;
    /* 0x0060 */ UClass* effectActor;
};

// Size: 0x218
class UWeatherManComponent : public UActorComponent {
    /* 0x00b8 */ FWeatherManConfig config;
    /* 0x0160 */ FWeatherState State;

    void GotoDay();
    void GotoNight();
    void GotoRapidDays();
    float ReadDarkness() const;
    float ReadTimeOfDayRatio() const;
    void StopCycle();
};

// Size: 0xa8
struct FWeatherManConfig {
    /* 0x0000 */ TArray<FWeatherEffect> effects;
    /* 0x0010 */ FVector2D changeTiming;
    /* 0x0020 */ float paramChangeSpeed;
    /* 0x0024 */ float minTotalWindSpeed;
    /* 0x0028 */ float daySpeed;
    /* 0x002c */ float dayLength;
    /* 0x0030 */ float nightLength;
    /* 0x0034 */ float shiftLength;
    /* 0x0038 */ EEase dayNightEaseFunction;
    /* 0x0040 */ UMaterialParameterCollection* weatherParameterCollection;
    /* 0x0048 */ TMap<EWeatherType, FWeatherParams> Parameters;
    /* 0x0098 */ FVector2D windowLightRamp;
};

// Size: 0x40
struct FWeatherParams {
    /* 0x0000 */ bool affectWetness;
    /* 0x0004 */ float wetness;
    /* 0x0008 */ bool affectHotness;
    /* 0x000c */ float hotness;
    /* 0x0010 */ bool affectWindSpeed;
    /* 0x0014 */ float windSpeed;
    /* 0x0018 */ bool affectFog;
    /* 0x001c */ float fog;
    /* 0x0020 */ float darkness;
    /* 0x0028 */ FVector WindDirection;
};

// Size: 0xb8
struct FWeatherState {
    /* 0x0000 */ FWeatherParams Params;
    /* 0x0040 */ float timeSinceStart;
    /* 0x0044 */ float timeUntillChange;
    /* 0x0048 */ EWeatherType Type;
    /* 0x0049 */ EClimate currentClimate;
    /* 0x0050 */ FVector totalWindOffset;
    /* 0x0068 */ TMap<int32_t, AActor*> activeEffects;
};

// Size: 0x28
class UWordsLogic : public UBlueprintFunctionLibrary {

    static FSplitWordCombo ComputeSplitCombo(FString Input);
};

// Size: 0x858
class UMovieSceneTakeSection : public UMovieSceneSection {
    /* 0x0108 */ FMovieSceneIntegerChannel HoursCurve;
    /* 0x0210 */ FMovieSceneIntegerChannel MinutesCurve;
    /* 0x0318 */ FMovieSceneIntegerChannel SecondsCurve;
    /* 0x0420 */ FMovieSceneIntegerChannel FramesCurve;
    /* 0x0528 */ FMovieSceneFloatChannel SubFramesCurve;
    /* 0x0638 */ FMovieSceneFloatChannel RateCurve;
    /* 0x0748 */ FMovieSceneStringChannel Slate;
};

// Size: 0x98
class UMovieSceneTakeSettings : public UObject {
    /* 0x0028 */ FString HoursName;
    /* 0x0038 */ FString MinutesName;
    /* 0x0048 */ FString SecondsName;
    /* 0x0058 */ FString FramesName;
    /* 0x0068 */ FString SubFramesName;
    /* 0x0078 */ FString RateName;
    /* 0x0088 */ FString SlateName;
};

// Size: 0x120
class UMovieSceneTakeTrack : public UMovieSceneNameableTrack {
    /* 0x0110 */ TArray<UMovieSceneSection*> Sections;
};

// Size: 0x60
class UTcpMessagingSettings : public UObject {
    /* 0x0028 */ bool EnableTransport;
    /* 0x0030 */ FString ListenEndpoint;
    /* 0x0040 */ TArray<FString> ConnectToEndpoints;
    /* 0x0050 */ int32_t ConnectionRetryDelay;
    /* 0x0054 */ int32_t ConnectionRetryPeriod;
    /* 0x0058 */ bool bStopServiceWhenAppDeactivates;
};

// Size: 0x40
class UCameraAnimationBoundObjectInstantiator : public UMovieSceneEntityInstantiatorSystem {
};

// Size: 0x768
class UCameraAnimationEntitySystemLinker : public UMovieSceneEntitySystemLinker {
};

// Size: 0xe8
class UCameraAnimationSequence : public UTemplateSequence {
};

// Size: 0x8c0
class UCameraAnimationSequenceCameraStandIn : public UObject {
    /* 0x0028 */ float FieldOfView;
    /* 0x002c */ bool bConstrainAspectRatio;
    /* 0x0030 */ float AspectRatio;
    /* 0x0040 */ FPostProcessSettings PostProcessSettings;
    /* 0x07a0 */ float PostProcessBlendWeight;
    /* 0x07a4 */ FCameraFilmbackSettings Filmback;
    /* 0x07b8 */ FCameraLensSettings LensSettings;
    /* 0x07d8 */ FCameraFocusSettings FocusSettings;
    /* 0x0838 */ float CurrentFocalLength;
    /* 0x083c */ float CurrentAperture;
    /* 0x0840 */ float CurrentFocusDistance;
};

// Size: 0x330
class UCameraAnimationSequencePlayer : public UObject {
    /* 0x0290 */ UObject* BoundObjectOverride;
    /* 0x0298 */ UMovieSceneSequence* Sequence;
    /* 0x02a0 */ FMovieSceneRootEvaluationTemplateInstance RootTemplateInstance;
};

// Size: 0x48
class UCameraAnimationSequenceSubsystem : public UWorldSubsystem {
    /* 0x0030 */ UMovieSceneEntitySystemLinker* Linker;
};

// Size: 0x40
class UCameraAnimationSpawnableSystem : public UMovieSceneEntitySystem {
};

enum class ETemplateSectionPropertyScaleType {
    FloatProperty = 0,
    TransformPropertyLocationOnly = 1,
    TransformPropertyRotationOnly = 2,
    ETemplateSectionPropertyScaleType_MAX = 3,
};

// Size: 0x78
class USequenceCameraShakePattern : public UCameraShakePattern {
    /* 0x0028 */ UCameraAnimationSequence* Sequence;
    /* 0x0030 */ float PlayRate;
    /* 0x0034 */ float Scale;
    /* 0x0038 */ float BlendInTime;
    /* 0x003c */ float BlendOutTime;
    /* 0x0040 */ float RandomSegmentDuration;
    /* 0x0044 */ bool bRandomSegment;
    /* 0x0048 */ UCameraAnimationSequencePlayer* Player;
    /* 0x0050 */ UCameraAnimationSequenceCameraStandIn* CameraStandIn;
};

// Size: 0x28
class USequenceCameraShakeTestUtil : public UBlueprintFunctionLibrary {

    static FMinimalViewInfo GetCameraCachePOV(APlayerController* PlayerController);
    static FMinimalViewInfo GetLastFrameCameraCachePOV(APlayerController* PlayerController);
    static bool GetPostProcessBlendCache(APlayerController* PlayerController, int32_t PPIndex, FPostProcessSettings& OutPPSettings, float& OutPPBlendWeight);
};

// Size: 0x138
struct FTemplateSectionPropertyScale {
    /* 0x0000 */ FGuid ObjectBinding;
    /* 0x0010 */ FMovieScenePropertyBinding PropertyBinding;
    /* 0x0024 */ ETemplateSectionPropertyScaleType PropertyScaleType;
    /* 0x0028 */ FMovieSceneFloatChannel FloatChannel;
};

// Size: 0xe8
class UTemplateSequence : public UMovieSceneSequence {
    /* 0x0068 */ UMovieScene* MovieScene;
    /* 0x0070 */ TSoftClassPtr<AActor> BoundActorClass;
    /* 0x0098 */ TMap<FGuid, FName> BoundActorComponents;
};

// Size: 0x310
class ATemplateSequenceActor : public AActor {
    /* 0x02b0 */ FMovieSceneSequencePlaybackSettings PlaybackSettings;
    /* 0x02d8 */ UTemplateSequencePlayer* SequencePlayer;
    /* 0x02e0 */ FSoftObjectPath TemplateSequence;
    /* 0x0300 */ FTemplateSequenceBindingOverrideData BindingOverride;

    UTemplateSequence* GetSequence() const;
    UTemplateSequencePlayer* GetSequencePlayer() const;
    UTemplateSequence* LoadSequence() const;
    void SetBinding(AActor* Actor, bool bOverridesDefault);
    void SetSequence(UTemplateSequence* InSequence);
};

// Size: 0xc
struct FTemplateSequenceBindingOverrideData {
    /* 0x0000 */ TWeakObjectPtr<UObject> Object;
    /* 0x0008 */ bool bOverridesDefault;
};

// Size: 0x478
class UTemplateSequencePlayer : public UMovieSceneSequencePlayer {

    static UTemplateSequencePlayer* CreateTemplateSequencePlayer(UObject* WorldContextObject, UTemplateSequence* TemplateSequence, FMovieSceneSequencePlaybackSettings Settings, ATemplateSequenceActor*& OutActor);
};

// Size: 0x90
class UTemplateSequencePropertyScalingEvaluatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x98
class UTemplateSequencePropertyScalingInstantiatorSystem : public UMovieSceneEntitySystem {
};

// Size: 0x800
class UTemplateSequenceSection : public UMovieSceneSubSection {
    /* 0x07f0 */ TArray<FTemplateSectionPropertyScale> PropertyScales;
};

// Size: 0xd0
class UTemplateSequenceSystem : public UMovieSceneEntitySystem {
};

// Size: 0x120
class UTemplateSequenceTrack : public UMovieSceneSubTrack {
};

enum class ETextureImportFloatingPointFormat {
    HDR_F16 = 0,
    HDRCompressed_BC6 = 1,
    HDR_F32_or_F16 = 2,
    PreviousDefault = 0,
    ETextureImportFloatingPointFormat_MAX = 3,
};

enum class ETextureImportPNGInfill {
    Default = 0,
    Never = 1,
    OnlyOnBinaryTransparency = 2,
    Always = 3,
    ETextureImportPNGInfill_MAX = 4,
};

// Size: 0x48
class UTextureImportSettings : public UDeveloperSettings {
    /* 0x0038 */ int32_t AutoVTSize;
    /* 0x003c */ int32_t AutoLimitDimension;
    /* 0x0040 */ bool bEnableNormalizeNormals;
    /* 0x0041 */ bool bEnableFastMipFilter;
    /* 0x0042 */ ETextureImportFloatingPointFormat CompressedFormatForFloatTextures;
    /* 0x0043 */ ETextureImportPNGInfill PNGInfill;
};

// Size: 0x40
class UTextureImportUserSettings : public UDeveloperSettings {
    /* 0x0038 */ ETextureImportPNGInfill PNGInfill;
};

// Size: 0x40
class UCatchupFixedRateCustomTimeStep : public UFixedFrameRateCustomTimeStep {
    /* 0x0028 */ FFrameRate FrameRate;
    /* 0x0030 */ double MaxCatchupSeconds;
};

enum class EFrameNumberDisplayFormats {
    NonDropFrameTimecode = 0,
    DropFrameTimecode = 1,
    Seconds = 2,
    Frames = 3,
    Custom = 4,
    MAX_Count = 5,
    EFrameNumberDisplayFormats_MAX = 6,
};

enum class ETimedDataInputEvaluationType {
    None = 0,
    Timecode = 1,
    PlatformTime = 2,
    ETimedDataInputEvaluationType_MAX = 3,
};

enum class ETimedDataInputState {
    Connected = 0,
    Unresponsive = 1,
    Disconnected = 2,
    ETimedDataInputState_MAX = 3,
};

// Size: 0x28
class UFixedFrameRateCustomTimeStep : public UEngineCustomTimeStep {
};

// Size: 0x30
class UGenlockedCustomTimeStep : public UFixedFrameRateCustomTimeStep {
    /* 0x0028 */ bool bAutoDetectFormat;
    /* 0x0029 */ bool bWaitForBothFields;
};

// Size: 0x50
class UGenlockedFixedRateCustomTimeStep : public UGenlockedCustomTimeStep {
    /* 0x0030 */ FFrameRate FrameRate;
    /* 0x0038 */ bool bShouldBlock;
    /* 0x0039 */ bool bForceSingleFrameDeltaTime;
};

// Size: 0x58
class UGenlockedTimecodeProvider : public UTimecodeProvider {
    /* 0x0030 */ bool bUseGenlockToCount;
};

// Size: 0x28
class UTimeManagementBlueprintLibrary : public UBlueprintFunctionLibrary {

    static FFrameNumber Add_FrameNumberFrameNumber(FFrameNumber A, FFrameNumber B);
    static FFrameNumber Add_FrameNumberInteger(FFrameNumber A, int32_t B);
    static int32_t Conv_FrameNumberToInteger(const FFrameNumber& InFrameNumber);
    static float Conv_FrameRateToInterval(const FFrameRate InFrameRate);
    static float Conv_FrameRateToSeconds(const FFrameRate& InFrameRate);
    static float Conv_QualifiedFrameTimeToSeconds(const FQualifiedFrameTime& InFrameTime);
    static FString Conv_TimecodeToString(const FTimecode& InTimecode, bool bForceSignDisplay);
    static FFrameNumber Divide_FrameNumberInteger(FFrameNumber A, int32_t B);
    static FTimecode GetTimecode();
    static FFrameRate GetTimecodeFrameRate();
    static bool IsValid_Framerate(const FFrameRate& InFrameRate);
    static bool IsValid_MultipleOf(const FFrameRate& InFrameRate, const FFrameRate& OtherFramerate);
    static FFrameNumber Multiply_FrameNumberInteger(FFrameNumber A, int32_t B);
    static FFrameTime Multiply_SecondsFrameRate(float TimeInSeconds, const FFrameRate& FrameRate);
    static FFrameTime SnapFrameTimeToRate(const FFrameTime& SourceTime, const FFrameRate& SourceRate, const FFrameRate& SnapToRate);
    static FFrameNumber Subtract_FrameNumberFrameNumber(FFrameNumber A, FFrameNumber B);
    static FFrameNumber Subtract_FrameNumberInteger(FFrameNumber A, int32_t B);
    static FFrameTime TransformTime(const FFrameTime& SourceTime, const FFrameRate& SourceRate, const FFrameRate& DestinationRate);
};

// Size: 0x30
class UTimeSynchronizationSource : public UObject {
    /* 0x0028 */ bool bUseForSynchronization;
    /* 0x002c */ int32_t FrameOffset;
};

// Size: 0x18
struct FTimedDataChannelSampleTime {
};

// Size: 0x8
struct FTimedDataInputEvaluationData {
    /* 0x0000 */ float DistanceToNewestSampleSeconds;
    /* 0x0004 */ float DistanceToOldestSampleSeconds;
};

// Size: 0x28
class UTraceUtilLibrary : public UBlueprintFunctionLibrary {

    static TArray<FString> GetAllChannels();
    static TArray<FString> GetEnabledChannels();
    static bool IsChannelEnabled(FString ChannelName);
    static bool IsTracing();
    static bool PauseTracing();
    static bool ResumeTracing();
    static bool StartTraceSendTo(FString Target, const TArray<FString>& Channels);
    static bool StartTraceToFile(FString Filename, const TArray<FString>& Channels);
    static bool StopTracing();
    static bool ToggleChannel(FString ChannelName, bool Enabled);
    static void TraceBookmark(FString Name);
    static void TraceMarkRegionEnd(FString Name);
    static void TraceMarkRegionStart(FString Name);
    static void TraceScreenshot(FString Name, bool bShowUI);
};

// Size: 0x10
struct FDescriptionColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FText Description;
};

// Size: 0x10
struct FDisplayNameColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FText DisplayName;
};

enum class ESCCModification {
    Modified = 0,
    Added = 1,
    Removed = 2,
    Conflicted = 3,
    ESCCModification_MAX = 4,
};

// Size: 0x1
struct FEditorDataStorageColumn {
};

// Size: 0x28
class UEditorDataStorageFactory : public UObject {
};

// Size: 0x1
struct FEditorDataStorageTag {
};

// Size: 0x10
struct FEditorDataStorageUrlColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FString UrlString;
};

// Size: 0x18
struct FEditorDataStorageWebImageColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FString UrlString;
    /* 0x0010 */ uint16_t Width;
    /* 0x0012 */ uint16_t Height;
};

// Size: 0x1
struct FFolderTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FHideRowFromUITag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FIsInEditingModeTag : public FEditorDataStorageTag {
};

// Size: 0x8
struct FNameColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FName Name;
};

// Size: 0x1
struct FObjectOverrideColumn : public FEditorDataStorageColumn {
};

// Size: 0x14
struct FSCCExternalRevisionIdColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FSCCRevisionId RevisionId;
};

// Size: 0x1
struct FSCCExternallyEditedTag : public FEditorDataStorageTag {
};

// Size: 0x10
struct FSCCExternallyLockedColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FSCCUserInfo LockedBy;
};

// Size: 0x1
struct FSCCInChangelistTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FSCCLockedTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FSCCNotCurrentTag : public FEditorDataStorageTag {
};

// Size: 0x14
struct FSCCRevisionId {
    /* 0x0000 */ uint32_t ID[5];
};

// Size: 0x14
struct FSCCRevisionIdColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FSCCRevisionId RevisionId;
};

// Size: 0x1
struct FSCCStagedTag : public FEditorDataStorageTag {
};

// Size: 0x4
struct FSCCStatusColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ ESCCModification Modification;
};

// Size: 0x10
struct FSCCUserInfo {
    /* 0x0000 */ FString Name;
};

// Size: 0x8
struct FScriptTypedElementHandle {
};

// Size: 0x10
struct FScriptTypedElementListProxy {
};

// Size: 0x80
struct FSimpleWidgetConstructor : public FTypedElementWidgetConstructor {
};

// Size: 0x14
struct FSlateColorColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FSlateColor Color;
};

// Size: 0x10
struct FTEDSProcessorTestsReferenceColumn : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTEDSProcessorTests_Linked : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTEDSProcessorTests_PrimaryTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTEDSProcessorTests_SecondaryTag : public FEditorDataStorageTag {
};

// Size: 0x8
struct FTableRowParentColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FTedsRowHandle {
    /* 0x0000 */ uint64_t RowHandle;
};

// Size: 0x1
struct FTestColumnA : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnB : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnC : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnD : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnDynamic : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnE : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnF : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTestColumnG : public FEditorDataStorageColumn {
};

// Size: 0x4
struct FTestColumnInt : public FEditorDataStorageColumn {
    /* 0x0000 */ int32_t TestInt;
};

// Size: 0x10
struct FTestColumnString : public FEditorDataStorageColumn {
    /* 0x0000 */ FString TestString;
};

// Size: 0x1
struct FTestTagColumnA : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTestTagColumnB : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTestTagColumnC : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTestTagColumnD : public FEditorDataStorageTag {
};

// Size: 0x28
class ITestTypedElementInterfaceA : public UInterface {

    FText GetDisplayName(const FScriptTypedElementHandle& InElementHandle);
    bool SetDisplayName(const FScriptTypedElementHandle& InElementHandle, FText InNewName, bool bNotify);
};

// Size: 0x30
class UTestTypedElementInterfaceA_ImplTyped : public UObject {
};

// Size: 0x30
class UTestTypedElementInterfaceA_ImplUntyped : public UObject {
};

// Size: 0x28
class ITestTypedElementInterfaceB : public UInterface {

    bool MarkAsTested(const FScriptTypedElementHandle& InElementHandle);
};

// Size: 0x38
class UTestTypedElementInterfaceBAndC_Typed : public UObject {
};

// Size: 0x28
class ITestTypedElementInterfaceC : public UInterface {

    bool GetIsTested(const FScriptTypedElementHandle& InElementHandle) const;
};

// Size: 0x28
class UTest_PingPongBetweenPhaseFactory : public UEditorDataStorageFactory {
};

// Size: 0x8
struct FTest_PingPongDurPhys : public FEditorDataStorageColumn {
    /* 0x0000 */ uint64_t Value;
};

// Size: 0x8
struct FTest_PingPongPostPhys : public FEditorDataStorageColumn {
    /* 0x0000 */ uint64_t Value;
};

// Size: 0x8
struct FTest_PingPongPrePhys : public FEditorDataStorageColumn {
    /* 0x0000 */ uint64_t Value;
};

// Size: 0x1
struct FTypedElementActorTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTypedElementClassDefaultObjectTag : public FEditorDataStorageTag {
};

// Size: 0x8
struct FTypedElementClassTypeInfoColumn : public FEditorDataStorageColumn {
};

// Size: 0x28
class ITypedElementCounterInterface : public UInterface {
};

// Size: 0x8
struct FTypedElementExternalObjectColumn : public FEditorDataStorageColumn {
};

// Size: 0x4
struct FTypedElementFloatValueCacheColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ float Value;
};

// Size: 0x28
class UTypedElementHandleLibrary : public UObject {

    static bool Equal(const FScriptTypedElementHandle& LHS, const FScriptTypedElementHandle& RHS);
    static bool IsSet(const FScriptTypedElementHandle& ElementHandle);
    static bool NotEqual(const FScriptTypedElementHandle& LHS, const FScriptTypedElementHandle& RHS);
    static void Release(FScriptTypedElementHandle& ElementHandle);
};

// Size: 0x4
struct FTypedElementI32IntValueCacheColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ int32_t Value;
};

// Size: 0x8
struct FTypedElementI64IntValueCacheColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ int64_t Value;
};

// Size: 0x8
struct FTypedElementIconOverrideColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FName IconName;
};

// Size: 0x10
struct FTypedElementLabelColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FString Label;
};

// Size: 0x8
struct FTypedElementLabelHashColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ uint64_t LabelHash;
};

// Size: 0x28
class UTypedElementListLibrary : public UObject {

    static bool Add(FScriptTypedElementListProxy ElementList, const FScriptTypedElementHandle& ElementHandle);
    static void Append(FScriptTypedElementListProxy ElementList, const TArray<FScriptTypedElementHandle>& ElementHandles);
    static void AppendList(FScriptTypedElementListProxy ElementList, const FScriptTypedElementListProxy OtherElementList);
    static FScriptTypedElementListProxy Clone(const FScriptTypedElementListProxy ElementList);
    static bool Contains(const FScriptTypedElementListProxy ElementList, const FScriptTypedElementHandle& ElementHandle);
    static int32_t CountElements(const FScriptTypedElementListProxy ElementList, const UClass* BaseInterfaceType);
    static int32_t CountElementsOfType(const FScriptTypedElementListProxy ElementList, const FName ElementTypeName);
    static FScriptTypedElementListProxy CreateScriptElementList(UTypedElementRegistry* Registry);
    static void Empty(FScriptTypedElementListProxy ElementList, const int32_t Slack);
    static FScriptTypedElementHandle GetElementHandleAt(const FScriptTypedElementListProxy ElementList, const int32_t Index);
    static TArray<FScriptTypedElementHandle> GetElementHandles(const FScriptTypedElementListProxy ElementList, const UClass* BaseInterfaceType);
    static UObject* GetElementInterface(const FScriptTypedElementListProxy ElementList, const FScriptTypedElementHandle& ElementHandle, const UClass* BaseInterfaceType);
    static bool HasElements(const FScriptTypedElementListProxy ElementList, const UClass* BaseInterfaceType);
    static bool HasElementsOfType(const FScriptTypedElementListProxy ElementList, const FName ElementTypeName);
    static bool IsValidIndex(const FScriptTypedElementListProxy ElementList, const int32_t Index);
    static int32_t Num(const FScriptTypedElementListProxy ElementList);
    static bool Remove(FScriptTypedElementListProxy ElementList, const FScriptTypedElementHandle& ElementHandle);
    static void Reserve(FScriptTypedElementListProxy ElementList, const int32_t Size);
    static void Reset(FScriptTypedElementListProxy ElementList);
    static void Shrink(FScriptTypedElementListProxy ElementList);
};

// Size: 0x60
struct FTypedElementLocalTransformColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FTransform Transform;
};

// Size: 0x1
struct FTypedElementLoosePropertyTag : public FEditorDataStorageTag {
};

// Size: 0xc
struct FTypedElementPackageLoadedPathColumn : public FEditorDataStorageColumn {
};

// Size: 0x10
struct FTypedElementPackagePathColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FString Path;
};

// Size: 0x8
struct FTypedElementPackageReference : public FEditorDataStorageColumn {
};

// Size: 0x10
struct FTypedElementPackageUnresolvedReference : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTypedElementPackageUpdatedTag : public FEditorDataStorageTag {
};

// Size: 0x18
struct FTypedElementPivotOffset : public FEditorDataStorageColumn {
    /* 0x0000 */ FVector Offset;
};

// Size: 0x1
struct FTypedElementPropertyBagPlaceholderTag : public FEditorDataStorageTag {
};

// Size: 0x8
struct FTypedElementPropertyBagPlaceholderTypeInfoColumn : public FEditorDataStorageColumn {
};

// Size: 0x948
class UTypedElementRegistry : public UObject {

    UObject* GetElementInterface(const FScriptTypedElementHandle& InElementHandle, const UClass* InBaseInterfaceType) const;
    static UTypedElementRegistry* GetInstance();
};

// Size: 0x8
struct FTypedElementRowReferenceColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FTypedElementScriptStructTypeInfoColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FTypedElementSelectionColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FName SelectionSet;
};

// Size: 0x30
struct FTypedElementSlateWidgetReferenceColumn : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FTypedElementSlateWidgetReferenceDeletesRowTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTypedElementSyncBackToWorldTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTypedElementSyncFromWorldInteractiveTag : public FEditorDataStorageTag {
};

// Size: 0x1
struct FTypedElementSyncFromWorldTag : public FEditorDataStorageTag {
};

// Size: 0x4
struct FTypedElementU32IntValueCacheColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ uint32_t Value;
};

// Size: 0x8
struct FTypedElementU64IntValueCacheColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ uint64_t Value;
};

// Size: 0x8
struct FTypedElementUObjectColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FTypedElementUObjectIdColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ uint32_t ID;
    /* 0x0004 */ int32_t SerialNumber;
};

// Size: 0x1
struct FTypedElementViewportOutlineColorColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ uint8_t SelectionOutlineColorIndex;
};

// Size: 0x4
struct FTypedElementViewportOverlayColorColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FColor OverlayColor;
};

// Size: 0x80
struct FTypedElementWidgetConstructor {
};

// Size: 0x8
struct FTypedElementWorldColumn : public FEditorDataStorageColumn {
};

// Size: 0x18
struct FUnresolvedTableRowParentColumn : public FEditorDataStorageColumn {
};

// Size: 0x1
struct FVisibleInEditorColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FWidgetFactoryColumn : public FEditorDataStorageColumn {
};

// Size: 0x288
struct FWidgetFactoryConditionsColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FWidgetFactoryConstructorColumn : public FEditorDataStorageColumn {
};

// Size: 0x8
struct FWidgetFactoryConstructorTypeInfoColumn : public FEditorDataStorageColumn {
};

// Size: 0x20
struct FWidgetPurposeColumn : public FEditorDataStorageColumn {
};

// Size: 0x18
struct FWidgetPurposeNameColumn : public FEditorDataStorageColumn {
    /* 0x0000 */ FName Namespace;
    /* 0x0008 */ FName Name;
    /* 0x0010 */ FName Frame;
};

enum class ETypedElementChildInclusionMethod {
    None = 0,
    Immediate = 1,
    Recursive = 2,
    ETypedElementChildInclusionMethod_MAX = 3,
};

enum class ETypedElementSelectionMethod {
    Primary = 0,
    Secondary = 1,
    FromSecondary = 2,
    ETypedElementSelectionMethod_MAX = 3,
};

// Size: 0x28
class ITypedElementAssetDataInterface : public UInterface {

    TArray<FAssetData> GetAllReferencedAssetDatas(const FScriptTypedElementHandle& InElementHandle);
    FAssetData GetAssetData(const FScriptTypedElementHandle& InElementHandle);
};

// Size: 0x1
struct FTypedElementAssetDataReferencedOptions {
    /* 0x0000 */ bool bOnlyTopLevelAsset;
};

// Size: 0x28
class ITypedElementHierarchyInterface : public UInterface {

    void GetChildElements(const FScriptTypedElementHandle& InElementHandle, TArray<FScriptTypedElementHandle>& OutElementHandles, const bool bAllowCreate);
    FScriptTypedElementHandle GetParentElement(const FScriptTypedElementHandle& InElementHandle, const bool bAllowCreate);
};

// Size: 0xc
struct FTypedElementIsSelectedOptions {
    /* 0x0000 */ bool bAllowIndirect;
};

// Size: 0x28
class ITypedElementObjectInterface : public UInterface {

    UObject* GetObject(const FScriptTypedElementHandle& InElementHandle);
    UClass* GetObjectClass(const FScriptTypedElementHandle& InElementHandle);
};

// Size: 0x28
class ITypedElementPrimitiveCustomDataInterface : public UInterface {

    void SetCustomData(const FScriptTypedElementHandle& InElementHandle, const TArray<float>& CustomDataFloats, bool bMarkRenderStateDirty);
    void SetCustomDataValue(const FScriptTypedElementHandle& InElementHandle, int32_t CustomDataIndex, float CustomDataValue, bool bMarkRenderStateDirty);
};

// Size: 0x28
class ITypedElementSelectionInterface : public UInterface {

    bool AllowSelectionModifiers(const FScriptTypedElementHandle& InElementHandle, const FScriptTypedElementListProxy InSelectionSet);
    bool CanDeselectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions& InSelectionOptions);
    bool CanSelectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions& InSelectionOptions);
    bool DeselectElement(const FScriptTypedElementHandle& InElementHandle, FScriptTypedElementListProxy InSelectionSet, const FTypedElementSelectionOptions& InSelectionOptions);
    FScriptTypedElementHandle GetSelectionElement(const FScriptTypedElementHandle& InElementHandle, const FScriptTypedElementListProxy InCurrentSelection, const ETypedElementSelectionMethod InSelectionMethod);
    bool IsElementSelected(const FScriptTypedElementHandle& InElementHandle, const FScriptTypedElementListProxy InSelectionSet, const FTypedElementIsSelectedOptions& InSelectionOptions);
    bool SelectElement(const FScriptTypedElementHandle& InElementHandle, FScriptTypedElementListProxy InSelectionSet, const FTypedElementSelectionOptions& InSelectionOptions);
};

// Size: 0xc
struct FTypedElementSelectionNormalizationOptions {
    /* 0x0000 */ bool bExpandGroups;
    /* 0x0001 */ bool bFollowAttachment;
};

// Size: 0x10
struct FTypedElementSelectionOptions {
    /* 0x0000 */ bool bAllowHidden;
    /* 0x0001 */ bool bAllowGroups;
    /* 0x0002 */ bool bAllowLegacyNotifications;
    /* 0x0003 */ bool bWarnIfLocked;
    /* 0x0004 */ bool bAllowSubRootSelection;
    /* 0x0005 */ ETypedElementChildInclusionMethod ChildElementInclusionMethod;
};

// Size: 0x8a0
class UTypedElementSelectionSet : public UObject {
    /* 0x0828 */ FMulticastInlineDelegate OnPreSelectionChange;
    /* 0x0838 */ FMulticastInlineDelegate OnSelectionChange;

    bool AllowSelectionModifiers(const FScriptTypedElementHandle& InElementHandle) const;
    bool CanDeselectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
    bool CanSelectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
    bool ClearSelection(const FTypedElementSelectionOptions InSelectionOptions);
    int32_t CountSelectedElements(const UClass* InBaseInterfaceType) const;
    int32_t CountSelectedObjects(const UClass* InRequiredClass) const;
    bool DeselectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
    bool DeselectElements(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    UObject* GetBottomSelectedObject(const UClass* InRequiredClass) const;
    FTypedElementSelectionSetState GetCurrentSelectionState() const;
    int32_t GetNumSelectedElements() const;
    TArray<UObject*> GetSelectedObjects(const UClass* InRequiredClass) const;
    FScriptTypedElementHandle GetSelectionElement(const FScriptTypedElementHandle& InElementHandle, const ETypedElementSelectionMethod InSelectionMethod) const;
    UObject* GetTopSelectedObject(const UClass* InRequiredClass) const;
    bool HasSelectedElements(const UClass* InBaseInterfaceType) const;
    bool HasSelectedObjects(const UClass* InRequiredClass) const;
    bool IsElementSelected(const FScriptTypedElementHandle& InElementHandle, const FTypedElementIsSelectedOptions InSelectionOptions) const;
    TArray<FScriptTypedElementHandle> K2_GetSelectedElementHandles(const UClass* InBaseInterfaceType) const;
    void OnChangeDynamic__DelegateSignature(const UTypedElementSelectionSet* SelectionSet);
    void OnPreChangeDynamic__DelegateSignature(const UTypedElementSelectionSet* SelectionSet);
    void RestoreSelectionState(const FTypedElementSelectionSetState& InSelectionState);
    bool SelectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
    bool SelectElements(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    bool SetSelection(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
};

// Size: 0x28
class UTypedElementSelectionSetLibrary : public UObject {

    static bool DeselectElementsFromList(UTypedElementSelectionSet* SelectionSet, const FScriptTypedElementListProxy ElementList, const FTypedElementSelectionOptions SelectionOptions);
    static FScriptTypedElementListProxy GetNormalizedElementList(UTypedElementSelectionSet* SelectionSet, const FScriptTypedElementListProxy ElementList, const FTypedElementSelectionNormalizationOptions NormalizationOptions);
    static FScriptTypedElementListProxy GetNormalizedSelection(UTypedElementSelectionSet* SelectionSet, const FTypedElementSelectionNormalizationOptions NormalizationOptions);
    static bool SelectElementsFromList(UTypedElementSelectionSet* SelectionSet, const FScriptTypedElementListProxy ElementList, const FTypedElementSelectionOptions SelectionOptions);
    static bool SetSelectionFromList(UTypedElementSelectionSet* SelectionSet, const FScriptTypedElementListProxy ElementList, const FTypedElementSelectionOptions SelectionOptions);
};

// Size: 0x18
struct FTypedElementSelectionSetState {
    /* 0x0000 */ TWeakObjectPtr<UTypedElementSelectionSet> CreatedFromSelectionSet;
};

// Size: 0x40
struct FAnchorData {
    /* 0x0000 */ FMargin Offsets;
    /* 0x0010 */ FAnchors Anchors;
    /* 0x0030 */ FVector2D Alignment;
};

// Size: 0x28
struct FAnimationEventBinding {
    /* 0x0000 */ UWidgetAnimation* Animation;
    /* 0x0008 */ FDelegate Delegate;
    /* 0x0018 */ EWidgetAnimationEvent AnimationEvent;
    /* 0x001c */ FName UserTag;
};

// Size: 0x50
class UAsyncTaskDownloadImage : public UBlueprintAsyncActionBase {
    /* 0x0030 */ FMulticastInlineDelegate OnSuccess;
    /* 0x0040 */ FMulticastInlineDelegate OnFail;

    static UAsyncTaskDownloadImage* DownloadImage(FString URL);
};

// Size: 0x280
class UBackgroundBlur : public UContentWidget {
    /* 0x0180 */ FMargin Padding;
    /* 0x0190 */ uint8_t HorizontalAlignment;
    /* 0x0191 */ uint8_t VerticalAlignment;
    /* 0x0192 */ bool bApplyAlphaToBlur;
    /* 0x0194 */ float BlurStrength;
    /* 0x0198 */ bool bOverrideAutoRadiusCalculation;
    /* 0x019c */ int32_t BlurRadius;
    /* 0x01a0 */ FVector4 CornerRadius;
    /* 0x01c0 */ FSlateBrush LowQualityFallbackBrush;

    void SetApplyAlphaToBlur(bool bInApplyAlphaToBlur);
    void SetBlurRadius(int32_t InBlurRadius);
    void SetBlurStrength(float InStrength);
    void SetCornerRadius(FVector4 InCornerRadius);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetLowQualityFallbackBrush(const FSlateBrush& InBrush);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x60
class UBackgroundBlurSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ uint8_t HorizontalAlignment;
    /* 0x0049 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x1c
struct FBlueprintWidgetAnimationDelegateBinding {
    /* 0x0000 */ EWidgetAnimationEvent action;
    /* 0x0004 */ FName AnimationToBind;
    /* 0x000c */ FName FunctionNameToBind;
    /* 0x0014 */ FName UserTag;
};

// Size: 0x70
class UBoolBinding : public UPropertyBinding {

    bool GetValue() const;
};

// Size: 0x310
class UBorder : public UContentWidget {
    /* 0x0180 */ uint8_t HorizontalAlignment;
    /* 0x0181 */ uint8_t VerticalAlignment;
    /* 0x0182 */ bool bShowEffectWhenDisabled;
    /* 0x0184 */ FLinearColor ContentColorAndOpacity;
    /* 0x0194 */ FDelegate ContentColorAndOpacityDelegate;
    /* 0x01a4 */ FMargin Padding;
    /* 0x01c0 */ FSlateBrush Background;
    /* 0x0270 */ FDelegate BackgroundDelegate;
    /* 0x0280 */ FLinearColor BrushColor;
    /* 0x0290 */ FDelegate BrushColorDelegate;
    /* 0x02a0 */ FVector2D DesiredSizeScale;
    /* 0x02b0 */ bool bFlipForRightToLeftFlowDirection;
    /* 0x02b4 */ FDelegate OnMouseButtonDownEvent;
    /* 0x02c4 */ FDelegate OnMouseButtonUpEvent;
    /* 0x02d4 */ FDelegate OnMouseMoveEvent;
    /* 0x02e4 */ FDelegate OnMouseDoubleClickEvent;

    UMaterialInstanceDynamic* GetDynamicMaterial();
    void SetBrush(const FSlateBrush& InBrush);
    void SetBrushColor(FLinearColor InBrushColor);
    void SetBrushFromAsset(USlateBrushAsset* Asset);
    void SetBrushFromMaterial(UMaterialInterface* Material);
    void SetBrushFromTexture(UTexture2D* Texture);
    void SetContentColorAndOpacity(FLinearColor InContentColorAndOpacity);
    void SetDesiredSizeScale(FVector2D InScale);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetShowEffectWhenDisabled(bool bInShowEffectWhenDisabled);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x60
class UBorderSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ uint8_t HorizontalAlignment;
    /* 0x0049 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x78
class UBrushBinding : public UPropertyBinding {

    FSlateBrush GetValue() const;
};

// Size: 0x60
class UButtonSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ uint8_t HorizontalAlignment;
    /* 0x0049 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x190
class UCanvasPanel : public UPanelWidget {

    UCanvasPanelSlot* AddChildToCanvas(UWidget* Content);
};

// Size: 0x88
class UCanvasPanelSlot : public UPanelSlot {
    /* 0x0038 */ FAnchorData LayoutData;
    /* 0x0078 */ bool bAutoSize;
    /* 0x007c */ int32_t ZOrder;

    FVector2D GetAlignment() const;
    FAnchors GetAnchors() const;
    bool GetAutoSize() const;
    FAnchorData GetLayout() const;
    FMargin GetOffsets() const;
    FVector2D GetPosition() const;
    FVector2D GetSize() const;
    int32_t GetZOrder() const;
    void SetAlignment(FVector2D InAlignment);
    void SetAnchors(FAnchors InAnchors);
    void SetAutoSize(bool InbAutoSize);
    void SetLayout(const FAnchorData& InLayoutData);
    void SetMaximum(FVector2D InMaximumAnchors);
    void SetMinimum(FVector2D InMinimumAnchors);
    void SetOffsets(FMargin InOffset);
    void SetPosition(FVector2D InPosition);
    void SetSize(FVector2D InSize);
    void SetZOrder(int32_t InZOrder);
};

// Size: 0xb20
class UCheckBox : public UContentWidget {
    /* 0x0180 */ ECheckBoxState CheckedState;
    /* 0x0184 */ FDelegate CheckedStateDelegate;
    /* 0x01a0 */ FCheckBoxStyle WidgetStyle;
    /* 0x0af0 */ uint8_t HorizontalAlignment;
    /* 0x0af1 */ uint8_t ClickMethod;
    /* 0x0af2 */ uint8_t TouchMethod;
    /* 0x0af3 */ uint8_t PressMethod;
    /* 0x0af4 */ bool IsFocusable;
    /* 0x0af8 */ FMulticastInlineDelegate OnCheckStateChanged;

    ECheckBoxState GetCheckedState() const;
    bool IsChecked() const;
    bool IsPressed() const;
    void SetCheckedState(ECheckBoxState InCheckedState);
    void SetClickMethod(uint8_t InClickMethod);
    void SetIsChecked(bool InIsChecked);
    void SetPressMethod(uint8_t InPressMethod);
    void SetTouchMethod(uint8_t InTouchMethod);
};

// Size: 0x78
class UCheckedStateBinding : public UPropertyBinding {

    ECheckBoxState GetValue() const;
};

// Size: 0x250
class UCircularThrobber : public UWidget {
    /* 0x0168 */ int32_t NumberOfPieces;
    /* 0x016c */ float Period;
    /* 0x0170 */ float Radius;
    /* 0x0180 */ FSlateBrush Image;
    /* 0x0230 */ bool bEnableRadius;

    void SetNumberOfPieces(int32_t InNumberOfPieces);
    void SetPeriod(float InPeriod);
    void SetRadius(float InRadius);
};

// Size: 0x78
class UColorBinding : public UPropertyBinding {

    FLinearColor GetLinearValue() const;
    FSlateColor GetSlateValue() const;
};

// Size: 0x800
class UComboBox : public UWidget {
    /* 0x0170 */ FScrollBarStyle ScrollBarStyle;
    /* 0x07c0 */ TArray<UObject*> Items;
    /* 0x07d0 */ FDelegate OnGenerateWidgetEvent;
    /* 0x07e0 */ bool bIsFocusable;
};

// Size: 0x1970
class UComboBoxKey : public UWidget {
    /* 0x0168 */ TArray<FName> Options;
    /* 0x0178 */ FName SelectedOption;
    /* 0x0180 */ FComboBoxStyle WidgetStyle;
    /* 0x0740 */ FTableRowStyle ItemStyle;
    /* 0x1290 */ FScrollBarStyle ScrollBarStyle;
    /* 0x18e0 */ FSlateColor ForegroundColor;
    /* 0x18f4 */ FMargin ContentPadding;
    /* 0x1904 */ float MaxListHeight;
    /* 0x1908 */ bool bHasDownArrow;
    /* 0x1909 */ bool bEnableGamepadNavigationMode;
    /* 0x190a */ bool bIsFocusable;
    /* 0x190c */ FDelegate OnGenerateContentWidget;
    /* 0x191c */ FDelegate OnGenerateItemWidget;
    /* 0x1930 */ FMulticastInlineDelegate OnSelectionChanged;
    /* 0x1940 */ FMulticastInlineDelegate OnOpening;

    void AddOption(FName Option);
    void ClearOptions();
    void ClearSelection();
    UWidget* GenerateWidgetEvent__DelegateSignature(FName Item);
    FName GetSelectedOption() const;
    bool IsOpen() const;
    void OnOpeningEvent__DelegateSignature();
    void OnSelectionChangedEvent__DelegateSignature(FName SelectedItem, uint8_t SelectionType);
    bool RemoveOption(FName Option);
    void SetSelectedOption(FName Option);
};

// Size: 0x1a00
class UComboBoxString : public UWidget {
    /* 0x0168 */ TArray<FString> DefaultOptions;
    /* 0x0178 */ FString SelectedOption;
    /* 0x0190 */ FComboBoxStyle WidgetStyle;
    /* 0x0750 */ FTableRowStyle ItemStyle;
    /* 0x12a0 */ FScrollBarStyle ScrollBarStyle;
    /* 0x18f0 */ FMargin ContentPadding;
    /* 0x1900 */ float MaxListHeight;
    /* 0x1904 */ bool HasDownArrow;
    /* 0x1905 */ bool EnableGamepadNavigationMode;
    /* 0x1908 */ FSlateFontInfo Font;
    /* 0x1968 */ FSlateColor ForegroundColor;
    /* 0x197c */ bool bIsFocusable;
    /* 0x1980 */ FDelegate OnGenerateWidgetEvent;
    /* 0x1990 */ FMulticastInlineDelegate OnSelectionChanged;
    /* 0x19a0 */ FMulticastInlineDelegate OnOpening;

    void AddOption(FString Option);
    void ClearOptions();
    void ClearSelection();
    int32_t FindOptionIndex(FString Option) const;
    FString GetOptionAtIndex(int32_t Index) const;
    int32_t GetOptionCount() const;
    int32_t GetSelectedIndex() const;
    FString GetSelectedOption() const;
    bool IsOpen() const;
    void OnOpeningEvent__DelegateSignature();
    void OnSelectionChangedEvent__DelegateSignature(FString SelectedItem, uint8_t SelectionType);
    void RefreshOptions();
    bool RemoveOption(FString Option);
    void SetSelectedIndex(const int32_t Index);
    void SetSelectedOption(FString Option);
};

// Size: 0x180
class UContentWidget : public UPanelWidget {

    UWidget* GetContent() const;
    UPanelSlot* GetContentSlot() const;
    UPanelSlot* SetContent(UWidget* Content);
};

// Size: 0x60
struct FDelegateRuntimeBinding {
    /* 0x0000 */ FString ObjectName;
    /* 0x0010 */ FName PropertyName;
    /* 0x0018 */ FName FunctionName;
    /* 0x0020 */ FDynamicPropertyPath SourcePath;
    /* 0x0058 */ EBindingKind Kind;
};

// Size: 0x90
class UDragDropOperation : public UObject {
    /* 0x0028 */ FString Tag;
    /* 0x0038 */ UObject* Payload;
    /* 0x0040 */ UWidget* DefaultDragVisual;
    /* 0x0048 */ EDragPivot Pivot;
    /* 0x0050 */ FVector2D Offset;
    /* 0x0060 */ FMulticastInlineDelegate OnDrop;
    /* 0x0070 */ FMulticastInlineDelegate OnDragCancelled;
    /* 0x0080 */ FMulticastInlineDelegate OnDragged;

    void DragCancelled(const FPointerEvent& PointerEvent);
    void Dragged(const FPointerEvent& PointerEvent);
    void Drop(const FPointerEvent& PointerEvent);
};

// Size: 0x250
class UDynamicEntryBox : public UDynamicEntryBoxBase {
    /* 0x0248 */ UClass* EntryWidgetClass;

    UUserWidget* BP_CreateEntry();
    UUserWidget* BP_CreateEntryOfClass(UClass* EntryClass);
    void RemoveEntry(UUserWidget* EntryWidget);
    void Reset(bool bDeleteWidgets);
};

// Size: 0x248
class UDynamicEntryBoxBase : public UWidget {
    /* 0x0168 */ FVector2D EntrySpacing;
    /* 0x0178 */ TArray<FVector2D> SpacingPattern;
    /* 0x0188 */ EDynamicBoxType EntryBoxType;
    /* 0x018c */ FSlateChildSize EntrySizeRule;
    /* 0x0194 */ uint8_t EntryHorizontalAlignment;
    /* 0x0195 */ uint8_t EntryVerticalAlignment;
    /* 0x0198 */ int32_t MaxElementSize;
    /* 0x019c */ FRadialBoxSettings RadialBoxSettings;
    /* 0x01c0 */ FUserWidgetPool EntryWidgetPool;

    TArray<UUserWidget*> GetAllEntries() const;
    int32_t GetNumEntries() const;
    void SetEntrySpacing(const FVector2D& InEntrySpacing);
    void SetRadialSettings(const FRadialBoxSettings& InSettings);
};

// Size: 0x38
struct FDynamicPropertyPath : public FCachedPropertyPath {
};

enum class EBindingKind {
    Function = 0,
    Property = 1,
    EBindingKind_MAX = 2,
};

enum class EDragPivot {
    MouseDown = 0,
    TopLeft = 1,
    TopCenter = 2,
    TopRight = 3,
    CenterLeft = 4,
    CenterCenter = 5,
    CenterRight = 6,
    BottomLeft = 7,
    BottomCenter = 8,
    BottomRight = 9,
    EDragPivot_MAX = 10,
};

enum class EDynamicBoxType {
    Horizontal = 0,
    Vertical = 1,
    Wrap = 2,
    VerticalWrap = 3,
    Radial = 4,
    Overlay = 5,
    EDynamicBoxType_MAX = 6,
};

enum class ESlateAccessibleBehavior {
    NotAccessible = 0,
    Auto = 1,
    Summary = 2,
    Custom = 3,
    ToolTip = 4,
    ESlateAccessibleBehavior_MAX = 5,
};

enum class ESlateSizeRule {
    Automatic = 0,
    Fill = 1,
    ESlateSizeRule_MAX = 2,
};

enum class ESlateVisibility {
    Visible = 0,
    Collapsed = 1,
    Hidden = 2,
    HitTestInvisible = 3,
    SelfHitTestInvisible = 4,
    ESlateVisibility_MAX = 5,
};

enum class ETickMode {
    Disabled = 0,
    Enabled = 1,
    Automatic = 2,
    ETickMode_MAX = 3,
};

enum class EUMGSequencePlayMode {
    Forward = 0,
    Reverse = 1,
    PingPong = 2,
    EUMGSequencePlayMode_MAX = 3,
};

enum class EVirtualKeyboardType {
    Default = 0,
    Number = 1,
    Web = 2,
    Email = 3,
    Password = 4,
    AlphaNumeric = 5,
    EVirtualKeyboardType_MAX = 6,
};

enum class EWidgetAnimationEvent {
    Started = 0,
    Finished = 1,
    EWidgetAnimationEvent_MAX = 2,
};

enum class EWidgetBlendMode {
    Opaque = 0,
    Masked = 1,
    Transparent = 2,
    EWidgetBlendMode_MAX = 3,
};

enum class EWidgetDesignFlags {
    None = 0,
    Designing = 1,
    ShowOutline = 2,
    ExecutePreConstruct = 4,
    Previewing = 8,
    EWidgetDesignFlags_MAX = 9,
};

enum class EWidgetGeometryMode {
    Plane = 0,
    Cylinder = 1,
    EWidgetGeometryMode_MAX = 2,
};

enum class EWidgetInteractionSource {
    World = 0,
    Mouse = 1,
    CenterScreen = 2,
    Custom = 3,
    EWidgetInteractionSource_MAX = 4,
};

enum class EWidgetSpace {
    World = 0,
    Screen = 1,
    EWidgetSpace_MAX = 2,
};

enum class EWidgetTickFrequency {
    Never = 0,
    Auto = 1,
    EWidgetTickFrequency_MAX = 2,
};

enum class EWidgetTimingPolicy {
    RealTime = 0,
    GameTime = 1,
    EWidgetTimingPolicy_MAX = 2,
};

enum class EWindowVisibility {
    Visible = 0,
    SelfHitTestInvisible = 1,
    EWindowVisibility_MAX = 2,
};

// Size: 0x490
class UEditableText : public UWidget {
    /* 0x0168 */ FText Text;
    /* 0x0178 */ FDelegate TextDelegate;
    /* 0x0188 */ FText HintText;
    /* 0x0198 */ FDelegate HintTextDelegate;
    /* 0x01b0 */ FEditableTextStyle WidgetStyle;
    /* 0x0440 */ bool IsReadOnly;
    /* 0x0441 */ bool IsPassword;
    /* 0x0444 */ float MinimumDesiredWidth;
    /* 0x0448 */ bool IsCaretMovedWhenGainFocus;
    /* 0x0449 */ bool SelectAllTextWhenFocused;
    /* 0x044a */ bool RevertTextOnEscape;
    /* 0x044b */ bool ClearKeyboardFocusOnCommit;
    /* 0x044c */ bool SelectAllTextOnCommit;
    /* 0x044d */ bool AllowContextMenu;
    /* 0x044e */ uint8_t KeyboardType;
    /* 0x044f */ FVirtualKeyboardOptions VirtualKeyboardOptions;
    /* 0x0450 */ EVirtualKeyboardTrigger VirtualKeyboardTrigger;
    /* 0x0451 */ EVirtualKeyboardDismissAction VirtualKeyboardDismissAction;
    /* 0x0452 */ uint8_t Justification;
    /* 0x0453 */ ETextOverflowPolicy OverflowPolicy;
    /* 0x0454 */ FShapedTextOptions ShapedTextOptions;
    /* 0x0458 */ FMulticastInlineDelegate OnTextChanged;
    /* 0x0468 */ FMulticastInlineDelegate OnTextCommitted;
    /* 0x0488 */ bool EnableIntegratedKeyboard;

    FSlateFontInfo GetFont() const;
    FText GetHintText() const;
    uint8_t GetJustification() const;
    FText GetText() const;
    void OnEditableTextChangedEvent__DelegateSignature(const FText& Text);
    void OnEditableTextCommittedEvent__DelegateSignature(const FText& Text, uint8_t CommitMethod);
    void SetFont(FSlateFontInfo InFontInfo);
    void SetFontMaterial(UMaterialInterface* InMaterial);
    void SetFontOutlineMaterial(UMaterialInterface* InMaterial);
    void SetHintText(FText InHintText);
    void SetIsPassword(bool InbIsPassword);
    void SetIsReadOnly(bool InbIsReadyOnly);
    void SetJustification(uint8_t InJustification);
    void SetMinimumDesiredWidth(float InMinDesiredWidth);
    void SetText(FText InText);
    void SetTextOverflowPolicy(ETextOverflowPolicy InOverflowPolicy);
};

// Size: 0xe80
class UEditableTextBox : public UWidget {
    /* 0x0168 */ FText Text;
    /* 0x0178 */ FDelegate TextDelegate;
    /* 0x0190 */ FEditableTextBoxStyle WidgetStyle;
    /* 0x0e10 */ FText HintText;
    /* 0x0e20 */ FDelegate HintTextDelegate;
    /* 0x0e30 */ bool IsReadOnly;
    /* 0x0e31 */ bool IsPassword;
    /* 0x0e34 */ float MinimumDesiredWidth;
    /* 0x0e38 */ bool IsCaretMovedWhenGainFocus;
    /* 0x0e39 */ bool SelectAllTextWhenFocused;
    /* 0x0e3a */ bool RevertTextOnEscape;
    /* 0x0e3b */ bool ClearKeyboardFocusOnCommit;
    /* 0x0e3c */ bool SelectAllTextOnCommit;
    /* 0x0e3d */ bool AllowContextMenu;
    /* 0x0e3e */ uint8_t KeyboardType;
    /* 0x0e3f */ FVirtualKeyboardOptions VirtualKeyboardOptions;
    /* 0x0e40 */ EVirtualKeyboardTrigger VirtualKeyboardTrigger;
    /* 0x0e41 */ EVirtualKeyboardDismissAction VirtualKeyboardDismissAction;
    /* 0x0e42 */ uint8_t Justification;
    /* 0x0e43 */ ETextOverflowPolicy OverflowPolicy;
    /* 0x0e44 */ FShapedTextOptions ShapedTextOptions;
    /* 0x0e48 */ FMulticastInlineDelegate OnTextChanged;
    /* 0x0e58 */ FMulticastInlineDelegate OnTextCommitted;

    void ClearError();
    FText GetText() const;
    bool HasError() const;
    void OnEditableTextBoxChangedEvent__DelegateSignature(const FText& Text);
    void OnEditableTextBoxCommittedEvent__DelegateSignature(const FText& Text, uint8_t CommitMethod);
    void SetError(FText InError);
    void SetForegroundColor(FLinearColor Color);
    void SetHintText(FText InText);
    void SetIsPassword(bool bIsPassword);
    void SetIsReadOnly(bool bReadOnly);
    void SetJustification(uint8_t InJustification);
    void SetText(FText InText);
    void SetTextOverflowPolicy(ETextOverflowPolicy InOverflowPolicy);
};

// Size: 0xb8
struct FEventReply {
};

// Size: 0x410
class UExpandableArea : public UWidget {
    /* 0x0170 */ FExpandableAreaStyle style;
    /* 0x02f0 */ FSlateBrush BorderBrush;
    /* 0x03a0 */ FSlateColor BorderColor;
    /* 0x03b4 */ bool bIsExpanded;
    /* 0x03b8 */ float maxHeight;
    /* 0x03bc */ FMargin HeaderPadding;
    /* 0x03cc */ FMargin AreaPadding;
    /* 0x03e0 */ FMulticastInlineDelegate OnExpansionChanged;
    /* 0x03f0 */ UWidget* HeaderContent;
    /* 0x03f8 */ UWidget* BodyContent;

    bool GetIsExpanded() const;
    void SetIsExpanded(bool IsExpanded);
    void SetIsExpanded_Animated(bool IsExpanded);
};

// Size: 0x70
class UFloatBinding : public UPropertyBinding {

    float GetValue() const;
};

// Size: 0xb0
class UGameViewportSubsystem : public UEngineSubsystem {

    bool AddWidget(UWidget* Widget, FGameViewportWidgetSlot Slot);
    bool AddWidgetForPlayer(UWidget* Widget, ULocalPlayer* Player, FGameViewportWidgetSlot Slot);
    FGameViewportWidgetSlot GetWidgetSlot(const UWidget* Widget) const;
    bool IsWidgetAdded(const UWidget* Widget) const;
    void RemoveWidget(UWidget* Widget);
    void SetWidgetSlot(UWidget* Widget, FGameViewportWidgetSlot Slot);
    static FGameViewportWidgetSlot SetWidgetSlotDesiredSize(FGameViewportWidgetSlot Slot, FVector2D Size);
    static FGameViewportWidgetSlot SetWidgetSlotPosition(FGameViewportWidgetSlot Slot, const UWidget* Widget, FVector2D position, bool bRemoveDPIScale);
};

// Size: 0x48
struct FGameViewportWidgetSlot {
    /* 0x0000 */ FAnchors Anchors;
    /* 0x0020 */ FMargin Offsets;
    /* 0x0030 */ FVector2D Alignment;
    /* 0x0040 */ int32_t ZOrder;
    /* 0x0044 */ bool bAutoRemoveOnWorldRemoved;
};

// Size: 0x1b0
class UGridPanel : public UPanelWidget {
    /* 0x0180 */ TArray<float> ColumnFill;
    /* 0x0190 */ TArray<float> RowFill;

    UGridSlot* AddChildToGrid(UWidget* Content, int32_t InRow, int32_t InColumn);
    void SetColumnFill(int32_t ColumnIndex, float Coefficient);
    void SetRowFill(int32_t RowIndex, float Coefficient);
};

// Size: 0x78
class UGridSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ uint8_t HorizontalAlignment;
    /* 0x0049 */ uint8_t VerticalAlignment;
    /* 0x004c */ int32_t Row;
    /* 0x0050 */ int32_t RowSpan;
    /* 0x0054 */ int32_t Column;
    /* 0x0058 */ int32_t ColumnSpan;
    /* 0x005c */ int32_t Layer;
    /* 0x0060 */ FVector2D Nudge;

    void SetColumn(int32_t InColumn);
    void SetColumnSpan(int32_t InColumnSpan);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetLayer(int32_t InLayer);
    void SetNudge(FVector2D InNudge);
    void SetPadding(FMargin InPadding);
    void SetRow(int32_t InRow);
    void SetRowSpan(int32_t InRowSpan);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x190
class UHorizontalBox : public UPanelWidget {

    UHorizontalBoxSlot* AddChildToHorizontalBox(UWidget* Content);
};

// Size: 0x60
class UHorizontalBoxSlot : public UPanelSlot {
    /* 0x0040 */ FSlateChildSize Size;
    /* 0x0048 */ FMargin Padding;
    /* 0x0058 */ uint8_t HorizontalAlignment;
    /* 0x0059 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetSize(FSlateChildSize InSize);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x2b0
class UImage : public UWidget {
    /* 0x0170 */ FSlateBrush Brush;
    /* 0x0220 */ FDelegate BrushDelegate;
    /* 0x0230 */ FLinearColor ColorAndOpacity;
    /* 0x0240 */ FDelegate ColorAndOpacityDelegate;
    /* 0x0250 */ bool bFlipForRightToLeftFlowDirection;
    /* 0x0254 */ FDelegate OnMouseButtonDownEvent;

    UMaterialInstanceDynamic* GetDynamicMaterial();
    void SetBrush(const FSlateBrush& InBrush);
    void SetBrushFromAsset(USlateBrushAsset* Asset);
    void SetBrushFromAtlasInterface(TScriptInterface<ISlateTextureAtlasInterface> AtlasRegion, bool bMatchSize);
    void SetBrushFromMaterial(UMaterialInterface* Material);
    void SetBrushFromSoftMaterial(TSoftObjectPtr<UMaterialInterface> SoftMaterial);
    void SetBrushFromSoftTexture(TSoftObjectPtr<UTexture2D> SoftTexture, bool bMatchSize);
    void SetBrushFromTexture(UTexture2D* Texture, bool bMatchSize);
    void SetBrushFromTextureDynamic(UTexture2DDynamic* Texture, bool bMatchSize);
    void SetBrushResourceObject(UObject* ResourceObject);
    void SetBrushTintColor(FSlateColor TintColor);
    void SetColorAndOpacity(FLinearColor InColorAndOpacity);
    void SetDesiredSizeOverride(FVector2D DesiredSize);
    void SetOpacity(float InOpacity);
};

// Size: 0x880
class UInputKeySelector : public UWidget {
    /* 0x0170 */ FButtonStyle WidgetStyle;
    /* 0x0500 */ FTextBlockStyle TextStyle;
    /* 0x07e0 */ FInputChord SelectedKey;
    /* 0x0800 */ FMargin Margin;
    /* 0x0810 */ FText KeySelectionText;
    /* 0x0820 */ FText NoKeySpecifiedText;
    /* 0x0830 */ bool bAllowModifierKeys;
    /* 0x0831 */ bool bAllowGamepadKeys;
    /* 0x0838 */ TArray<FKey> EscapeKeys;
    /* 0x0848 */ FMulticastInlineDelegate OnKeySelected;
    /* 0x0858 */ FMulticastInlineDelegate OnIsSelectingKeyChanged;

    bool GetIsSelectingKey() const;
    void OnIsSelectingKeyChanged__DelegateSignature();
    void OnKeySelected__DelegateSignature(FInputChord SelectedKey);
    void SetAllowGamepadKeys(bool bInAllowGamepadKeys);
    void SetAllowModifierKeys(bool bInAllowModifierKeys);
    void SetEscapeKeys(const TArray<FKey>& InKeys);
    void SetKeySelectionText(FText InKeySelectionText);
    void SetNoKeySpecifiedText(FText InNoKeySpecifiedText);
    void SetSelectedKey(const FInputChord& InSelectedKey);
    void SetTextBlockVisibility(const ESlateVisibility InVisibility);
};

// Size: 0x70
class UInt32Binding : public UPropertyBinding {

    int32_t GetValue() const;
};

// Size: 0x198
class UInvalidationBox : public UContentWidget {
    /* 0x0180 */ bool bCanCache;

    bool GetCanCache() const;
    void InvalidateCache();
    void SetCanCache(bool CanCache);
};

// Size: 0xb70
class UListView : public UListViewBase {
    /* 0x0390 */ FTableViewStyle WidgetStyle;
    /* 0x0450 */ FScrollBarStyle ScrollBarStyle;
    /* 0x0aa0 */ uint8_t Orientation;
    /* 0x0aa1 */ uint8_t SelectionMode;
    /* 0x0aa2 */ EConsumeMouseWheel ConsumeMouseWheel;
    /* 0x0aa3 */ bool bClearSelectionOnClick;
    /* 0x0aa4 */ bool bIsFocusable;
    /* 0x0aa5 */ bool bClearScrollVelocityOnSelection;
    /* 0x0aa6 */ bool bReturnFocusToSelection;
    /* 0x0aa7 */ EScrollIntoViewAlignment ScrollIntoViewAlignment;
    /* 0x0aa8 */ TArray<UObject*> ListItems;
    /* 0x0ac8 */ float HorizontalEntrySpacing;
    /* 0x0acc */ float VerticalEntrySpacing;
    /* 0x0ad0 */ FMargin ScrollBarPadding;
    /* 0x0ae0 */ FMulticastInlineDelegate BP_OnEntryInitialized;
    /* 0x0af0 */ FMulticastInlineDelegate BP_OnItemClicked;
    /* 0x0b00 */ FMulticastInlineDelegate BP_OnItemDoubleClicked;
    /* 0x0b10 */ FMulticastInlineDelegate BP_OnItemIsHoveredChanged;
    /* 0x0b20 */ FMulticastInlineDelegate BP_OnItemSelectionChanged;
    /* 0x0b30 */ FMulticastInlineDelegate BP_OnItemScrolledIntoView;
    /* 0x0b40 */ FMulticastInlineDelegate BP_OnListViewScrolled;
    /* 0x0b50 */ FMulticastInlineDelegate BP_OnListViewFinishedScrolling;
    /* 0x0b60 */ FDelegate BP_OnIsItemSelectableOrNavigable;

    void AddItem(UObject* Item);
    void BP_CancelScrollIntoView();
    void BP_ClearSelection();
    int32_t BP_GetNumItemsSelected() const;
    UObject* BP_GetSelectedItem() const;
    bool BP_GetSelectedItems(TArray<UObject*>& Items) const;
    bool BP_IsItemVisible(UObject* Item) const;
    void BP_NavigateToItem(UObject* Item);
    void BP_ScrollItemIntoView(UObject* Item);
    void BP_SetItemSelection(UObject* Item, bool bSelected);
    void BP_SetListItems(const TArray<UObject*>& InListItems);
    void BP_SetSelectedItem(UObject* Item);
    void ClearListItems();
    float GetHorizontalEntrySpacing() const;
    int32_t GetIndexForItem(const UObject* Item) const;
    UObject* GetItemAt(int32_t Index) const;
    TArray<UObject*> GetListItems() const;
    int32_t GetNumItems() const;
    FMargin GetScrollBarPadding() const;
    float GetVerticalEntrySpacing() const;
    bool IsRefreshPending() const;
    void NavigateToIndex(int32_t Index);
    void OnListItemEndPlayed(AActor* Item, uint8_t EndPlayReason);
    void OnListItemOuterEndPlayed(AActor* ItemOuter, uint8_t EndPlayReason);
    void RemoveItem(UObject* Item);
    void ScrollIndexIntoView(int32_t Index);
    void SetScrollBarPadding(const FMargin& InScrollBarPadding);
    void SetScrollIntoViewAlignment(EScrollIntoViewAlignment NewScrollIntoViewAlignment);
    void SetSelectedIndex(int32_t Index);
    void SetSelectionMode(uint8_t SelectionMode);
};

// Size: 0x2a0
class UListViewBase : public UWidget {
    /* 0x0168 */ FMulticastInlineDelegate BP_OnEntryGenerated;
    /* 0x0178 */ FMulticastInlineDelegate BP_OnEntriesGenerated;
    /* 0x0198 */ UClass* EntryWidgetClass;
    /* 0x01a0 */ float WheelScrollMultiplier;
    /* 0x01a4 */ bool bEnableScrollAnimation;
    /* 0x01a8 */ float ScrollingAnimationInterpolationSpeed;
    /* 0x01ac */ bool bInEnableTouchAnimatedScrolling;
    /* 0x01ad */ bool AllowOverscroll;
    /* 0x01ae */ bool bEnableRightClickScrolling;
    /* 0x01af */ bool bEnableTouchScrolling;
    /* 0x01b0 */ bool bIsPointerScrollingEnabled;
    /* 0x01b1 */ bool bIsGamepadScrollingEnabled;
    /* 0x01b2 */ bool bEnableFixedLineOffset;
    /* 0x01b4 */ float FixedLineScrollOffset;
    /* 0x01b8 */ bool bAllowDragging;
    /* 0x01b9 */ bool bSelectItemOnNavigation;
    /* 0x01c0 */ FMulticastInlineDelegate BP_OnEntryReleased;
    /* 0x01d0 */ FUserWidgetPool EntryWidgetPool;

    void EndInertialScrolling();
    TArray<UUserWidget*> GetDisplayedEntryWidgets() const;
    float GetScrollOffset() const;
    void RegenerateAllEntries();
    void RequestRefresh();
    void ScrollToBottom();
    void ScrollToTop();
    void SetIsGamepadScrollingEnabled(bool bInIsGamepadScrollingEnabled);
    void SetIsPointerScrollingEnabled(bool bInIsPointerScrollingEnabled);
    void SetScrollOffset(const float InScrollOffset);
    void SetScrollbarVisibility(ESlateVisibility InVisibility);
    void SetWheelScrollMultiplier(float NewWheelScrollMultiplier);
};

// Size: 0x28
class UListViewDesignerPreviewItem : public UObject {
};

// Size: 0x1d0
class UMenuAnchor : public UContentWidget {
    /* 0x0180 */ UClass* MenuClass;
    /* 0x0188 */ FDelegate OnGetMenuContentEvent;
    /* 0x0198 */ FDelegate OnGetUserMenuContentEvent;
    /* 0x01a8 */ uint8_t Placement;
    /* 0x01a9 */ bool bFitInWindow;
    /* 0x01aa */ bool ShouldDeferPaintingAfterWindowContent;
    /* 0x01ab */ bool UseApplicationMenuStack;
    /* 0x01ac */ bool ShowMenuBackground;
    /* 0x01b0 */ FMulticastInlineDelegate OnMenuOpenChanged;

    void Close();
    void FitInWindow(bool bFit);
    FVector2D GetMenuPosition() const;
    UUserWidget* GetUserWidget__DelegateSignature();
    bool HasOpenSubMenus() const;
    bool IsOpen() const;
    void Open(bool bFocusMenu);
    void SetPlacement(uint8_t InPlacement);
    bool ShouldOpenDueToClick() const;
    void ToggleOpen(bool bFocusOnOpen);
};

// Size: 0x70
class UMouseCursorBinding : public UPropertyBinding {

    uint8_t GetValue() const;
};

// Size: 0x4
struct FMovieScene2DTransformMask {
    /* 0x0000 */ uint32_t Mask;
};

// Size: 0x58
class UMovieScene2DTransformPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x888
class UMovieScene2DTransformSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieScene2DTransformMask TransformMask;
    /* 0x0118 */ FMovieSceneFloatChannel Translation[2];
    /* 0x0338 */ FMovieSceneFloatChannel Rotation;
    /* 0x0448 */ FMovieSceneFloatChannel Scale[2];
    /* 0x0668 */ FMovieSceneFloatChannel Shear[2];
};

// Size: 0x140
class UMovieScene2DTransformTrack : public UMovieScenePropertyTrack {
};

// Size: 0x58
class UMovieSceneMarginPropertySystem : public UMovieScenePropertySystem {
};

// Size: 0x550
class UMovieSceneMarginSection : public UMovieSceneSection {
    /* 0x0110 */ FMovieSceneFloatChannel TopCurve;
    /* 0x0220 */ FMovieSceneFloatChannel LeftCurve;
    /* 0x0330 */ FMovieSceneFloatChannel RightCurve;
    /* 0x0440 */ FMovieSceneFloatChannel BottomCurve;
};

// Size: 0x140
class UMovieSceneMarginTrack : public UMovieScenePropertyTrack {
};

// Size: 0x208
class UMovieSceneWidgetMaterialSystem : public UMovieSceneEntitySystem {
};

// Size: 0x150
class UMovieSceneWidgetMaterialTrack : public UMovieSceneMaterialTrack {
    /* 0x0138 */ TArray<FName> BrushPropertyNamePath;
    /* 0x0148 */ FName TrackName;
};

// Size: 0x4e0
class UMultiLineEditableText : public UTextLayoutWidget {
    /* 0x0188 */ FText Text;
    /* 0x0198 */ FText HintText;
    /* 0x01a8 */ FDelegate HintTextDelegate;
    /* 0x01c0 */ FTextBlockStyle WidgetStyle;
    /* 0x04a0 */ bool bIsReadOnly;
    /* 0x04a1 */ bool SelectAllTextWhenFocused;
    /* 0x04a2 */ bool ClearTextSelectionOnFocusLoss;
    /* 0x04a3 */ bool RevertTextOnEscape;
    /* 0x04a4 */ bool ClearKeyboardFocusOnCommit;
    /* 0x04a5 */ bool AllowContextMenu;
    /* 0x04a6 */ FVirtualKeyboardOptions VirtualKeyboardOptions;
    /* 0x04a7 */ EVirtualKeyboardDismissAction VirtualKeyboardDismissAction;
    /* 0x04a8 */ FMulticastInlineDelegate OnTextChanged;
    /* 0x04b8 */ FMulticastInlineDelegate OnTextCommitted;

    FSlateFontInfo GetFont() const;
    FText GetHintText() const;
    FText GetText() const;
    void OnMultiLineEditableTextChangedEvent__DelegateSignature(const FText& Text);
    void OnMultiLineEditableTextCommittedEvent__DelegateSignature(const FText& Text, uint8_t CommitMethod);
    void SetFont(FSlateFontInfo InFontInfo);
    void SetFontMaterial(UMaterialInterface* InMaterial);
    void SetFontOutlineMaterial(UMaterialInterface* InMaterial);
    void SetHintText(FText InHintText);
    void SetIsReadOnly(bool bReadOnly);
    void SetText(FText InText);
    void SetWidgetStyle(const FTextBlockStyle& InWidgetStyle);
};

// Size: 0xe80
class UMultiLineEditableTextBox : public UTextLayoutWidget {
    /* 0x0188 */ FText Text;
    /* 0x0198 */ FText HintText;
    /* 0x01a8 */ FDelegate HintTextDelegate;
    /* 0x01c0 */ FEditableTextBoxStyle WidgetStyle;
    /* 0x0e40 */ bool bIsReadOnly;
    /* 0x0e41 */ bool AllowContextMenu;
    /* 0x0e42 */ FVirtualKeyboardOptions VirtualKeyboardOptions;
    /* 0x0e43 */ EVirtualKeyboardDismissAction VirtualKeyboardDismissAction;
    /* 0x0e48 */ FMulticastInlineDelegate OnTextChanged;
    /* 0x0e58 */ FMulticastInlineDelegate OnTextCommitted;

    FText GetHintText() const;
    FText GetText() const;
    void OnMultiLineEditableTextBoxChangedEvent__DelegateSignature(const FText& Text);
    void OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature(const FText& Text, uint8_t CommitMethod);
    void SetError(FText InError);
    void SetForegroundColor(FLinearColor Color);
    void SetHintText(FText InHintText);
    void SetIsReadOnly(bool bReadOnly);
    void SetText(FText InText);
    void SetTextStyle(const FTextBlockStyle& InTextStyle);
};

// Size: 0x190
class UNamedSlot : public UContentWidget {
};

// Size: 0x10
struct FNamedSlotBinding {
    /* 0x0000 */ FName Name;
    /* 0x0008 */ UWidget* Content;
};

// Size: 0x28
class INamedSlotInterface : public UInterface {
};

// Size: 0x178
class UNativeWidgetHost : public UWidget {
};

// Size: 0x190
class UOverlay : public UPanelWidget {

    UOverlaySlot* AddChildToOverlay(UWidget* Content);
    bool ReplaceOverlayChildAt(int32_t Index, UWidget* Content);
};

// Size: 0x58
class UOverlaySlot : public UPanelSlot {
    /* 0x0040 */ FMargin Padding;
    /* 0x0050 */ uint8_t HorizontalAlignment;
    /* 0x0051 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x30
struct FPaintContext {
};

// Size: 0x38
class UPanelSlot : public UVisual {
    /* 0x0028 */ UPanelWidget* Parent;
    /* 0x0030 */ UWidget* Content;

    UWidget* GetContent() const;
};

// Size: 0x180
class UPanelWidget : public UWidget {
    /* 0x0168 */ TArray<UPanelSlot*> Slots;

    UPanelSlot* AddChild(UWidget* Content);
    void ClearChildren();
    TArray<UWidget*> GetAllChildren() const;
    UWidget* GetChildAt(int32_t Index) const;
    int32_t GetChildIndex(const UWidget* Content) const;
    int32_t GetChildrenCount() const;
    bool HasAnyChildren() const;
    bool HasChild(UWidget* Content) const;
    bool RemoveChild(UWidget* Content);
    bool RemoveChildAt(int32_t Index);
};

// Size: 0x38
class UPostBufferBlurUpdater : public USlatePostBufferProcessorUpdater {
    /* 0x0030 */ float GaussianBlurStrength;
};

// Size: 0x1a0
class UPostBufferUpdate : public UWidget {
    /* 0x0168 */ bool bUpdateOnlyPaintArea;
    /* 0x0169 */ bool bPerformDefaultPostBufferUpdate;
    /* 0x0170 */ TArray<ESlatePostRT> BuffersToUpdate;
    /* 0x0180 */ TArray<FSlatePostBufferUpdateInfo> UpdateBufferInfos;
};

// Size: 0x400
class UProgressBar : public UWidget {
    /* 0x0170 */ FProgressBarStyle WidgetStyle;
    /* 0x03a0 */ float Percent;
    /* 0x03a4 */ uint8_t BarFillType;
    /* 0x03a5 */ uint8_t BarFillStyle;
    /* 0x03a6 */ bool bIsMarquee;
    /* 0x03a8 */ FVector2D BorderPadding;
    /* 0x03b8 */ FDelegate PercentDelegate;
    /* 0x03c8 */ FLinearColor FillColorAndOpacity;
    /* 0x03d8 */ FDelegate FillColorAndOpacityDelegate;

    void SetFillColorAndOpacity(FLinearColor InColor);
    void SetIsMarquee(bool InbIsMarquee);
    void SetPercent(float InPercent);
};

// Size: 0x70
class UPropertyBinding : public UObject {
    /* 0x0028 */ TWeakObjectPtr<UObject> SourceObject;
    /* 0x0030 */ FDynamicPropertyPath SourcePath;
    /* 0x0068 */ FName DestinationProperty;
};

// Size: 0x38
struct FQueuedWidgetAnimationTransition {
    /* 0x0000 */ UWidgetAnimation* WidgetAnimation;
};

// Size: 0x10
struct FRadialBoxSettings {
    /* 0x0000 */ float StartingAngle;
    /* 0x0004 */ bool bDistributeItemsEvenly;
    /* 0x0008 */ float AngleBetweenItems;
    /* 0x000c */ float SectorCentralAngle;
};

// Size: 0x1b0
class URetainerBox : public UContentWidget {
    /* 0x0180 */ bool bRetainRender;
    /* 0x0181 */ bool RenderOnInvalidation;
    /* 0x0182 */ bool RenderOnPhase;
    /* 0x0184 */ int32_t Phase;
    /* 0x0188 */ int32_t PhaseCount;
    /* 0x0190 */ UMaterialInterface* EffectMaterial;
    /* 0x0198 */ FName TextureParameter;

    UMaterialInstanceDynamic* GetEffectMaterial() const;
    void RequestRender();
    void SetEffectMaterial(UMaterialInterface* EffectMaterial);
    void SetRenderingPhase(int32_t RenderPhase, int32_t TotalPhases);
    void SetRetainRendering(bool bInRetainRendering);
    void SetTextureParameter(FName TextureParameter);
};

// Size: 0xc0
struct FRichImageRow : public FTableRowBase {
    /* 0x0010 */ FSlateBrush Brush;
};

// Size: 0x7b0
class URichTextBlock : public UTextLayoutWidget {
    /* 0x0188 */ FText Text;
    /* 0x0198 */ UDataTable* TextStyleSet;
    /* 0x01a0 */ TArray<UClass*> DecoratorClasses;
    /* 0x01b0 */ FTextBlockStyle DefaultTextStyleOverride;
    /* 0x0490 */ float MinDesiredWidth;
    /* 0x0494 */ bool bOverrideDefaultStyle;
    /* 0x0495 */ ETextTransformPolicy TextTransformPolicy;
    /* 0x0496 */ ETextOverflowPolicy TextOverflowPolicy;
    /* 0x04a0 */ FTextBlockStyle DefaultTextStyle;
    /* 0x0780 */ TArray<URichTextBlockDecorator*> InstanceDecorators;

    void ClearAllDefaultStyleOverrides();
    URichTextBlockDecorator* GetDecoratorByClass(UClass* DecoratorClass);
    UMaterialInstanceDynamic* GetDefaultDynamicMaterial();
    FText GetText() const;
    UDataTable* GetTextStyleSet() const;
    void RefreshTextLayout();
    void SetAutoWrapText(bool InAutoTextWrap);
    void SetDecorators(const TArray<UClass*>& InDecoratorClasses);
    void SetDefaultColorAndOpacity(FSlateColor InColorAndOpacity);
    void SetDefaultFont(FSlateFontInfo InFontInfo);
    void SetDefaultMaterial(UMaterialInterface* InMaterial);
    void SetDefaultShadowColorAndOpacity(FLinearColor InShadowColorAndOpacity);
    void SetDefaultShadowOffset(FVector2D InShadowOffset);
    void SetDefaultStrikeBrush(const FSlateBrush& InStrikeBrush);
    void SetDefaultTextStyle(const FTextBlockStyle& InDefaultTextStyle);
    void SetMinDesiredWidth(float InMinDesiredWidth);
    void SetText(const FText& InText);
    void SetTextOverflowPolicy(ETextOverflowPolicy InOverflowPolicy);
    void SetTextStyleSet(UDataTable* NewTextStyleSet);
    void SetTextTransformPolicy(ETextTransformPolicy InTransformPolicy);
};

// Size: 0x28
class URichTextBlockDecorator : public UObject {
};

// Size: 0x30
class URichTextBlockImageDecorator : public URichTextBlockDecorator {
    /* 0x0028 */ UDataTable* ImageSet;
};

// Size: 0x2f0
struct FRichTextStyleRow : public FTableRowBase {
    /* 0x0010 */ FTextBlockStyle TextStyle;
};

// Size: 0x198
class USafeZone : public UContentWidget {
    /* 0x0180 */ bool PadLeft;
    /* 0x0181 */ bool PadRight;
    /* 0x0182 */ bool PadTop;
    /* 0x0183 */ bool PadBottom;

    void SetSidesToPad(bool InPadLeft, bool InPadRight, bool InPadTop, bool InPadBottom);
};

// Size: 0x70
class USafeZoneSlot : public UPanelSlot {
    /* 0x0038 */ bool bIsTitleSafe;
    /* 0x003c */ FMargin SafeAreaScale;
    /* 0x004c */ uint8_t HAlign;
    /* 0x004d */ uint8_t VAlign;
    /* 0x0050 */ FMargin Padding;
};

// Size: 0x1a0
class UScaleBox : public UContentWidget {
    /* 0x0180 */ uint8_t Stretch;
    /* 0x0181 */ uint8_t StretchDirection;
    /* 0x0184 */ float UserSpecifiedScale;
    /* 0x0188 */ bool IgnoreInheritedScale;

    void SetIgnoreInheritedScale(bool bInIgnoreInheritedScale);
    void SetStretch(uint8_t InStretch);
    void SetStretchDirection(uint8_t InStretchDirection);
    void SetUserSpecifiedScale(float InUserSpecifiedScale);
};

// Size: 0x50
class UScaleBoxSlot : public UPanelSlot {
    /* 0x0038 */ uint8_t HorizontalAlignment;
    /* 0x0039 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x800
class UScrollBar : public UWidget {
    /* 0x0170 */ FScrollBarStyle WidgetStyle;
    /* 0x07c0 */ bool bAlwaysShowScrollbar;
    /* 0x07c1 */ bool bAlwaysShowScrollbarTrack;
    /* 0x07c2 */ uint8_t Orientation;
    /* 0x07c8 */ FVector2D Thickness;
    /* 0x07d8 */ FMargin Padding;

    void SetState(float InOffsetFraction, float InThumbSizeFraction);
};

// Size: 0xb90
class UScrollBox : public UPanelWidget {
    /* 0x0180 */ float ScrollAnimationInterpolationSpeed;
    /* 0x0184 */ bool bEnableTouchScrolling;
    /* 0x0185 */ bool bConsumePointerInput;
    /* 0x0188 */ FKey AnalogMouseWheelKey;
    /* 0x01a0 */ bool bIsFocusable;
    /* 0x01b0 */ FScrollBoxStyle WidgetStyle;
    /* 0x04a0 */ FScrollBarStyle WidgetBarStyle;
    /* 0x0af0 */ uint8_t Orientation;
    /* 0x0af1 */ ESlateVisibility ScrollBarVisibility;
    /* 0x0af2 */ EConsumeMouseWheel ConsumeMouseWheel;
    /* 0x0af8 */ FVector2D ScrollbarThickness;
    /* 0x0b08 */ FMargin ScrollBarPadding;
    /* 0x0b18 */ bool AlwaysShowScrollbar;
    /* 0x0b19 */ bool AlwaysShowScrollbarTrack;
    /* 0x0b1a */ bool AllowOverscroll;
    /* 0x0b1b */ bool BackPadScrolling;
    /* 0x0b1c */ bool FrontPadScrolling;
    /* 0x0b1d */ bool bAnimateWheelScrolling;
    /* 0x0b1e */ EDescendantScrollDestination NavigationDestination;
    /* 0x0b20 */ float NavigationScrollPadding;
    /* 0x0b24 */ EScrollWhenFocusChanges ScrollWhenFocusChanges;
    /* 0x0b25 */ bool bAllowRightClickDragScrolling;
    /* 0x0b28 */ float WheelScrollMultiplier;
    /* 0x0b30 */ FMulticastInlineDelegate OnUserScrolled;
    /* 0x0b40 */ FMulticastInlineDelegate OnScrollBarVisibilityChanged;
    /* 0x0b50 */ FMulticastInlineDelegate OnFocusReceived;
    /* 0x0b60 */ FMulticastInlineDelegate OnFocusLost;

    void EndInertialScrolling();
    FKey GetAnalogMouseWheelKey() const;
    bool GetConsumePointerInput() const;
    bool GetIsFocusable() const;
    bool GetIsScrolling() const;
    float GetOverscrollOffset() const;
    float GetOverscrollPercentage() const;
    float GetScrollOffset() const;
    float GetScrollOffsetOfEnd() const;
    float GetViewFraction() const;
    float GetViewOffsetFraction() const;
    void ScrollToEnd();
    void ScrollToStart();
    void ScrollWidgetIntoView(UWidget* WidgetToFind, bool AnimateScroll, EDescendantScrollDestination ScrollDestination, float Padding);
    void SetAllowOverscroll(bool NewAllowOverscroll);
    void SetAlwaysShowScrollbar(bool NewAlwaysShowScrollbar);
    void SetAnalogMouseWheelKey(FKey InMouseWheelKey);
    void SetAnimateWheelScrolling(bool bShouldAnimateWheelScrolling);
    void SetConsumeMouseWheel(EConsumeMouseWheel NewConsumeMouseWheel);
    void SetConsumePointerInput(bool bInConsumePointerInput);
    void SetIsFocusable(bool bInIsFocusable);
    void SetIsTouchScrollingEnabled(bool bInEnableTouchScrolling);
    void SetNavigationDestination(const EDescendantScrollDestination NewNavigationDestination);
    void SetOrientation(uint8_t NewOrientation);
    void SetScrollAnimationInterpolationSpeed(float NewScrollAnimationInterpolationSpeed);
    void SetScrollBarPadding(const FMargin& NewScrollbarPadding);
    void SetScrollOffset(float NewScrollOffset);
    void SetScrollWhenFocusChanges(EScrollWhenFocusChanges NewScrollWhenFocusChanges);
    void SetScrollbarThickness(const FVector2D& NewScrollbarThickness);
    void SetScrollbarVisibility(ESlateVisibility NewScrollBarVisibility);
    void SetWheelScrollMultiplier(float NewWheelScrollMultiplier);
};

// Size: 0x60
class UScrollBoxSlot : public UPanelSlot {
    /* 0x0038 */ FSlateChildSize Size;
    /* 0x0040 */ FMargin Padding;
    /* 0x0050 */ uint8_t HorizontalAlignment;
    /* 0x0051 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x2
struct FSequenceTickManagerWidgetData {
};

// Size: 0x3
struct FShapedTextOptions {
    /* 0x0000 */ bool bOverride_TextShapingMethod;
    /* 0x0000 */ bool bOverride_TextFlowDirection;
    /* 0x0001 */ ETextShapingMethod TextShapingMethod;
    /* 0x0002 */ ETextFlowDirection TextFlowDirection;
};

// Size: 0x1b8
class USizeBox : public UContentWidget {
    /* 0x0190 */ float WidthOverride;
    /* 0x0194 */ float HeightOverride;
    /* 0x0198 */ float MinDesiredWidth;
    /* 0x019c */ float MinDesiredHeight;
    /* 0x01a0 */ float MaxDesiredWidth;
    /* 0x01a4 */ float MaxDesiredHeight;
    /* 0x01a8 */ float MinAspectRatio;
    /* 0x01ac */ float MaxAspectRatio;
    /* 0x01b0 */ bool bOverride_WidthOverride;
    /* 0x01b0 */ bool bOverride_HeightOverride;
    /* 0x01b0 */ bool bOverride_MinDesiredWidth;
    /* 0x01b0 */ bool bOverride_MinDesiredHeight;
    /* 0x01b0 */ bool bOverride_MaxDesiredWidth;
    /* 0x01b0 */ bool bOverride_MaxDesiredHeight;
    /* 0x01b0 */ bool bOverride_MinAspectRatio;
    /* 0x01b0 */ bool bOverride_MaxAspectRatio;

    void ClearHeightOverride();
    void ClearMaxAspectRatio();
    void ClearMaxDesiredHeight();
    void ClearMaxDesiredWidth();
    void ClearMinAspectRatio();
    void ClearMinDesiredHeight();
    void ClearMinDesiredWidth();
    void ClearWidthOverride();
    void SetHeightOverride(float InHeightOverride);
    void SetMaxAspectRatio(float InMaxAspectRatio);
    void SetMaxDesiredHeight(float InMaxDesiredHeight);
    void SetMaxDesiredWidth(float InMaxDesiredWidth);
    void SetMinAspectRatio(float InMinAspectRatio);
    void SetMinDesiredHeight(float InMinDesiredHeight);
    void SetMinDesiredWidth(float InMinDesiredWidth);
    void SetWidthOverride(float InWidthOverride);
};

// Size: 0x60
class USizeBoxSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0058 */ uint8_t HorizontalAlignment;
    /* 0x0059 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x70
class USlateAccessibleWidgetData : public UObject {
    /* 0x0028 */ bool bCanChildrenBeAccessible;
    /* 0x0029 */ ESlateAccessibleBehavior AccessibleBehavior;
    /* 0x002a */ ESlateAccessibleBehavior AccessibleSummaryBehavior;
    /* 0x0030 */ FText AccessibleText;
    /* 0x0040 */ FDelegate AccessibleTextDelegate;
    /* 0x0050 */ FText AccessibleSummaryText;
    /* 0x0060 */ FDelegate AccessibleSummaryTextDelegate;

    FText GetText__DelegateSignature();
};

// Size: 0x28
class USlateBlueprintLibrary : public UBlueprintFunctionLibrary {

    static FVector2D AbsoluteToLocal(const FGeometry& Geometry, FVector2D AbsoluteCoordinate);
    static void AbsoluteToViewport(UObject* WorldContextObject, FVector2D AbsoluteDesktopCoordinate, FVector2D& PixelPosition, FVector2D& ViewportPosition);
    static bool EqualEqual_SlateBrush(const FSlateBrush& A, const FSlateBrush& B);
    static FVector2D GetAbsoluteSize(const FGeometry& Geometry);
    static FVector2D GetLocalSize(const FGeometry& Geometry);
    static FVector2D GetLocalTopLeft(const FGeometry& Geometry);
    static bool IsUnderLocation(const FGeometry& Geometry, const FVector2D& AbsoluteCoordinate);
    static FVector2D LocalToAbsolute(const FGeometry& Geometry, FVector2D LocalCoordinate);
    static void LocalToViewport(UObject* WorldContextObject, const FGeometry& Geometry, FVector2D LocalCoordinate, FVector2D& PixelPosition, FVector2D& ViewportPosition);
    static float Scalar_AbsoluteToLocal(const FGeometry& Geometry, float AbsoluteScalar);
    static float Scalar_LocalToAbsolute(const FGeometry& Geometry, float LocalScalar);
    static void ScreenToViewport(UObject* WorldContextObject, FVector2D screenPosition, FVector2D& ViewportPosition);
    static void ScreenToWidgetAbsolute(UObject* WorldContextObject, FVector2D screenPosition, FVector2D& AbsoluteCoordinate, bool bIncludeWindowPosition);
    static void ScreenToWidgetLocal(UObject* WorldContextObject, const FGeometry& Geometry, FVector2D screenPosition, FVector2D& LocalCoordinate, bool bIncludeWindowPosition);
    static float TransformScalarAbsoluteToLocal(const FGeometry& Geometry, float AbsoluteScalar);
    static float TransformScalarLocalToAbsolute(const FGeometry& Geometry, float LocalScalar);
    static FVector2D TransformVectorAbsoluteToLocal(const FGeometry& Geometry, FVector2D AbsoluteVector);
    static FVector2D TransformVectorLocalToAbsolute(const FGeometry& Geometry, FVector2D LocalVector);
    static FVector2D Vector_AbsoluteToLocal(const FGeometry& Geometry, FVector2D AbsoluteVector);
    static FVector2D Vector_LocalToAbsolute(const FGeometry& Geometry, FVector2D LocalVector);
};

// Size: 0x8
struct FSlateChildSize {
    /* 0x0000 */ float Value;
    /* 0x0004 */ uint8_t SizeRule;
};

// Size: 0x3c
struct FSlateMeshVertex {
    /* 0x0000 */ FVector2f position;
    /* 0x0008 */ FColor Color;
    /* 0x000c */ FVector2f UV0;
    /* 0x0014 */ FVector2f UV1;
    /* 0x001c */ FVector2f UV2;
    /* 0x0024 */ FVector2f UV3;
    /* 0x002c */ FVector2f UV4;
    /* 0x0034 */ FVector2f UV5;
};

// Size: 0x30
class USlatePostBufferProcessorUpdater : public UObject {
    /* 0x0028 */ bool bSkipBufferUpdate;
};

// Size: 0x10
struct FSlatePostBufferUpdateInfo {
    /* 0x0000 */ ESlatePostRT BufferToUpdate;
    /* 0x0008 */ USlatePostBufferProcessorUpdater* PostParamUpdater;
};

// Size: 0x70
class USlateVectorArtData : public UObject {
    /* 0x0028 */ TArray<FSlateMeshVertex> VertexData;
    /* 0x0038 */ TArray<uint32_t> IndexData;
    /* 0x0048 */ UMaterialInterface* Material;
    /* 0x0050 */ FVector2D ExtentMin;
    /* 0x0060 */ FVector2D ExtentMax;
};

// Size: 0x660
class USlider : public UWidget {
    /* 0x0168 */ float Value;
    /* 0x016c */ FDelegate ValueDelegate;
    /* 0x017c */ float MinValue;
    /* 0x0180 */ float MaxValue;
    /* 0x0190 */ FSliderStyle WidgetStyle;
    /* 0x05d0 */ uint8_t Orientation;
    /* 0x05d4 */ FLinearColor SliderBarColor;
    /* 0x05e4 */ FLinearColor SliderHandleColor;
    /* 0x05f4 */ bool IndentHandle;
    /* 0x05f5 */ bool Locked;
    /* 0x05f6 */ bool MouseUsesStep;
    /* 0x05f7 */ bool RequiresControllerLock;
    /* 0x05f8 */ float StepSize;
    /* 0x05fc */ bool IsFocusable;
    /* 0x05fd */ bool bPreventThrottling;
    /* 0x0600 */ FMulticastInlineDelegate OnMouseCaptureBegin;
    /* 0x0610 */ FMulticastInlineDelegate OnMouseCaptureEnd;
    /* 0x0620 */ FMulticastInlineDelegate OnControllerCaptureBegin;
    /* 0x0630 */ FMulticastInlineDelegate OnControllerCaptureEnd;
    /* 0x0640 */ FMulticastInlineDelegate OnValueChanged;

    float GetNormalizedValue() const;
    float GetValue() const;
    void SetIndentHandle(bool InValue);
    void SetLocked(bool InValue);
    void SetMaxValue(float InValue);
    void SetMinValue(float InValue);
    void SetSliderBarColor(FLinearColor InValue);
    void SetSliderHandleColor(FLinearColor InValue);
    void SetStepSize(float InValue);
    void SetValue(float InValue);
};

// Size: 0x188
class USpacer : public UWidget {
    /* 0x0168 */ FVector2D Size;

    void SetSize(FVector2D InSize);
};

// Size: 0x7a0
class USpinBox : public UWidget {
    /* 0x0168 */ float Value;
    /* 0x016c */ FDelegate ValueDelegate;
    /* 0x0180 */ FSpinBoxStyle WidgetStyle;
    /* 0x06a0 */ int32_t MinFractionalDigits;
    /* 0x06a4 */ int32_t MaxFractionalDigits;
    /* 0x06a8 */ bool bAlwaysUsesDeltaSnap;
    /* 0x06a9 */ bool bEnableSlider;
    /* 0x06ac */ float Delta;
    /* 0x06b0 */ float SliderExponent;
    /* 0x06b8 */ FSlateFontInfo Font;
    /* 0x0718 */ uint8_t Justification;
    /* 0x071c */ float MinDesiredWidth;
    /* 0x0720 */ uint8_t KeyboardType;
    /* 0x0721 */ bool ClearKeyboardFocusOnCommit;
    /* 0x0722 */ bool SelectAllTextOnCommit;
    /* 0x0724 */ FSlateColor ForegroundColor;
    /* 0x0738 */ FMulticastInlineDelegate OnValueChanged;
    /* 0x0748 */ FMulticastInlineDelegate OnValueCommitted;
    /* 0x0758 */ FMulticastInlineDelegate OnBeginSliderMovement;
    /* 0x0768 */ FMulticastInlineDelegate OnEndSliderMovement;
    /* 0x0778 */ bool bOverride_MinValue;
    /* 0x0778 */ bool bOverride_MaxValue;
    /* 0x0778 */ bool bOverride_MinSliderValue;
    /* 0x0778 */ bool bOverride_MaxSliderValue;
    /* 0x077c */ float MinValue;
    /* 0x0780 */ float MaxValue;
    /* 0x0784 */ float MinSliderValue;
    /* 0x0788 */ float MaxSliderValue;

    void ClearMaxSliderValue();
    void ClearMaxValue();
    void ClearMinSliderValue();
    void ClearMinValue();
    bool GetAlwaysUsesDeltaSnap() const;
    float GetDelta() const;
    int32_t GetMaxFractionalDigits() const;
    float GetMaxSliderValue() const;
    float GetMaxValue() const;
    int32_t GetMinFractionalDigits() const;
    float GetMinSliderValue() const;
    float GetMinValue() const;
    float GetValue() const;
    void OnSpinBoxBeginSliderMovement__DelegateSignature();
    void OnSpinBoxValueChangedEvent__DelegateSignature(float InValue);
    void OnSpinBoxValueCommittedEvent__DelegateSignature(float InValue, uint8_t CommitMethod);
    void SetAlwaysUsesDeltaSnap(bool bNewValue);
    void SetDelta(float NewValue);
    void SetForegroundColor(FSlateColor InForegroundColor);
    void SetMaxFractionalDigits(int32_t NewValue);
    void SetMaxSliderValue(float NewValue);
    void SetMaxValue(float NewValue);
    void SetMinFractionalDigits(int32_t NewValue);
    void SetMinSliderValue(float NewValue);
    void SetMinValue(float NewValue);
    void SetValue(float NewValue);
};

// Size: 0x198
class UStackBox : public UPanelWidget {
    /* 0x0180 */ uint8_t Orientation;

    UStackBoxSlot* AddChildToStackBox(UWidget* Content);
    bool ReplaceStackBoxChildAt(int32_t Index, UWidget* Content);
};

// Size: 0x60
class UStackBoxSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ FSlateChildSize Size;
    /* 0x0050 */ uint8_t HorizontalAlignment;
    /* 0x0051 */ uint8_t VerticalAlignment;
};

// Size: 0x78
class UTextBinding : public UPropertyBinding {

    FString GetStringValue() const;
    FText GetTextValue() const;
};

// Size: 0x330
class UTextBlock : public UTextLayoutWidget {
    /* 0x0188 */ FText Text;
    /* 0x0198 */ FDelegate TextDelegate;
    /* 0x01a8 */ FSlateColor ColorAndOpacity;
    /* 0x01bc */ FDelegate ColorAndOpacityDelegate;
    /* 0x01cc */ float MinDesiredWidth;
    /* 0x01d0 */ FSlateFontInfo Font;
    /* 0x0230 */ FSlateBrush StrikeBrush;
    /* 0x02e0 */ FVector2D ShadowOffset;
    /* 0x02f0 */ FLinearColor ShadowColorAndOpacity;
    /* 0x0300 */ FDelegate ShadowColorAndOpacityDelegate;
    /* 0x0310 */ bool bWrapWithInvalidationPanel;
    /* 0x0311 */ ETextTransformPolicy TextTransformPolicy;
    /* 0x0312 */ ETextOverflowPolicy TextOverflowPolicy;
    /* 0x0313 */ bool bSimpleTextMode;

    UMaterialInstanceDynamic* GetDynamicFontMaterial();
    UMaterialInstanceDynamic* GetDynamicOutlineMaterial();
    FText GetText() const;
    void SetAutoWrapText(bool InAutoTextWrap);
    void SetColorAndOpacity(FSlateColor InColorAndOpacity);
    void SetFont(FSlateFontInfo InFontInfo);
    void SetFontMaterial(UMaterialInterface* InMaterial);
    void SetFontOutlineMaterial(UMaterialInterface* InMaterial);
    void SetMinDesiredWidth(float InMinDesiredWidth);
    void SetOpacity(float InOpacity);
    void SetShadowColorAndOpacity(FLinearColor InShadowColorAndOpacity);
    void SetShadowOffset(FVector2D InShadowOffset);
    void SetStrikeBrush(FSlateBrush InStrikeBrush);
    void SetText(FText InText);
    void SetTextOverflowPolicy(ETextOverflowPolicy InOverflowPolicy);
    void SetTextTransformPolicy(ETextTransformPolicy InTransformPolicy);
};

// Size: 0x188
class UTextLayoutWidget : public UWidget {
    /* 0x0168 */ FShapedTextOptions ShapedTextOptions;
    /* 0x016b */ uint8_t Justification;
    /* 0x016c */ ETextWrappingPolicy WrappingPolicy;
    /* 0x016d */ bool AutoWrapText;
    /* 0x016e */ bool ApplyLineHeightToBottomLine;
    /* 0x0170 */ float WrapTextAt;
    /* 0x0174 */ FMargin Margin;
    /* 0x0184 */ float LineHeightPercentage;

    void SetJustification(uint8_t InJustification);
};

// Size: 0x230
class UThrobber : public UWidget {
    /* 0x0168 */ int32_t NumberOfPieces;
    /* 0x016c */ bool bAnimateHorizontally;
    /* 0x016d */ bool bAnimateVertically;
    /* 0x016e */ bool bAnimateOpacity;
    /* 0x0170 */ FSlateBrush Image;

    void SetAnimateHorizontally(bool bInAnimateHorizontally);
    void SetAnimateOpacity(bool bInAnimateOpacity);
    void SetAnimateVertically(bool bInAnimateVertically);
    void SetNumberOfPieces(int32_t InNumberOfPieces);
};

// Size: 0xba0
class UTileView : public UListView {
    /* 0x0b70 */ float EntryHeight;
    /* 0x0b74 */ float EntryWidth;
    /* 0x0b78 */ EListItemAlignment TileAlignment;
    /* 0x0b79 */ bool bWrapHorizontalNavigation;
    /* 0x0b7a */ ESlateVisibility ScrollbarDisabledVisibility;
    /* 0x0b90 */ bool bEntrySizeIncludesEntrySpacing;

    float GetEntryHeight() const;
    float GetEntryWidth() const;
    bool IsAligned() const;
    void SetEntryHeight(float NewHeight);
    void SetEntryWidth(float NewWidth);
};

// Size: 0xbd0
class UTreeView : public UListView {
    /* 0x0b80 */ FDelegate BP_OnGetItemChildren;
    /* 0x0b90 */ FMulticastInlineDelegate BP_OnItemExpansionChanged;

    void CollapseAll();
    void ExpandAll();
    void SetItemExpansion(UObject* Item, bool bExpandItem);
};

// Size: 0x50
class UUIComponent : public UObject {
    /* 0x0030 */ TWeakObjectPtr<UWidget> Owner;
};

// Size: 0x38
class UUIComponentContainer : public UObject {
    /* 0x0028 */ TArray<FUIComponentTarget> Components;
};

// Size: 0x10
struct FUIComponentTarget {
    /* 0x0000 */ FName TargetName;
    /* 0x0008 */ UUIComponent* Component;
};

// Size: 0x30
class UUIComponentUserWidgetExtension : public UUserWidgetExtension {
    /* 0x0028 */ UUIComponentContainer* ComponentContainer;
};

// Size: 0x30
class UUIComponentWidgetBlueprintGeneratedClassExtension : public UWidgetBlueprintGeneratedClassExtension {
    /* 0x0028 */ UUIComponentContainer* ComponentContainer;
};

// Size: 0x260
class UUMGSequencePlayer : public UObject {

    FName GetUserTag() const;
    void SetUserTag(FName InUserTag);
};

// Size: 0xc0
class UUMGSequenceTickManager : public UObject {
    /* 0x0028 */ TMap<TWeakObjectPtr<UUserWidget>, FSequenceTickManagerWidgetData> WeakUserWidgetData;
    /* 0x0078 */ UMovieSceneEntitySystemLinker* Linker;
};

// Size: 0x1a8
class UUniformGridPanel : public UPanelWidget {
    /* 0x0180 */ FMargin SlotPadding;
    /* 0x0190 */ float MinDesiredSlotWidth;
    /* 0x0194 */ float MinDesiredSlotHeight;

    UUniformGridSlot* AddChildToUniformGrid(UWidget* Content, int32_t InRow, int32_t InColumn);
    void SetMinDesiredSlotHeight(float InMinDesiredSlotHeight);
    void SetMinDesiredSlotWidth(float InMinDesiredSlotWidth);
    void SetSlotPadding(FMargin InSlotPadding);
};

// Size: 0x50
class UUniformGridSlot : public UPanelSlot {
    /* 0x0038 */ uint8_t HorizontalAlignment;
    /* 0x0039 */ uint8_t VerticalAlignment;
    /* 0x003c */ int32_t Row;
    /* 0x0040 */ int32_t Column;

    void SetColumn(int32_t InColumn);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetRow(int32_t InRow);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x28
class IUserListEntry : public UInterface {

    void BP_OnEntryReleased();
    void BP_OnItemExpansionChanged(bool bIsExpanded);
    void BP_OnItemSelectionChanged(bool bIsSelected);
};

// Size: 0x28
class UUserListEntryLibrary : public UBlueprintFunctionLibrary {

    static UListViewBase* GetOwningListView(TScriptInterface<IUserListEntry> UserListEntry);
    static bool IsListItemExpanded(TScriptInterface<IUserListEntry> UserListEntry);
    static bool IsListItemSelected(TScriptInterface<IUserListEntry> UserListEntry);
};

// Size: 0x28
class UUserObjectListEntry : public IUserListEntry {

    void OnListItemObjectSet(UObject* ListItemObject);
};

// Size: 0x28
class UUserObjectListEntryLibrary : public UBlueprintFunctionLibrary {

    static UObject* GetListItemObject(TScriptInterface<UUserObjectListEntry> UserObjectListEntry);
};

// Size: 0x340
class UUserWidget : public UWidget {
    /* 0x01a0 */ FLinearColor ColorAndOpacity;
    /* 0x01b0 */ FDelegate ColorAndOpacityDelegate;
    /* 0x01c0 */ FSlateColor ForegroundColor;
    /* 0x01d4 */ FDelegate ForegroundColorDelegate;
    /* 0x01e8 */ FMulticastInlineDelegate OnVisibilityChanged;
    /* 0x0228 */ FMargin Padding;
    /* 0x0238 */ int32_t Priority;
    /* 0x023c */ bool bIsFocusable;
    /* 0x023c */ bool bStopAction;
    /* 0x023c */ bool bAutomaticallyRegisterInputOnConstruction;
    /* 0x0240 */ TArray<FQueuedWidgetAnimationTransition> QueuedWidgetAnimationTransitions;
    /* 0x0250 */ TArray<UUMGSequencePlayer*> ActiveSequencePlayers;
    /* 0x0260 */ UUMGSequenceTickManager* AnimationTickManager;
    /* 0x0268 */ TArray<UUMGSequencePlayer*> StoppedSequencePlayers;
    /* 0x02b8 */ TArray<FNamedSlotBinding> NamedSlotBindings;
    /* 0x02c8 */ TArray<UUserWidgetExtension*> Extensions;
    /* 0x02d8 */ UWidgetTree* WidgetTree;
    /* 0x02e0 */ bool bHasScriptImplementedTick;
    /* 0x02e0 */ bool bHasScriptImplementedPaint;
    /* 0x02f8 */ EWidgetTickFrequency TickFrequency;
    /* 0x02fc */ FWidgetChild DesiredFocusWidget;
    /* 0x0310 */ UInputComponent* InputComponent;
    /* 0x0318 */ TArray<FAnimationEventBinding> AnimationCallbacks;

    UUserWidgetExtension* AddExtension(UClass* InExtensionType);
    bool AddToPlayerScreen(int32_t ZOrder);
    void AddToViewport(int32_t ZOrder);
    void BindToAnimationEvent(UWidgetAnimation* Animation, FDelegate Delegate, EWidgetAnimationEvent AnimationEvent, FName UserTag);
    void BindToAnimationFinished(UWidgetAnimation* Animation, FDelegate Delegate);
    void BindToAnimationStarted(UWidgetAnimation* Animation, FDelegate Delegate);
    void CancelLatentActions();
    void Construct();
    void Destruct();
    void FlushAnimations();
    FVector2D GetAlignmentInViewport() const;
    FAnchors GetAnchorsInViewport() const;
    float GetAnimationCurrentTime(const UWidgetAnimation* InAnimation) const;
    UUserWidgetExtension* GetExtension(UClass* ExtensionType) const;
    TArray<UUserWidgetExtension*> GetExtensions(UClass* ExtensionType) const;
    bool GetIsVisible() const;
    APlayerCameraManager* GetOwningPlayerCameraManager() const;
    APawn* GetOwningPlayerPawn() const;
    bool IsAnimationPlaying(const UWidgetAnimation* InAnimation) const;
    bool IsAnimationPlayingForward(const UWidgetAnimation* InAnimation);
    bool IsAnyAnimationPlaying() const;
    bool IsInteractable() const;
    bool IsListeningForInputAction(FName ActionName) const;
    bool IsPlayingAnimation() const;
    void ListenForInputAction(FName ActionName, uint8_t EventType, bool bConsume, FDelegate Callback);
    void OnAddedToFocusPath(FFocusEvent InFocusEvent);
    FEventReply OnAnalogValueChanged(FGeometry MyGeometry, FAnalogInputEvent InAnalogInputEvent);
    void OnAnimationFinished(const UWidgetAnimation* Animation);
    void OnAnimationStarted(const UWidgetAnimation* Animation);
    void OnDragCancelled(const FPointerEvent& PointerEvent, UDragDropOperation* Operation);
    void OnDragDetected(FGeometry MyGeometry, const FPointerEvent& PointerEvent, UDragDropOperation*& Operation);
    void OnDragEnter(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
    void OnDragLeave(FPointerEvent PointerEvent, UDragDropOperation* Operation);
    bool OnDragOver(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
    bool OnDrop(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
    void OnFocusLost(FFocusEvent InFocusEvent);
    FEventReply OnFocusReceived(FGeometry MyGeometry, FFocusEvent InFocusEvent);
    void OnInitialized();
    FEventReply OnKeyChar(FGeometry MyGeometry, FCharacterEvent InCharacterEvent);
    FEventReply OnKeyDown(FGeometry MyGeometry, FKeyEvent InKeyEvent);
    FEventReply OnKeyUp(FGeometry MyGeometry, FKeyEvent InKeyEvent);
    FEventReply OnMotionDetected(FGeometry MyGeometry, FMotionEvent InMotionEvent);
    FEventReply OnMouseButtonDoubleClick(FGeometry InMyGeometry, const FPointerEvent& InMouseEvent);
    FEventReply OnMouseButtonDown(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    FEventReply OnMouseButtonUp(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    void OnMouseCaptureLost();
    void OnMouseEnter(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    void OnMouseLeave(const FPointerEvent& MouseEvent);
    FEventReply OnMouseMove(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    FEventReply OnMouseWheel(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    void OnPaint(FPaintContext& Context) const;
    FEventReply OnPreviewKeyDown(FGeometry MyGeometry, FKeyEvent InKeyEvent);
    FEventReply OnPreviewMouseButtonDown(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    void OnRemovedFromFocusPath(FFocusEvent InFocusEvent);
    FEventReply OnTouchEnded(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    FEventReply OnTouchFirstMove(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    FEventReply OnTouchForceChanged(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    FEventReply OnTouchGesture(FGeometry MyGeometry, const FPointerEvent& GestureEvent);
    FEventReply OnTouchMoved(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    FEventReply OnTouchStarted(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    float PauseAnimation(const UWidgetAnimation* InAnimation);
    FWidgetAnimationHandle PlayAnimation(UWidgetAnimation* InAnimation, float StartAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed, bool bRestoreState);
    FWidgetAnimationHandle PlayAnimationForward(UWidgetAnimation* InAnimation, float PlaybackSpeed, bool bRestoreState);
    FWidgetAnimationHandle PlayAnimationReverse(UWidgetAnimation* InAnimation, float PlaybackSpeed, bool bRestoreState);
    FWidgetAnimationHandle PlayAnimationTimeRange(UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed, bool bRestoreState);
    void PlaySound(USoundBase* SoundToPlay);
    void PreConstruct(bool IsDesignTime);
    float QueuePauseAnimation(const UWidgetAnimation* InAnimation);
    void QueuePlayAnimation(UWidgetAnimation* InAnimation, float StartAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed, bool bRestoreState);
    void QueuePlayAnimationForward(UWidgetAnimation* InAnimation, float PlaybackSpeed, bool bRestoreState);
    void QueuePlayAnimationReverse(UWidgetAnimation* InAnimation, float PlaybackSpeed, bool bRestoreState);
    void QueuePlayAnimationTimeRange(UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed, bool bRestoreState);
    void QueueStopAllAnimations();
    void QueueStopAnimation(const UWidgetAnimation* InAnimation);
    void RegisterInputComponent();
    void RemoveExtension(UUserWidgetExtension* InExtension);
    void RemoveExtensions(UClass* InExtensionType);
    void RemoveFromViewport();
    void ReverseAnimation(const UWidgetAnimation* InAnimation);
    void SetAlignmentInViewport(FVector2D Alignment);
    void SetAnchorsInViewport(FAnchors Anchors);
    void SetAnimationCurrentTime(const UWidgetAnimation* InAnimation, float InTime);
    void SetColorAndOpacity(FLinearColor InColorAndOpacity);
    bool SetDesiredFocusWidget(UWidget* Widget);
    void SetDesiredSizeInViewport(FVector2D Size);
    void SetForegroundColor(FSlateColor InForegroundColor);
    void SetInputActionBlocking(bool bShouldBlock);
    void SetInputActionPriority(int32_t NewPriority);
    void SetNumLoopsToPlay(const UWidgetAnimation* InAnimation, int32_t NumLoopsToPlay);
    void SetOwningPlayer(APlayerController* LocalPlayerController);
    void SetPadding(FMargin InPadding);
    void SetPlaybackSpeed(const UWidgetAnimation* InAnimation, float PlaybackSpeed);
    void SetPositionInViewport(FVector2D position, bool bRemoveDPIScale);
    void StopAllAnimations();
    void StopAnimation(const UWidgetAnimation* InAnimation);
    void StopAnimationsAndLatentActions();
    void StopListeningForAllInputActions();
    void StopListeningForInputAction(FName ActionName, uint8_t EventType);
    void Tick(FGeometry MyGeometry, float InDeltaTime);
    void UnbindAllFromAnimationFinished(UWidgetAnimation* Animation);
    void UnbindAllFromAnimationStarted(UWidgetAnimation* Animation);
    void UnbindFromAnimationFinished(UWidgetAnimation* Animation, FDelegate Delegate);
    void UnbindFromAnimationStarted(UWidgetAnimation* Animation, FDelegate Delegate);
    void UnregisterInputComponent();
};

// Size: 0xa8
class UUserWidgetBlueprint : public UBlueprint {
};

// Size: 0x28
class UUserWidgetExtension : public UObject {
};

// Size: 0x28
class UUserWidgetFunctionLibrary : public UBlueprintFunctionLibrary {

    static UUMGSequencePlayer* Conv_UMGSequencePlayer(const FWidgetAnimationHandle& WidgetAnimationHandle);
};

// Size: 0x88
struct FUserWidgetPool {
    /* 0x0000 */ TArray<UUserWidget*> ActiveWidgets;
    /* 0x0010 */ TArray<UUserWidget*> InactiveWidgets;
};

// Size: 0x190
class UVerticalBox : public UPanelWidget {

    UVerticalBoxSlot* AddChildToVerticalBox(UWidget* Content);
};

// Size: 0x60
class UVerticalBoxSlot : public UPanelSlot {
    /* 0x0038 */ FSlateChildSize Size;
    /* 0x0040 */ FMargin Padding;
    /* 0x0050 */ uint8_t HorizontalAlignment;
    /* 0x0051 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetSize(FSlateChildSize InSize);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x1e0
class UViewport : public UContentWidget {
    /* 0x0180 */ FLinearColor BackgroundColor;

    FVector GetViewLocation() const;
    FMatrix GetViewProjectionMatrix() const;
    FRotator GetViewRotation() const;
    UWorld* GetViewportWorld() const;
    void SetEnableAdvancedFeatures(bool InEnableAdvancedFeatures);
    void SetLightIntensity(float LightIntensity);
    void SetShowFlag(FString InShowFlagName, bool InValue);
    void SetSkyIntensity(float LightIntensity);
    void SetViewLocation(FVector Location);
    void SetViewRotation(FRotator Rotation);
    AActor* Spawn(UClass* ActorClass);
};

// Size: 0x70
class UVisibilityBinding : public UPropertyBinding {

    ESlateVisibility GetValue() const;
};

// Size: 0x28
class UVisual : public UObject {
};

// Size: 0x168
class UWidget : public UVisual {
    /* 0x0030 */ UPanelSlot* Slot;
    /* 0x0038 */ FDelegate bIsEnabledDelegate;
    /* 0x0048 */ FDelegate ToolTipTextDelegate;
    /* 0x0058 */ FText ToolTipText;
    /* 0x0068 */ UWidget* ToolTipWidget;
    /* 0x0070 */ FDelegate ToolTipWidgetDelegate;
    /* 0x0080 */ FDelegate VisibilityDelegate;
    /* 0x0090 */ FWidgetTransform RenderTransform;
    /* 0x00c8 */ FVector2D RenderTransformPivot;
    /* 0x00d8 */ EFlowDirectionPreference FlowDirectionPreference;
    /* 0x00d9 */ bool bIsVariable;
    /* 0x00d9 */ bool bCreatedByConstructionScript;
    /* 0x00d9 */ bool bIsEnabled;
    /* 0x00d9 */ bool bOverride_Cursor;
    /* 0x00d9 */ bool bIsVolatile;
    /* 0x00da */ uint8_t Cursor;
    /* 0x00db */ EWidgetClipping Clipping;
    /* 0x00dc */ ESlateVisibility Visibility;
    /* 0x00dd */ EWidgetPixelSnapping PixelSnapping;
    /* 0x00e0 */ float RenderOpacity;
    /* 0x00e8 */ USlateAccessibleWidgetData* AccessibleWidgetData;
    /* 0x00f0 */ UWidgetNavigation* Navigation;
    /* 0x0138 */ TArray<UPropertyBinding*> NativeBindings;

    void ForceLayoutPrepass();
    void ForceVolatile(bool bForce);
    UWidget* GenerateWidgetForObject__DelegateSignature(UObject* Item);
    UWidget* GenerateWidgetForString__DelegateSignature(FString Item);
    FText GetAccessibleSummaryText() const;
    FText GetAccessibleText() const;
    bool GetBool__DelegateSignature();
    FGeometry GetCachedGeometry() const;
    ECheckBoxState GetCheckBoxState__DelegateSignature();
    EWidgetClipping GetClipping() const;
    FVector2D GetDesiredSize() const;
    float GetFloat__DelegateSignature();
    UGameInstance* GetGameInstance() const;
    int32_t GetInt32__DelegateSignature();
    bool GetIsEnabled() const;
    FLinearColor GetLinearColor__DelegateSignature();
    uint8_t GetMouseCursor__DelegateSignature();
    ULocalPlayer* GetOwningLocalPlayer() const;
    APlayerController* GetOwningPlayer() const;
    FGeometry GetPaintSpaceGeometry() const;
    UPanelWidget* GetParent() const;
    float GetRenderOpacity() const;
    float GetRenderTransformAngle() const;
    FSlateBrush GetSlateBrush__DelegateSignature();
    FSlateColor GetSlateColor__DelegateSignature();
    ESlateVisibility GetSlateVisibility__DelegateSignature();
    FText GetText__DelegateSignature();
    FGeometry GetTickSpaceGeometry() const;
    ESlateVisibility GetVisibility() const;
    UWidget* GetWidget__DelegateSignature();
    bool HasAnyUserFocus() const;
    bool HasFocusedDescendants() const;
    bool HasKeyboardFocus() const;
    bool HasMouseCapture() const;
    bool HasMouseCaptureByUser(int32_t UserIndex, int32_t PointerIndex) const;
    bool HasUserFocus(APlayerController* PlayerController) const;
    bool HasUserFocusedDescendants(APlayerController* PlayerController) const;
    void InvalidateLayoutAndVolatility();
    bool IsHovered() const;
    bool IsInViewport() const;
    bool IsRendered() const;
    bool IsVisible() const;
    void K2_AddFieldValueChangedDelegate(FFieldNotificationId FieldId, FDelegate Delegate);
    void K2_BroadcastFieldValueChanged(FFieldNotificationId FieldId);
    void K2_RemoveFieldValueChangedDelegate(FFieldNotificationId FieldId, FDelegate Delegate);
    FEventReply OnPointerEvent__DelegateSignature(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
    FEventReply OnReply__DelegateSignature();
    void RemoveFromParent();
    void ResetCursor();
    void SetAllNavigationRules(EUINavigationRule Rule, FName WidgetToFocus);
    void SetClipping(EWidgetClipping InClipping);
    void SetCursor(uint8_t InCursor);
    void SetFocus();
    void SetIsEnabled(bool bInIsEnabled);
    void SetKeyboardFocus();
    void SetNavigationRule(EUINavigation Direction, EUINavigationRule Rule, FName WidgetToFocus);
    void SetNavigationRuleBase(EUINavigation Direction, EUINavigationRule Rule);
    void SetNavigationRuleCustom(EUINavigation Direction, FDelegate InCustomDelegate);
    void SetNavigationRuleCustomBoundary(EUINavigation Direction, FDelegate InCustomDelegate);
    void SetNavigationRuleExplicit(EUINavigation Direction, UWidget* InWidget);
    void SetRenderOpacity(float InOpacity);
    void SetRenderScale(FVector2D Scale);
    void SetRenderShear(FVector2D Shear);
    void SetRenderTransform(FWidgetTransform InTransform);
    void SetRenderTransformAngle(float Angle);
    void SetRenderTransformPivot(FVector2D Pivot);
    void SetRenderTranslation(FVector2D Translation);
    void SetToolTip(UWidget* Widget);
    void SetToolTipText(const FText& InToolTipText);
    void SetUserFocus(APlayerController* PlayerController);
    void SetVisibility(ESlateVisibility InVisibility);
};

// Size: 0x98
class UWidgetAnimation : public UMovieSceneSequence {
    /* 0x0068 */ UMovieScene* MovieScene;
    /* 0x0070 */ TArray<FWidgetAnimationBinding> AnimationBindings;
    /* 0x0080 */ bool bLegacyFinishOnStop;
    /* 0x0088 */ FString DisplayLabel;

    void BindToAnimationFinished(UUserWidget* Widget, FDelegate Delegate);
    void BindToAnimationStarted(UUserWidget* Widget, FDelegate Delegate);
    float GetEndTime() const;
    float GetStartTime() const;
    void UnbindAllFromAnimationFinished(UUserWidget* Widget);
    void UnbindAllFromAnimationStarted(UUserWidget* Widget);
    void UnbindFromAnimationFinished(UUserWidget* Widget, FDelegate Delegate);
    void UnbindFromAnimationStarted(UUserWidget* Widget, FDelegate Delegate);
};

// Size: 0x50
struct FWidgetAnimationBinding {
    /* 0x0000 */ FName WidgetName;
    /* 0x0008 */ FName SlotWidgetName;
    /* 0x0010 */ FGuid AnimationGuid;
    /* 0x0020 */ bool bIsRootWidget;
    /* 0x0028 */ FMovieSceneDynamicBinding DynamicBinding;
};

// Size: 0x38
class UWidgetAnimationDelegateBinding : public UDynamicBlueprintBinding {
    /* 0x0028 */ TArray<FBlueprintWidgetAnimationDelegateBinding> WidgetAnimationDelegateBindings;
};

// Size: 0x10
struct FWidgetAnimationHandle {
    /* 0x0000 */ TWeakObjectPtr<UUserWidget> WeakUserWidget;
    /* 0x0008 */ int32_t StateIndex;
    /* 0x000c */ uint32_t StateSerial;
};

// Size: 0x28
class UWidgetAnimationHandleFunctionLibrary : public UBlueprintFunctionLibrary {

    static FName GetUserTag(const FWidgetAnimationHandle& Target);
    static void SetUserTag(FWidgetAnimationHandle& Target, FName InUserTag);
};

// Size: 0x50
class UWidgetAnimationPlayCallbackProxy : public UObject {
    /* 0x0028 */ FMulticastInlineDelegate Finished;

    static UWidgetAnimationPlayCallbackProxy* CreatePlayAnimationProxyObject(UUMGSequencePlayer*& Result, UUserWidget* Widget, UWidgetAnimation* InAnimation, float StartAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed);
    static UWidgetAnimationPlayCallbackProxy* CreatePlayAnimationTimeRangeProxyObject(UUMGSequencePlayer*& Result, UUserWidget* Widget, UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed);
    static UWidgetAnimationPlayCallbackProxy* NewPlayAnimationProxyObject(FWidgetAnimationHandle& Result, UUserWidget* Widget, UWidgetAnimation* InAnimation, float StartAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed);
    static UWidgetAnimationPlayCallbackProxy* NewPlayAnimationTimeRangeProxyObject(FWidgetAnimationHandle& Result, UUserWidget* Widget, UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int32_t NumLoopsToPlay, uint8_t PlayMode, float PlaybackSpeed);
};

// Size: 0x28
class UWidgetBinaryStateRegistration : public UObject {
};

// Size: 0x70
class UWidgetBinding : public UPropertyBinding {

    UWidget* GetValue() const;
};

// Size: 0x3d0
class UWidgetBlueprintGeneratedClass : public UBlueprintGeneratedClass {
    /* 0x0360 */ UWidgetTree* WidgetTree;
    /* 0x0368 */ TArray<UWidgetBlueprintGeneratedClassExtension*> Extensions;
    /* 0x0378 */ bool bClassRequiresNativeTick;
    /* 0x0378 */ bool bCanCallInitializedWithoutPlayerContext;
    /* 0x0380 */ TArray<FDelegateRuntimeBinding> Bindings;
    /* 0x0390 */ TArray<UWidgetAnimation*> Animations;
    /* 0x03a0 */ TArray<FName> NamedSlots;
    /* 0x03b0 */ TArray<FName> AvailableNamedSlots;
    /* 0x03c0 */ TArray<FName> InstanceNamedSlots;
};

// Size: 0x28
class UWidgetBlueprintGeneratedClassExtension : public UObject {
};

// Size: 0x28
class UWidgetBlueprintLibrary : public UBlueprintFunctionLibrary {

    static void CancelDragDrop();
    static FEventReply CaptureJoystick(FEventReply& Reply, UWidget* CapturingWidget, bool bInAllJoysticks);
    static FEventReply CaptureMouse(FEventReply& Reply, UWidget* CapturingWidget);
    static FEventReply ClearUserFocus(FEventReply& Reply, bool bInAllUsers);
    static UUserWidget* Create(UObject* WorldContextObject, UClass* WidgetType, APlayerController* OwningPlayer);
    static UDragDropOperation* CreateDragDropOperation(UClass* OperationClass);
    static FEventReply DetectDrag(FEventReply& Reply, UWidget* WidgetDetectingDrag, FKey DragKey);
    static FEventReply DetectDragIfPressed(const FPointerEvent& PointerEvent, UWidget* WidgetDetectingDrag, FKey DragKey);
    static void DismissAllMenus();
    static void DrawBox(FPaintContext& Context, FVector2D position, FVector2D Size, USlateBrushAsset* Brush, FLinearColor Tint);
    static void DrawLine(FPaintContext& Context, FVector2D PositionA, FVector2D PositionB, FLinearColor Tint, bool bAntiAlias, float Thickness);
    static void DrawLines(FPaintContext& Context, const TArray<FVector2D>& points, FLinearColor Tint, bool bAntiAlias, float Thickness);
    static void DrawSpline(FPaintContext& Context, FVector2D Start, FVector2D StartDir, FVector2D End, FVector2D EndDir, FLinearColor Tint, float Thickness);
    static void DrawText(FPaintContext& Context, FString InString, FVector2D position, FLinearColor Tint);
    static void DrawTextFormatted(FPaintContext& Context, const FText& Text, FVector2D position, UFont* Font, float FontSize, FName FontTypeFace, FLinearColor Tint);
    static FEventReply EndDragDrop(FEventReply& Reply);
    static void GetAllWidgetsOfClass(UObject* WorldContextObject, TArray<UUserWidget*>& FoundWidgets, UClass* WidgetClass, bool TopLevelOnly);
    static void GetAllWidgetsWithInterface(UObject* WorldContextObject, TArray<UUserWidget*>& FoundWidgets, UClass* Interface, bool TopLevelOnly);
    static UObject* GetBrushResource(const FSlateBrush& Brush);
    static UMaterialInterface* GetBrushResourceAsMaterial(const FSlateBrush& Brush);
    static UTexture2D* GetBrushResourceAsTexture2D(const FSlateBrush& Brush);
    static UDragDropOperation* GetDragDroppingContent();
    static UMaterialInstanceDynamic* GetDynamicMaterial(FSlateBrush& Brush);
    static FInputEvent GetInputEventFromCharacterEvent(const FCharacterEvent& Event);
    static FInputEvent GetInputEventFromKeyEvent(const FKeyEvent& Event);
    static FInputEvent GetInputEventFromNavigationEvent(const FNavigationEvent& Event);
    static FInputEvent GetInputEventFromPointerEvent(const FPointerEvent& Event);
    static FKeyEvent GetKeyEventFromAnalogInputEvent(const FAnalogInputEvent& Event);
    static void GetSafeZonePadding(UObject* WorldContextObject, FVector4& SafePadding, FVector2D& SafePaddingScale, FVector4& SpillOverPadding);
    static FEventReply Handled();
    static bool IsDragDropping();
    static FEventReply LockMouse(FEventReply& Reply, UWidget* CapturingWidget);
    static FSlateBrush MakeBrushFromAsset(USlateBrushAsset* BrushAsset);
    static FSlateBrush MakeBrushFromMaterial(UMaterialInterface* Material, int32_t Width, int32_t Height);
    static FSlateBrush MakeBrushFromTexture(UTexture2D* Texture, int32_t Width, int32_t Height);
    static FSlateBrush NoResourceBrush();
    void OnGameWindowCloseButtonClickedDelegate__DelegateSignature();
    static FEventReply ReleaseJoystickCapture(FEventReply& Reply, bool bInAllJoysticks);
    static FEventReply ReleaseMouseCapture(FEventReply& Reply);
    static void RestorePreviousWindowTitleBarState();
    static void SetBrushResourceToMaterial(FSlateBrush& Brush, UMaterialInterface* Material);
    static void SetBrushResourceToTexture(FSlateBrush& Brush, UTexture2D* Texture);
    static void SetColorVisionDeficiencyType(EColorVisionDeficiency Type, float Severity, bool CorrectDeficiency, bool ShowCorrectionWithDeficiency);
    static void SetFocusToGameViewport();
    static bool SetHardwareCursor(UObject* WorldContextObject, uint8_t CursorShape, FName CursorName, FVector2D HotSpot);
    static void SetInputMode_GameAndUIEx(APlayerController* PlayerController, UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode, bool bHideCursorDuringCapture, const bool bFlushInput);
    static void SetInputMode_GameOnly(APlayerController* PlayerController, const bool bFlushInput);
    static void SetInputMode_UIOnlyEx(APlayerController* PlayerController, UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode, const bool bFlushInput);
    static FEventReply SetMousePosition(FEventReply& Reply, FVector2D NewMousePosition);
    static FEventReply SetUserFocus(FEventReply& Reply, UWidget* FocusWidget, bool bInAllUsers);
    static void SetWindowTitleBarCloseButtonActive(bool bActive);
    static void SetWindowTitleBarOnCloseClickedDelegate(FDelegate Delegate);
    static void SetWindowTitleBarState(UWidget* TitleBarContent, EWindowTitleBarMode Mode, bool bTitleBarDragEnabled, bool bWindowButtonsVisible, bool bTitleBarVisible);
    static FEventReply Unhandled();
    static FEventReply UnlockMouse(FEventReply& Reply);
};

// Size: 0x28
class UWidgetCheckedStateRegistration : public UWidgetEnumStateRegistration {
};

// Size: 0x10
struct FWidgetChild {
    /* 0x0000 */ FName WidgetName;
    /* 0x0008 */ TWeakObjectPtr<UWidget> WidgetPtr;
};

// Size: 0x6d0
class UWidgetComponent : public UMeshComponent {
    /* 0x0580 */ EWidgetSpace Space;
    /* 0x0581 */ EWidgetTimingPolicy TimingPolicy;
    /* 0x0588 */ UClass* WidgetClass;
    /* 0x0590 */ FIntPoint DrawSize;
    /* 0x0598 */ bool bManuallyRedraw;
    /* 0x0599 */ bool bRedrawRequested;
    /* 0x059c */ float RedrawTime;
    /* 0x05a8 */ FIntPoint CurrentDrawSize;
    /* 0x05b0 */ bool bUseInvalidationInWorldSpace;
    /* 0x05b1 */ bool bDrawAtDesiredSize;
    /* 0x05b8 */ FVector2D Pivot;
    /* 0x05c8 */ bool bReceiveHardwareInput;
    /* 0x05c9 */ bool bWindowFocusable;
    /* 0x05ca */ EWindowVisibility WindowVisibility;
    /* 0x05cb */ bool bApplyGammaCorrection;
    /* 0x05d0 */ ULocalPlayer* OwnerPlayer;
    /* 0x05d8 */ FLinearColor BackgroundColor;
    /* 0x05e8 */ FLinearColor TintColorAndOpacity;
    /* 0x05f8 */ float OpacityFromTexture;
    /* 0x05fc */ EWidgetBlendMode BlendMode;
    /* 0x05fd */ bool bIsTwoSided;
    /* 0x05fe */ bool TickWhenOffscreen;
    /* 0x0600 */ UBodySetup* BodySetup;
    /* 0x0608 */ UMaterialInterface* TranslucentMaterial;
    /* 0x0610 */ UMaterialInterface* TranslucentMaterial_OneSided;
    /* 0x0618 */ UMaterialInterface* OpaqueMaterial;
    /* 0x0620 */ UMaterialInterface* OpaqueMaterial_OneSided;
    /* 0x0628 */ UMaterialInterface* MaskedMaterial;
    /* 0x0630 */ UMaterialInterface* MaskedMaterial_OneSided;
    /* 0x0638 */ UTextureRenderTarget2D* RenderTarget;
    /* 0x0640 */ UMaterialInstanceDynamic* MaterialInstance;
    /* 0x0648 */ bool bAddedToScreen;
    /* 0x0649 */ bool bEditTimeUsable;
    /* 0x064c */ FName SharedLayerName;
    /* 0x0654 */ int32_t LayerZOrder;
    /* 0x0658 */ EWidgetGeometryMode GeometryMode;
    /* 0x0660 */ double CylinderArcAngle;
    /* 0x0668 */ ETickMode TickMode;
    /* 0x0698 */ UUserWidget* Widget;

    FVector2D GetCurrentDrawSize() const;
    double GetCylinderArcAngle() const;
    bool GetDrawAtDesiredSize() const;
    FVector2D GetDrawSize() const;
    EWidgetGeometryMode GetGeometryMode() const;
    bool GetManuallyRedraw() const;
    UMaterialInstanceDynamic* GetMaterialInstance() const;
    ULocalPlayer* GetOwnerPlayer() const;
    FVector2D GetPivot() const;
    float GetRedrawTime() const;
    UTextureRenderTarget2D* GetRenderTarget() const;
    bool GetTickWhenOffscreen() const;
    bool GetTwoSided() const;
    UUserWidget* GetUserWidgetObject() const;
    UUserWidget* GetWidget() const;
    EWidgetSpace GetWidgetSpace() const;
    bool GetWindowFocusable() const;
    EWindowVisibility GetWindowVisiblility() const;
    bool IsWidgetVisible() const;
    void RequestRedraw();
    void RequestRenderUpdate();
    void SetBackgroundColor(const FLinearColor NewBackgroundColor);
    void SetCylinderArcAngle(const double InCylinderArcAngle);
    void SetDrawAtDesiredSize(bool bInDrawAtDesiredSize);
    void SetDrawSize(FVector2D Size);
    void SetGeometryMode(EWidgetGeometryMode InGeometryMode);
    void SetManuallyRedraw(bool bUseManualRedraw);
    void SetOwnerPlayer(ULocalPlayer* LocalPlayer);
    void SetPivot(const FVector2D& InPivot);
    void SetRedrawTime(float InRedrawTime);
    void SetTickMode(ETickMode InTickMode);
    void SetTickWhenOffscreen(const bool bWantTickWhenOffscreen);
    void SetTintColorAndOpacity(const FLinearColor NewTintColorAndOpacity);
    void SetTwoSided(const bool bWantTwoSided);
    void SetWidget(UUserWidget* Widget);
    void SetWidgetSpace(EWidgetSpace NewSpace);
    void SetWindowFocusable(bool bInWindowFocusable);
    void SetWindowVisibility(EWindowVisibility InVisibility);
};

// Size: 0xc8
struct FWidgetComponentInstanceData : public FSceneComponentInstanceData {
};

// Size: 0x28
class UWidgetDisabledStateRegistration : public UWidgetBinaryStateRegistration {
};

// Size: 0x28
class UWidgetEnumStateRegistration : public UObject {
};

// Size: 0x1
struct FWidgetEventField {
};

// Size: 0x40
class UWidgetFieldNotificationExtension : public UUserWidgetExtension {
};

// Size: 0x28
class UWidgetHoveredStateRegistration : public UWidgetBinaryStateRegistration {
};

// Size: 0x540
class UWidgetInteractionComponent : public USceneComponent {
    /* 0x0240 */ FMulticastInlineDelegate OnHoveredWidgetChanged;
    /* 0x0260 */ int32_t VirtualUserIndex;
    /* 0x0264 */ int32_t PointerIndex;
    /* 0x0268 */ uint8_t TraceChannel;
    /* 0x026c */ float InteractionDistance;
    /* 0x0270 */ EWidgetInteractionSource InteractionSource;
    /* 0x0271 */ bool bEnableHitTesting;
    /* 0x0272 */ bool bShowDebug;
    /* 0x0274 */ float DebugSphereLineThickness;
    /* 0x0278 */ float DebugLineThickness;
    /* 0x027c */ FLinearColor DebugColor;
    /* 0x0308 */ FHitResult CustomHitResult;
    /* 0x0408 */ FVector2D LocalHitLocation;
    /* 0x0418 */ FVector2D LastLocalHitLocation;
    /* 0x0428 */ UWidgetComponent* HoveredWidgetComponent;
    /* 0x0430 */ TWeakObjectPtr<UWidgetComponent> WeakHoveredWidgetComponent;
    /* 0x0438 */ FHitResult LastHitResult;
    /* 0x0538 */ bool bIsHoveredWidgetInteractable;
    /* 0x0539 */ bool bIsHoveredWidgetFocusable;
    /* 0x053a */ bool bIsHoveredWidgetHitTestVisible;

    FVector2D Get2DHitLocation() const;
    UWidgetComponent* GetHoveredWidgetComponent() const;
    FHitResult GetLastHitResult() const;
    bool IsOverFocusableWidget() const;
    bool IsOverHitTestVisibleWidget() const;
    bool IsOverInteractableWidget() const;
    bool PressAndReleaseKey(FKey Key);
    bool PressKey(FKey Key, bool bRepeat);
    void PressPointerKey(FKey Key);
    bool ReleaseKey(FKey Key);
    void ReleasePointerKey(FKey Key);
    void ScrollWheel(float ScrollDelta);
    bool SendKeyChar(FString Characters, bool bRepeat);
    void SetCustomHitResult(const FHitResult& HitResult);
    void SetFocus(UWidget* FocusWidget);
};

// Size: 0x28
class UWidgetLayoutLibrary : public UBlueprintFunctionLibrary {

    static FVector2D GetMousePositionOnPlatform();
    static FVector2D GetMousePositionOnViewport(UObject* WorldContextObject);
    static bool GetMousePositionScaledByDPI(APlayerController* Player, float& LocationX, float& LocationY);
    static FGeometry GetPlayerScreenWidgetGeometry(APlayerController* PlayerController);
    static float GetViewportScale(const UObject* WorldContextObject);
    static FVector2D GetViewportSize(UObject* WorldContextObject);
    static FGeometry GetViewportWidgetGeometry(UObject* WorldContextObject);
    static bool ProjectWorldLocationToWidgetPosition(APlayerController* PlayerController, FVector WorldLocation, FVector2D& screenPosition, bool bPlayerViewportRelative);
    static void RemoveAllWidgets(UObject* WorldContextObject);
    static UBorderSlot* SlotAsBorderSlot(UWidget* Widget);
    static UCanvasPanelSlot* SlotAsCanvasSlot(UWidget* Widget);
    static UGridSlot* SlotAsGridSlot(UWidget* Widget);
    static UHorizontalBoxSlot* SlotAsHorizontalBoxSlot(UWidget* Widget);
    static UOverlaySlot* SlotAsOverlaySlot(UWidget* Widget);
    static USafeZoneSlot* SlotAsSafeBoxSlot(UWidget* Widget);
    static UScaleBoxSlot* SlotAsScaleBoxSlot(UWidget* Widget);
    static UScrollBoxSlot* SlotAsScrollBoxSlot(UWidget* Widget);
    static USizeBoxSlot* SlotAsSizeBoxSlot(UWidget* Widget);
    static UStackBoxSlot* SlotAsStackBoxSlot(UWidget* Widget);
    static UUniformGridSlot* SlotAsUniformGridSlot(UWidget* Widget);
    static UVerticalBoxSlot* SlotAsVerticalBoxSlot(UWidget* Widget);
    static UWidgetSwitcherSlot* SlotAsWidgetSwitcherSlot(UWidget* Widget);
    static UWrapBoxSlot* SlotAsWrapBoxSlot(UWidget* Widget);
};

// Size: 0x100
class UWidgetNavigation : public UObject {
    /* 0x0028 */ FWidgetNavigationData Up;
    /* 0x004c */ FWidgetNavigationData Down;
    /* 0x0070 */ FWidgetNavigationData Left;
    /* 0x0094 */ FWidgetNavigationData Right;
    /* 0x00b8 */ FWidgetNavigationData Next;
    /* 0x00dc */ FWidgetNavigationData Previous;
};

// Size: 0x24
struct FWidgetNavigationData {
    /* 0x0000 */ EUINavigationRule Rule;
    /* 0x0004 */ FName WidgetToFocus;
    /* 0x000c */ TWeakObjectPtr<UWidget> Widget;
    /* 0x0014 */ FDelegate CustomDelegate;
};

// Size: 0x28
class UWidgetPressedStateRegistration : public UWidgetBinaryStateRegistration {
};

// Size: 0x28
class UWidgetSelectedStateRegistration : public UWidgetBinaryStateRegistration {
};

// Size: 0x8
struct FWidgetStateBitfield {
};

// Size: 0x6e8
class UWidgetStateSettings : public UDeveloperSettings {
};

// Size: 0x198
class UWidgetSwitcher : public UPanelWidget {
    /* 0x0180 */ int32_t ActiveWidgetIndex;

    UWidget* GetActiveWidget() const;
    int32_t GetActiveWidgetIndex() const;
    int32_t GetNumWidgets() const;
    UWidget* GetWidgetAtIndex(int32_t Index) const;
    void SetActiveWidget(UWidget* Widget);
    void SetActiveWidgetIndex(int32_t Index);
};

// Size: 0x58
class UWidgetSwitcherSlot : public UPanelSlot {
    /* 0x0040 */ FMargin Padding;
    /* 0x0050 */ uint8_t HorizontalAlignment;
    /* 0x0051 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x38
struct FWidgetTransform {
    /* 0x0000 */ FVector2D Translation;
    /* 0x0010 */ FVector2D Scale;
    /* 0x0020 */ FVector2D Shear;
    /* 0x0030 */ float Angle;
};

// Size: 0x88
class UWidgetTree : public UObject {
    /* 0x0030 */ UWidget* RootWidget;
    /* 0x0038 */ TMap<FName, UWidget*> NamedSlotBindings;
};

// Size: 0x1a0
class UWindowTitleBarArea : public UContentWidget {
    /* 0x0180 */ bool bWindowButtonsEnabled;
    /* 0x0181 */ bool bDoubleClickTogglesFullscreen;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x60
class UWindowTitleBarAreaSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ uint8_t HorizontalAlignment;
    /* 0x0049 */ uint8_t VerticalAlignment;

    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x1a8
class UWrapBox : public UPanelWidget {
    /* 0x0180 */ FVector2D InnerSlotPadding;
    /* 0x0190 */ float WrapSize;
    /* 0x0194 */ bool bExplicitWrapSize;
    /* 0x0195 */ uint8_t HorizontalAlignment;
    /* 0x0196 */ uint8_t Orientation;

    UWrapBoxSlot* AddChildToWrapBox(UWidget* Content);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetInnerSlotPadding(FVector2D InPadding);
};

// Size: 0x58
class UWrapBoxSlot : public UPanelSlot {
    /* 0x0038 */ FMargin Padding;
    /* 0x0048 */ float FillSpanWhenLessThan;
    /* 0x004c */ uint8_t HorizontalAlignment;
    /* 0x004d */ uint8_t VerticalAlignment;
    /* 0x004e */ bool bFillEmptySpace;
    /* 0x004f */ bool bForceNewLine;

    void SetFillEmptySpace(bool InbFillEmptySpace);
    void SetFillSpanWhenLessThan(float InFillSpanWhenLessThan);
    void SetHorizontalAlignment(uint8_t InHorizontalAlignment);
    void SetNewLine(bool InForceNewLine);
    void SetPadding(FMargin InPadding);
    void SetVerticalAlignment(uint8_t InVerticalAlignment);
};

// Size: 0x5a0
class Ubutton : public UContentWidget {
    /* 0x0180 */ FButtonStyle WidgetStyle;
    /* 0x0510 */ FLinearColor ColorAndOpacity;
    /* 0x0520 */ FLinearColor BackgroundColor;
    /* 0x0530 */ uint8_t ClickMethod;
    /* 0x0531 */ uint8_t TouchMethod;
    /* 0x0532 */ uint8_t PressMethod;
    /* 0x0533 */ bool IsFocusable;
    /* 0x0538 */ FMulticastInlineDelegate OnClicked;
    /* 0x0548 */ FMulticastInlineDelegate OnPressed;
    /* 0x0558 */ FMulticastInlineDelegate OnReleased;
    /* 0x0568 */ FMulticastInlineDelegate OnHovered;
    /* 0x0578 */ FMulticastInlineDelegate OnUnhovered;

    bool IsPressed() const;
    void SetBackgroundColor(FLinearColor InBackgroundColor);
    void SetClickMethod(uint8_t InClickMethod);
    void SetColorAndOpacity(FLinearColor InColorAndOpacity);
    void SetPressMethod(uint8_t InPressMethod);
    void SetStyle(const FButtonStyle& InStyle);
    void SetTouchMethod(uint8_t InTouchMethod);
};

// Size: 0x38
class UMyPluginObject : public UObject {
    /* 0x0028 */ FMyPluginStruct MyStruct;
};

// Size: 0x10
struct FMyPluginStruct {
    /* 0x0000 */ FString TestString;
};

enum class EUdpMessageFormat {
    None = 0,
    Json = 1,
    TaggedProperty = 2,
    CborPlatformEndianness = 3,
    CborStandardEndianness = 4,
    EUdpMessageFormat_MAX = 5,
};

// Size: 0xc0
class UUdpMessagingSettings : public UObject {
    /* 0x0028 */ bool EnabledByDefault;
    /* 0x0029 */ bool EnableTransport;
    /* 0x002a */ bool bAutoRepair;
    /* 0x002c */ float MaxSendRate;
    /* 0x0030 */ uint32_t AutoRepairAttemptLimit;
    /* 0x0034 */ uint16_t WorkQueueSize;
    /* 0x0036 */ bool bStopServiceWhenAppDeactivates;
    /* 0x0038 */ FString UnicastEndpoint;
    /* 0x0048 */ FString MulticastEndpoint;
    /* 0x0058 */ EUdpMessageFormat MessageFormat;
    /* 0x0059 */ uint8_t MulticastTimeToLive;
    /* 0x0060 */ TArray<FString> StaticEndpoints;
    /* 0x0070 */ TArray<FString> ExcludedEndpoints;
    /* 0x0080 */ bool bShareKnownNodesWithActiveConnections;
    /* 0x0084 */ uint32_t MaxConcurrentDeserializationTasks;
    /* 0x0088 */ bool EnableTunnel;
    /* 0x0090 */ FString TunnelUnicastEndpoint;
    /* 0x00a0 */ FString TunnelMulticastEndpoint;
    /* 0x00b0 */ TArray<FString> RemoteTunnelEndpoints;
};

// Size: 0x10
struct FUdpMockMessage {
    /* 0x0000 */ TArray<uint8_t> Data;
};

// Size: 0x20
struct FDirectPathObjectLocator {
    /* 0x0000 */ FSoftObjectPath Path;
};

enum class ELocatorResolveFlags {
    None = 0,
    Load = 1,
    Unload = 2,
    Async = 4,
    WillWait = 8,
    AsyncWait = 12,
    ELocatorResolveFlags_MAX = 13,
};

// Size: 0x10
struct FSubObjectLocator {
    /* 0x0000 */ FString PathWithinContext;
};

// Size: 0x10
struct FUniversalObjectLocator {
    /* 0x0000 */ TArray<FUniversalObjectLocatorFragment> Fragments;
};

// Size: 0x1
struct FUniversalObjectLocatorEmptyPayload {
};

// Size: 0x20
struct FUniversalObjectLocatorFragment {
};

// Size: 0x28
struct FCapturedPropSegment {
    /* 0x0000 */ FString PropertyName;
    /* 0x0010 */ int32_t PropertyIndex;
    /* 0x0018 */ FString ComponentName;
};

enum class EPropertyValueCategory {
    Undefined = 0,
    Generic = 1,
    RelativeLocation = 2,
    RelativeRotation = 4,
    RelativeScale3D = 8,
    Visibility = 16,
    Material = 32,
    Color = 64,
    Option = 128,
    EPropertyValueCategory_MAX = 129,
};

// Size: 0x8
struct FFunctionCaller {
    /* 0x0000 */ FName FunctionName;
};

// Size: 0x90
class ULevelVariantSets : public UObject {
    /* 0x0028 */ UBlueprintGeneratedClass* DirectorClass;
    /* 0x0030 */ TArray<UVariantSet*> VariantSets;

    int32_t GetNumVariantSets();
    UVariantSet* GetVariantSet(int32_t VariantSetIndex);
    UVariantSet* GetVariantSetByName(FString VariantSetName);
};

// Size: 0x318
class ALevelVariantSetsActor : public AActor {
    /* 0x02a8 */ FSoftObjectPath LevelVariantSets;
    /* 0x02c8 */ TMap<UBlueprintGeneratedClass*, ULevelVariantSetsFunctionDirector*> DirectorInstances;

    ULevelVariantSets* GetLevelVariantSets(bool bLoad);
    void SetLevelVariantSets(ULevelVariantSets* InVariantSets);
    bool SwitchOnVariantByIndex(int32_t VariantSetIndex, int32_t VariantIndex);
    bool SwitchOnVariantByName(FString VariantSetName, FString VariantName);
};

// Size: 0x40
class ULevelVariantSetsFunctionDirector : public UObject {
};

// Size: 0x1b0
class UPropertyValue : public UObject {
    /* 0x0088 */ TArray<FFieldPath> Properties;
    /* 0x0098 */ TArray<int32_t> PropertyIndices;
    /* 0x00a8 */ TArray<FCapturedPropSegment> CapturedPropSegments;
    /* 0x00b8 */ FString FullDisplayString;
    /* 0x00c8 */ FName PropertySetterName;
    /* 0x00d0 */ TMap<FString, FString> PropertySetterParameterDefaults;
    /* 0x0120 */ bool bHasRecordedData;
    /* 0x0128 */ UClass* LeafPropertyClass;
    /* 0x0138 */ TArray<uint8_t> ValueBytes;
    /* 0x0148 */ EPropertyValueCategory PropCategory;

    FString GetFullDisplayString() const;
    FText GetPropertyTooltip() const;
    bool HasRecordedData() const;
};

// Size: 0x1b0
class UPropertyValueColor : public UPropertyValue {
};

// Size: 0x1b0
class UPropertyValueMaterial : public UPropertyValue {
};

// Size: 0x1b0
class UPropertyValueOption : public UPropertyValue {
};

// Size: 0x1b0
class UPropertyValueSoftObject : public UPropertyValue {
};

// Size: 0x1b0
class UPropertyValueTransform : public UPropertyValue {
};

// Size: 0x1b0
class UPropertyValueVisibility : public UPropertyValue {
};

// Size: 0x2d0
class ASwitchActor : public AActor {
    /* 0x02c0 */ USceneComponent* SceneComponent;
    /* 0x02c8 */ int32_t LastSelectedOption;

    TArray<AActor*> GetOptions() const;
    int32_t GetSelectedOption() const;
    void SelectOption(int32_t OptionIndex);
};

// Size: 0x70
class UVariant : public UObject {
    /* 0x0028 */ TArray<FVariantDependency> Dependencies;
    /* 0x0038 */ FText DisplayText;
    /* 0x0058 */ TArray<UVariantObjectBinding*> ObjectBindings;
    /* 0x0068 */ UTexture2D* Thumbnail;

    int32_t AddDependency(FVariantDependency& Dependency);
    void DeleteDependency(int32_t Index);
    AActor* GetActor(int32_t ActorIndex);
    FVariantDependency GetDependency(int32_t Index);
    TArray<UVariant*> GetDependents(ULevelVariantSets* LevelVariantSets, bool bOnlyEnabledDependencies);
    FText GetDisplayText() const;
    int32_t GetNumActors();
    int32_t GetNumDependencies();
    UVariantSet* GetParent();
    UTexture2D* GetThumbnail();
    bool IsActive();
    void SetDependency(int32_t Index, FVariantDependency& Dependency);
    void SetDisplayText(const FText& NewDisplayText);
    void SetThumbnailFromCamera(UObject* WorldContextObject, const FTransform& CameraTransform, float FOVDegrees, float minZ, float Gamma);
    void SetThumbnailFromEditorViewport();
    void SetThumbnailFromFile(FString FilePath);
    void SetThumbnailFromTexture(UTexture2D* NewThumbnail);
    void SwitchOn();
};

// Size: 0x58
struct FVariantDependency {
    /* 0x0000 */ TSoftObjectPtr<UVariantSet> VariantSet;
    /* 0x0028 */ TSoftObjectPtr<UVariant> Variant;
    /* 0x0050 */ bool bEnabled;
};

// Size: 0x90
class UVariantObjectBinding : public UObject {
    /* 0x0028 */ FString CachedActorLabel;
    /* 0x0038 */ FSoftObjectPath ObjectPtr;
    /* 0x0058 */ TLazyObjectPtr<UObject> LazyObjectPtr;
    /* 0x0070 */ TArray<UPropertyValue*> CapturedProperties;
    /* 0x0080 */ TArray<FFunctionCaller> FunctionCallers;
};

// Size: 0x68
class UVariantSet : public UObject {
    /* 0x0028 */ FText DisplayText;
    /* 0x0048 */ bool bExpanded;
    /* 0x0050 */ TArray<UVariant*> Variants;
    /* 0x0060 */ UTexture2D* Thumbnail;

    FText GetDisplayText() const;
    int32_t GetNumVariants() const;
    ULevelVariantSets* GetParent();
    UTexture2D* GetThumbnail();
    UVariant* GetVariant(int32_t VariantIndex);
    UVariant* GetVariantByName(FString VariantName);
    void SetDisplayText(const FText& NewDisplayText);
    void SetThumbnailFromCamera(UObject* WorldContextObject, const FTransform& CameraTransform, float FOVDegrees, float minZ, float Gamma);
    void SetThumbnailFromEditorViewport();
    void SetThumbnailFromFile(FString FilePath);
    void SetThumbnailFromTexture(UTexture2D* NewThumbnail);
};

enum class EVectorVMBaseTypes {
    Float = 0,
    Int = 1,
    Bool = 2,
    Num = 3,
    EVectorVMBaseTypes_MAX = 4,
};

enum class EVectorVMOperandLocation {
    Register = 0,
    Constant = 1,
    Num = 2,
    EVectorVMOperandLocation_MAX = 3,
};

enum class EWaveTableBitDepth {
    PCM_16 = 0,
    IEEE_Float = 1,
    COUNT = 2,
    EWaveTableBitDepth_MAX = 3,
};

enum class EWaveTableCurve {
    Linear = 0,
    Linear_Inv = 1,
    Exp = 2,
    Exp_Inverse = 3,
    Log = 4,
    Sin = 5,
    Sin_Full = 6,
    SCurve = 7,
    Shared = 8,
    Custom = 9,
    File = 10,
    Count = 11,
    EWaveTableCurve_MAX = 12,
};

enum class EWaveTableResolution {
    None = 0,
    Res_8 = 3,
    Res_16 = 4,
    Res_32 = 5,
    Res_64 = 6,
    Res_128 = 7,
    Res_256 = 8,
    Res_512 = 9,
    Res_1024 = 10,
    Res_2048 = 11,
    Res_4096 = 12,
    Res_Max = 12,
    Maximum = 13,
    EWaveTableResolution_MAX = 14,
};

enum class EWaveTableSamplingMode {
    FixedSampleRate = 0,
    FixedResolution = 1,
    COUNT = 2,
    EWaveTableSamplingMode_MAX = 3,
};

// Size: 0x60
class UWaveTableBank : public UObject {
    /* 0x0030 */ EWaveTableSamplingMode SampleMode;
    /* 0x0031 */ EWaveTableResolution Resolution;
    /* 0x0034 */ int32_t SampleRate;
    /* 0x0038 */ bool bBipolar;
    /* 0x0040 */ TArray<FWaveTableBankEntry> Entries;
};

// Size: 0xb8
struct FWaveTableBankEntry {
    /* 0x0000 */ FWaveTableTransform Transform;
};

// Size: 0x20
struct FWaveTableData {
    /* 0x0000 */ EWaveTableBitDepth BitDepth;
    /* 0x0008 */ TArray<uint8_t> Data;
    /* 0x0018 */ float FinalValue;
};

// Size: 0x58
struct FWaveTableSettings {
    /* 0x0000 */ FFilePath FilePath;
    /* 0x0010 */ int32_t ChannelIndex;
    /* 0x0018 */ FWaveTableData SourceData;
    /* 0x0038 */ int32_t SourceSampleRate;
    /* 0x003c */ float Phase;
    /* 0x0040 */ float Top;
    /* 0x0044 */ float Tail;
    /* 0x0048 */ float FadeIn;
    /* 0x004c */ float FadeOut;
    /* 0x0050 */ bool bNormalize;
    /* 0x0051 */ bool bRemoveOffset;
};

// Size: 0xb8
struct FWaveTableTransform {
    /* 0x0000 */ EWaveTableCurve Curve;
    /* 0x0004 */ float Scalar;
    /* 0x0008 */ FRichCurve CurveCustom;
    /* 0x0088 */ UCurveFloat* CurveShared;
    /* 0x0090 */ FWaveTableData TableData;
    /* 0x00b0 */ float Duration;
};

// Size: 0x20
struct FWorldMetricCollection {
    /* 0x0000 */ TArray<UWorldMetricInterface*> metrics;
    /* 0x0010 */ TWeakObjectPtr<UWorldMetricsSubsystem> Subsystem;
    /* 0x0018 */ bool bIsEnabled;
};

// Size: 0x28
class UWorldMetricInterface : public UObject {
};

// Size: 0xd0
class UWorldMetricsActorTracker : public UWorldMetricsExtension {
};

// Size: 0x28
class IWorldMetricsActorTrackerSubscriber : public UInterface {
};

// Size: 0x28
class UWorldMetricsExtension : public UObject {
};

// Size: 0x2a40
class UWorldMetricsSubsystem : public UWorldSubsystem {
    /* 0x0040 */ TArray<UWorldMetricInterface*> metrics;
    /* 0x2a30 */ float UpdateRateInSeconds;
    /* 0x2a34 */ int32_t WarmUpFrames;
};

enum class EXeFGMode {
    Off = 0,
    On = 1,
    EXeFGMode_MAX = 2,
};

// Size: 0x28
class UXeFGBlueprintLibrary : public UBlueprintFunctionLibrary {

    static TArray<EXeFGMode> GetSupportedXeFGModes();
    static EXeFGMode GetXeFGMode();
    static bool IfRelaunchRequiredByXeFG();
    static bool IsXeFGSupported();
    static void SetXeFGMode(EXeFGMode Mode);
};

enum class EXeLLMode {
    Off = 0,
    On = 1,
    EXeLLMode_MAX = 2,
};

// Size: 0x28
class UXeLLBlueprintLibrary : public UBlueprintFunctionLibrary {

    static bool GetFlashIndicatorEnabled();
    static float GetGameLatencyInMs();
    static float GetGameToRenderLatencyInMs();
    static float GetInputLatencyInMs();
    static bool GetLatencyMarkEnabled();
    static float GetPresentLatencyInMs();
    static float GetRenderLatencyInMs();
    static float GetRenderSubmitLatencyInMs();
    static float GetSimulationLatencyInMs();
    static TArray<EXeLLMode> GetSupportedXeLLModes();
    static EXeLLMode GetXeLLMode();
    static bool IsXeLLSupported();
    static void SetFlashIndicatorEnabled(const bool bEnabled);
    static void SetXeLLMode(const EXeLLMode Mode);
};

enum class EXeSSQualityMode {
    Off = 0,
    UltraPerformance = 1,
    Performance = 2,
    Balanced = 3,
    Quality = 4,
    UltraQuality = 5,
    UltraQualityPlus = 6,
    AntiAliasing = 7,
    EXeSSQualityMode_MAX = 8,
};

// Size: 0x28
class UXeSSBlueprintLibrary : public UBlueprintFunctionLibrary {

    static EXeSSQualityMode GetDefaultXeSSQualityMode(FIntPoint ScreenResolution);
    static TArray<EXeSSQualityMode> GetSupportedXeSSQualityModes();
    static EXeSSQualityMode GetXeSSQualityMode();
    static bool GetXeSSQualityModeInformation(EXeSSQualityMode QualityMode, float& ScreenPercentage);
    static bool IsXeSSSupported();
    static void SetXeSSQualityMode(EXeSSQualityMode QualityMode);
};

// Size: 0x40
class UXeSSSettings : public UDeveloperSettings {
    /* 0x0038 */ bool bEnableXeSSInEditorViewports;
};

