#pragma once

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

// Package: MovieScene

#include "Basic.hpp"

#include "CoreUObject_structs.hpp"
#include "Engine_structs.hpp"


namespace SDK
{

// Enum MovieScene.EMovieSceneKeyInterpolation
// NumValues: 0x0006
enum class EMovieSceneKeyInterpolation : uint8
{
	Auto                                     = 0,
	User                                     = 1,
	Break                                    = 2,
	Linear                                   = 3,
	Constant                                 = 4,
	EMovieSceneKeyInterpolation_MAX          = 5,
};

// Enum MovieScene.EMovieSceneBlendType
// NumValues: 0x0006
enum class EMovieSceneBlendType : uint8
{
	Invalid                                  = 0,
	Absolute                                 = 1,
	Additive                                 = 2,
	Relative                                 = 4,
	AdditiveFromBase                         = 8,
	EMovieSceneBlendType_MAX                 = 9,
};

// Enum MovieScene.EMovieSceneCompletionMode
// NumValues: 0x0004
enum class EMovieSceneCompletionMode : uint8
{
	KeepState                                = 0,
	RestoreState                             = 1,
	ProjectDefault                           = 2,
	EMovieSceneCompletionMode_MAX            = 3,
};

// Enum MovieScene.EMovieSceneBuiltInEasing
// NumValues: 0x0017
enum class EMovieSceneBuiltInEasing : uint8
{
	Linear                                   = 0,
	SinIn                                    = 1,
	SinOut                                   = 2,
	SinInOut                                 = 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,
	EMovieSceneBuiltInEasing_MAX             = 22,
};

// Enum MovieScene.EEvaluationMethod
// NumValues: 0x0003
enum class EEvaluationMethod : uint8
{
	Static                                   = 0,
	Swept                                    = 1,
	EEvaluationMethod_MAX                    = 2,
};

// Enum MovieScene.EMovieSceneServerClientMask
// NumValues: 0x0005
enum class EMovieSceneServerClientMask : uint8
{
	None                                     = 0,
	Server                                   = 1,
	Client                                   = 2,
	All                                      = 3,
	EMovieSceneServerClientMask_MAX          = 4,
};

// Enum MovieScene.EMovieSceneSequenceFlags
// NumValues: 0x0005
enum class EMovieSceneSequenceFlags : uint8
{
	None                                     = 0,
	Volatile                                 = 1,
	BlockingEvaluation                       = 2,
	InheritedFlags                           = 1,
	EMovieSceneSequenceFlags_MAX             = 3,
};

// Enum MovieScene.EUpdateClockSource
// NumValues: 0x0007
enum class EUpdateClockSource : uint8
{
	Tick                                     = 0,
	Platform                                 = 1,
	Audio                                    = 2,
	RelativeTimecode                         = 3,
	Timecode                                 = 4,
	Custom                                   = 5,
	EUpdateClockSource_MAX                   = 6,
};

// Enum MovieScene.EMovieSceneEvaluationType
// NumValues: 0x0003
enum class EMovieSceneEvaluationType : uint8
{
	FrameLocked                              = 0,
	WithSubFrames                            = 1,
	EMovieSceneEvaluationType_MAX            = 2,
};

// Enum MovieScene.EMovieScenePlayerStatus
// NumValues: 0x0007
enum class EMovieScenePlayerStatus : uint8
{
	Stopped                                  = 0,
	Playing                                  = 1,
	Scrubbing                                = 2,
	Jumping                                  = 3,
	Stepping                                 = 4,
	Paused                                   = 5,
	MAX                                      = 6,
};

// Enum MovieScene.EMovieSceneObjectBindingSpace
// NumValues: 0x0004
enum class EMovieSceneObjectBindingSpace : uint8
{
	Local                                    = 0,
	Root                                     = 1,
	Unused                                   = 2,
	EMovieSceneObjectBindingSpace_MAX        = 3,
};

// Enum MovieScene.ESectionEvaluationFlags
// NumValues: 0x0004
enum class ESectionEvaluationFlags : uint8
{
	None                                     = 0,
	PreRoll                                  = 1,
	PostRoll                                 = 2,
	ESectionEvaluationFlags_MAX              = 3,
};

// Enum MovieScene.EMovieScenePositionType
// NumValues: 0x0004
enum class EMovieScenePositionType : uint8
{
	Frame                                    = 0,
	Time                                     = 1,
	MarkedFrame                              = 2,
	EMovieScenePositionType_MAX              = 3,
};

// Enum MovieScene.EUpdatePositionMethod
// NumValues: 0x0004
enum class EUpdatePositionMethod : uint8
{
	Play                                     = 0,
	Jump                                     = 1,
	Scrub                                    = 2,
	EUpdatePositionMethod_MAX                = 3,
};

// Enum MovieScene.ESpawnOwnership
// NumValues: 0x0004
enum class ESpawnOwnership : uint8
{
	InnerSequence                            = 0,
	MasterSequence                           = 1,
	External                                 = 2,
	ESpawnOwnership_MAX                      = 3,
};

// ScriptStruct MovieScene.MovieSceneKeyStruct
// 0x0008 (0x0008 - 0x0000)
struct alignas(0x08) FMovieSceneKeyStruct
{
public:
	uint8                                         Pad_0[0x8];                                        // 0x0000(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneKeyStruct) == 0x000008, "Wrong alignment on FMovieSceneKeyStruct");
static_assert(sizeof(FMovieSceneKeyStruct) == 0x000008, "Wrong size on FMovieSceneKeyStruct");

// ScriptStruct MovieScene.MovieSceneChannel
// 0x0008 (0x0008 - 0x0000)
struct alignas(0x08) FMovieSceneChannel
{
public:
	uint8                                         Pad_0[0x8];                                        // 0x0000(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneChannel) == 0x000008, "Wrong alignment on FMovieSceneChannel");
static_assert(sizeof(FMovieSceneChannel) == 0x000008, "Wrong size on FMovieSceneChannel");

// ScriptStruct MovieScene.MovieSceneBoolChannel
// 0x0088 (0x0090 - 0x0008)
struct FMovieSceneBoolChannel final : public FMovieSceneChannel
{
public:
	TArray<struct FFrameNumber>                   Times;                                             // 0x0008(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	bool                                          DefaultValue;                                      // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bHasDefaultValue;                                  // 0x0019(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<bool>                                  Values;                                            // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_30[0x60];                                      // 0x0030(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneBoolChannel) == 0x000008, "Wrong alignment on FMovieSceneBoolChannel");
static_assert(sizeof(FMovieSceneBoolChannel) == 0x000090, "Wrong size on FMovieSceneBoolChannel");
static_assert(offsetof(FMovieSceneBoolChannel, Times) == 0x000008, "Member 'FMovieSceneBoolChannel::Times' has a wrong offset!");
static_assert(offsetof(FMovieSceneBoolChannel, DefaultValue) == 0x000018, "Member 'FMovieSceneBoolChannel::DefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneBoolChannel, bHasDefaultValue) == 0x000019, "Member 'FMovieSceneBoolChannel::bHasDefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneBoolChannel, Values) == 0x000020, "Member 'FMovieSceneBoolChannel::Values' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationGroupLUTIndex
// 0x0008 (0x0008 - 0x0000)
struct FMovieSceneEvaluationGroupLUTIndex final
{
public:
	int32                                         NumInitPtrs;                                       // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         NumEvalPtrs;                                       // 0x0004(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationGroupLUTIndex) == 0x000004, "Wrong alignment on FMovieSceneEvaluationGroupLUTIndex");
static_assert(sizeof(FMovieSceneEvaluationGroupLUTIndex) == 0x000008, "Wrong size on FMovieSceneEvaluationGroupLUTIndex");
static_assert(offsetof(FMovieSceneEvaluationGroupLUTIndex, NumInitPtrs) == 0x000000, "Member 'FMovieSceneEvaluationGroupLUTIndex::NumInitPtrs' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationGroupLUTIndex, NumEvalPtrs) == 0x000004, "Member 'FMovieSceneEvaluationGroupLUTIndex::NumEvalPtrs' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceID
// 0x0004 (0x0004 - 0x0000)
struct FMovieSceneSequenceID final
{
public:
	uint32                                        Value;                                             // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneSequenceID) == 0x000004, "Wrong alignment on FMovieSceneSequenceID");
static_assert(sizeof(FMovieSceneSequenceID) == 0x000004, "Wrong size on FMovieSceneSequenceID");
static_assert(offsetof(FMovieSceneSequenceID, Value) == 0x000000, "Member 'FMovieSceneSequenceID::Value' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackIdentifier
// 0x0004 (0x0004 - 0x0000)
struct FMovieSceneTrackIdentifier final
{
public:
	uint32                                        Value;                                             // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneTrackIdentifier) == 0x000004, "Wrong alignment on FMovieSceneTrackIdentifier");
static_assert(sizeof(FMovieSceneTrackIdentifier) == 0x000004, "Wrong size on FMovieSceneTrackIdentifier");
static_assert(offsetof(FMovieSceneTrackIdentifier, Value) == 0x000000, "Member 'FMovieSceneTrackIdentifier::Value' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldTrackPtr
// 0x0008 (0x0008 - 0x0000)
struct FMovieSceneEvaluationFieldTrackPtr
{
public:
	struct FMovieSceneSequenceID                  SequenceID;                                        // 0x0000(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneTrackIdentifier             TrackIdentifier;                                   // 0x0004(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationFieldTrackPtr) == 0x000004, "Wrong alignment on FMovieSceneEvaluationFieldTrackPtr");
static_assert(sizeof(FMovieSceneEvaluationFieldTrackPtr) == 0x000008, "Wrong size on FMovieSceneEvaluationFieldTrackPtr");
static_assert(offsetof(FMovieSceneEvaluationFieldTrackPtr, SequenceID) == 0x000000, "Member 'FMovieSceneEvaluationFieldTrackPtr::SequenceID' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationFieldTrackPtr, TrackIdentifier) == 0x000004, "Member 'FMovieSceneEvaluationFieldTrackPtr::TrackIdentifier' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneFieldEntry_EvaluationTrack
// 0x000C (0x000C - 0x0000)
struct FMovieSceneFieldEntry_EvaluationTrack final
{
public:
	struct FMovieSceneEvaluationFieldTrackPtr     TrackPtr;                                          // 0x0000(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        NumChildren;                                       // 0x0008(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x2];                                        // 0x000A(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneFieldEntry_EvaluationTrack) == 0x000004, "Wrong alignment on FMovieSceneFieldEntry_EvaluationTrack");
static_assert(sizeof(FMovieSceneFieldEntry_EvaluationTrack) == 0x00000C, "Wrong size on FMovieSceneFieldEntry_EvaluationTrack");
static_assert(offsetof(FMovieSceneFieldEntry_EvaluationTrack, TrackPtr) == 0x000000, "Member 'FMovieSceneFieldEntry_EvaluationTrack::TrackPtr' has a wrong offset!");
static_assert(offsetof(FMovieSceneFieldEntry_EvaluationTrack, NumChildren) == 0x000008, "Member 'FMovieSceneFieldEntry_EvaluationTrack::NumChildren' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneFieldEntry_ChildTemplate
// 0x0008 (0x0008 - 0x0000)
struct FMovieSceneFieldEntry_ChildTemplate final
{
public:
	uint16                                        ChildIndex;                                        // 0x0000(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESectionEvaluationFlags                       Flags;                                             // 0x0002(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_3[0x1];                                        // 0x0003(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FFrameNumber                           ForcedTime;                                        // 0x0004(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneFieldEntry_ChildTemplate) == 0x000004, "Wrong alignment on FMovieSceneFieldEntry_ChildTemplate");
static_assert(sizeof(FMovieSceneFieldEntry_ChildTemplate) == 0x000008, "Wrong size on FMovieSceneFieldEntry_ChildTemplate");
static_assert(offsetof(FMovieSceneFieldEntry_ChildTemplate, ChildIndex) == 0x000000, "Member 'FMovieSceneFieldEntry_ChildTemplate::ChildIndex' has a wrong offset!");
static_assert(offsetof(FMovieSceneFieldEntry_ChildTemplate, Flags) == 0x000002, "Member 'FMovieSceneFieldEntry_ChildTemplate::Flags' has a wrong offset!");
static_assert(offsetof(FMovieSceneFieldEntry_ChildTemplate, ForcedTime) == 0x000004, "Member 'FMovieSceneFieldEntry_ChildTemplate::ForcedTime' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationGroup
// 0x0030 (0x0030 - 0x0000)
struct FMovieSceneEvaluationGroup final
{
public:
	TArray<struct FMovieSceneEvaluationGroupLUTIndex> LUTIndices;                                    // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FMovieSceneFieldEntry_EvaluationTrack> TrackLUT;                                   // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FMovieSceneFieldEntry_ChildTemplate> SectionLUT;                                   // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationGroup) == 0x000008, "Wrong alignment on FMovieSceneEvaluationGroup");
static_assert(sizeof(FMovieSceneEvaluationGroup) == 0x000030, "Wrong size on FMovieSceneEvaluationGroup");
static_assert(offsetof(FMovieSceneEvaluationGroup, LUTIndices) == 0x000000, "Member 'FMovieSceneEvaluationGroup::LUTIndices' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationGroup, TrackLUT) == 0x000010, "Member 'FMovieSceneEvaluationGroup::TrackLUT' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationGroup, SectionLUT) == 0x000020, "Member 'FMovieSceneEvaluationGroup::SectionLUT' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvalTemplateBase
// 0x0010 (0x0010 - 0x0000)
struct alignas(0x08) FMovieSceneEvalTemplateBase
{
public:
	uint8                                         Pad_0[0x10];                                       // 0x0000(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvalTemplateBase) == 0x000008, "Wrong alignment on FMovieSceneEvalTemplateBase");
static_assert(sizeof(FMovieSceneEvalTemplateBase) == 0x000010, "Wrong size on FMovieSceneEvalTemplateBase");

// ScriptStruct MovieScene.MovieSceneEvalTemplatePtr
// 0x0088 (0x0088 - 0x0000)
struct alignas(0x08) FMovieSceneEvalTemplatePtr final
{
public:
	uint8                                         Pad_0[0x88];                                       // 0x0000(0x0088)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvalTemplatePtr) == 0x000008, "Wrong alignment on FMovieSceneEvalTemplatePtr");
static_assert(sizeof(FMovieSceneEvalTemplatePtr) == 0x000088, "Wrong size on FMovieSceneEvalTemplatePtr");

// ScriptStruct MovieScene.MovieSceneTrackImplementationPtr
// 0x0038 (0x0038 - 0x0000)
struct alignas(0x08) FMovieSceneTrackImplementationPtr final
{
public:
	uint8                                         Pad_0[0x38];                                       // 0x0000(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneTrackImplementationPtr) == 0x000008, "Wrong alignment on FMovieSceneTrackImplementationPtr");
static_assert(sizeof(FMovieSceneTrackImplementationPtr) == 0x000038, "Wrong size on FMovieSceneTrackImplementationPtr");

// ScriptStruct MovieScene.MovieSceneEvaluationTrack
// 0x0078 (0x0078 - 0x0000)
struct FMovieSceneEvaluationTrack final
{
public:
	struct FGuid                                  ObjectBindingID;                                   // 0x0000(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint16                                        EvaluationPriority;                                // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	EEvaluationMethod                             EvaluationMethod;                                  // 0x0012(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_13[0x1];                                       // 0x0013(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UMovieSceneTrack>        SourceTrack;                                       // 0x0014(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FMovieSceneEvalTemplatePtr>     ChildTemplates;                                    // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	struct FMovieSceneTrackImplementationPtr      TrackTemplate;                                     // 0x0030(0x0038)(NativeAccessSpecifierPrivate)
	class FName                                   EvaluationGroup;                                   // 0x0068(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bEvaluateInPreroll : 1;                            // 0x0070(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bEvaluateInPostroll : 1;                           // 0x0070(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         bTearDownPriority : 1;                             // 0x0070(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_71[0x7];                                       // 0x0071(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationTrack) == 0x000008, "Wrong alignment on FMovieSceneEvaluationTrack");
static_assert(sizeof(FMovieSceneEvaluationTrack) == 0x000078, "Wrong size on FMovieSceneEvaluationTrack");
static_assert(offsetof(FMovieSceneEvaluationTrack, ObjectBindingID) == 0x000000, "Member 'FMovieSceneEvaluationTrack::ObjectBindingID' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, EvaluationPriority) == 0x000010, "Member 'FMovieSceneEvaluationTrack::EvaluationPriority' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, EvaluationMethod) == 0x000012, "Member 'FMovieSceneEvaluationTrack::EvaluationMethod' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, SourceTrack) == 0x000014, "Member 'FMovieSceneEvaluationTrack::SourceTrack' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, ChildTemplates) == 0x000020, "Member 'FMovieSceneEvaluationTrack::ChildTemplates' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, TrackTemplate) == 0x000030, "Member 'FMovieSceneEvaluationTrack::TrackTemplate' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTrack, EvaluationGroup) == 0x000068, "Member 'FMovieSceneEvaluationTrack::EvaluationGroup' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationTemplateSerialNumber
// 0x0004 (0x0004 - 0x0000)
struct FMovieSceneEvaluationTemplateSerialNumber final
{
public:
	uint32                                        Value;                                             // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneEvaluationTemplateSerialNumber) == 0x000004, "Wrong alignment on FMovieSceneEvaluationTemplateSerialNumber");
static_assert(sizeof(FMovieSceneEvaluationTemplateSerialNumber) == 0x000004, "Wrong size on FMovieSceneEvaluationTemplateSerialNumber");
static_assert(offsetof(FMovieSceneEvaluationTemplateSerialNumber, Value) == 0x000000, "Member 'FMovieSceneEvaluationTemplateSerialNumber::Value' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneFrameRange
// 0x0010 (0x0010 - 0x0000)
struct alignas(0x04) FMovieSceneFrameRange final
{
public:
	uint8                                         Pad_0[0x10];                                       // 0x0000(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneFrameRange) == 0x000004, "Wrong alignment on FMovieSceneFrameRange");
static_assert(sizeof(FMovieSceneFrameRange) == 0x000010, "Wrong size on FMovieSceneFrameRange");

// ScriptStruct MovieScene.MovieSceneTemplateGenerationLedger
// 0x00A8 (0x00A8 - 0x0000)
struct FMovieSceneTemplateGenerationLedger final
{
public:
	struct FMovieSceneTrackIdentifier             LastTrackIdentifier;                               // 0x0000(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<struct FGuid, struct FMovieSceneTrackIdentifier> TrackSignatureToTrackIdentifier;           // 0x0008(0x0050)(NativeAccessSpecifierPublic)
	TMap<struct FGuid, struct FMovieSceneFrameRange> SubSectionRanges;                               // 0x0058(0x0050)(NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTemplateGenerationLedger) == 0x000008, "Wrong alignment on FMovieSceneTemplateGenerationLedger");
static_assert(sizeof(FMovieSceneTemplateGenerationLedger) == 0x0000A8, "Wrong size on FMovieSceneTemplateGenerationLedger");
static_assert(offsetof(FMovieSceneTemplateGenerationLedger, LastTrackIdentifier) == 0x000000, "Member 'FMovieSceneTemplateGenerationLedger::LastTrackIdentifier' has a wrong offset!");
static_assert(offsetof(FMovieSceneTemplateGenerationLedger, TrackSignatureToTrackIdentifier) == 0x000008, "Member 'FMovieSceneTemplateGenerationLedger::TrackSignatureToTrackIdentifier' has a wrong offset!");
static_assert(offsetof(FMovieSceneTemplateGenerationLedger, SubSectionRanges) == 0x000058, "Member 'FMovieSceneTemplateGenerationLedger::SubSectionRanges' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationTemplate
// 0x0160 (0x0160 - 0x0000)
struct FMovieSceneEvaluationTemplate final
{
public:
	TMap<struct FMovieSceneTrackIdentifier, struct FMovieSceneEvaluationTrack> Tracks;               // 0x0000(0x0050)(ContainsInstancedReference, NativeAccessSpecifierPrivate)
	uint8                                         Pad_50[0x50];                                      // 0x0050(0x0050)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  SequenceSignature;                                 // 0x00A0(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneEvaluationTemplateSerialNumber TemplateSerialNumber;                           // 0x00B0(0x0004)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_B4[0x4];                                       // 0x00B4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneTemplateGenerationLedger    TemplateLedger;                                    // 0x00B8(0x00A8)(NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneEvaluationTemplate) == 0x000008, "Wrong alignment on FMovieSceneEvaluationTemplate");
static_assert(sizeof(FMovieSceneEvaluationTemplate) == 0x000160, "Wrong size on FMovieSceneEvaluationTemplate");
static_assert(offsetof(FMovieSceneEvaluationTemplate, Tracks) == 0x000000, "Member 'FMovieSceneEvaluationTemplate::Tracks' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTemplate, SequenceSignature) == 0x0000A0, "Member 'FMovieSceneEvaluationTemplate::SequenceSignature' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTemplate, TemplateSerialNumber) == 0x0000B0, "Member 'FMovieSceneEvaluationTemplate::TemplateSerialNumber' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationTemplate, TemplateLedger) == 0x0000B8, "Member 'FMovieSceneEvaluationTemplate::TemplateLedger' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvalTemplate
// 0x0010 (0x0020 - 0x0010)
struct FMovieSceneEvalTemplate : public FMovieSceneEvalTemplateBase
{
public:
	EMovieSceneCompletionMode                     CompletionMode;                                    // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TWeakObjectPtr<class UMovieSceneSection>      SourceSectionPtr;                                  // 0x0014(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, Protected, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvalTemplate) == 0x000008, "Wrong alignment on FMovieSceneEvalTemplate");
static_assert(sizeof(FMovieSceneEvalTemplate) == 0x000020, "Wrong size on FMovieSceneEvalTemplate");
static_assert(offsetof(FMovieSceneEvalTemplate, CompletionMode) == 0x000010, "Member 'FMovieSceneEvalTemplate::CompletionMode' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvalTemplate, SourceSectionPtr) == 0x000014, "Member 'FMovieSceneEvalTemplate::SourceSectionPtr' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneRootEvaluationTemplateInstance
// 0x00E8 (0x00E8 - 0x0000)
struct FMovieSceneRootEvaluationTemplateInstance final
{
public:
	TWeakObjectPtr<class UMovieSceneSequence>     WeakRootSequence;                                  // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UMovieSceneCompiledDataManager*         CompiledDataManager;                               // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_10[0x8];                                       // 0x0010(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UMovieSceneEntitySystemLinker*          EntitySystemLinker;                                // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_20[0x70];                                      // 0x0020(0x0070)(Fixing Size After Last Property [ Dumper-7 ])
	TMap<struct FMovieSceneSequenceID, class UObject*> DirectorInstances;                            // 0x0090(0x0050)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_E0[0x8];                                       // 0x00E0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneRootEvaluationTemplateInstance) == 0x000008, "Wrong alignment on FMovieSceneRootEvaluationTemplateInstance");
static_assert(sizeof(FMovieSceneRootEvaluationTemplateInstance) == 0x0000E8, "Wrong size on FMovieSceneRootEvaluationTemplateInstance");
static_assert(offsetof(FMovieSceneRootEvaluationTemplateInstance, WeakRootSequence) == 0x000000, "Member 'FMovieSceneRootEvaluationTemplateInstance::WeakRootSequence' has a wrong offset!");
static_assert(offsetof(FMovieSceneRootEvaluationTemplateInstance, CompiledDataManager) == 0x000008, "Member 'FMovieSceneRootEvaluationTemplateInstance::CompiledDataManager' has a wrong offset!");
static_assert(offsetof(FMovieSceneRootEvaluationTemplateInstance, EntitySystemLinker) == 0x000018, "Member 'FMovieSceneRootEvaluationTemplateInstance::EntitySystemLinker' has a wrong offset!");
static_assert(offsetof(FMovieSceneRootEvaluationTemplateInstance, DirectorInstances) == 0x000090, "Member 'FMovieSceneRootEvaluationTemplateInstance::DirectorInstances' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTangentData
// 0x0014 (0x0014 - 0x0000)
struct FMovieSceneTangentData final
{
public:
	float                                         ArriveTangent;                                     // 0x0000(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LeaveTangent;                                      // 0x0004(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         ArriveTangentWeight;                               // 0x0008(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         LeaveTangentWeight;                                // 0x000C(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERichCurveTangentWeightMode                   TangentWeightMode;                                 // 0x0010(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneTangentData) == 0x000004, "Wrong alignment on FMovieSceneTangentData");
static_assert(sizeof(FMovieSceneTangentData) == 0x000014, "Wrong size on FMovieSceneTangentData");
static_assert(offsetof(FMovieSceneTangentData, ArriveTangent) == 0x000000, "Member 'FMovieSceneTangentData::ArriveTangent' has a wrong offset!");
static_assert(offsetof(FMovieSceneTangentData, LeaveTangent) == 0x000004, "Member 'FMovieSceneTangentData::LeaveTangent' has a wrong offset!");
static_assert(offsetof(FMovieSceneTangentData, ArriveTangentWeight) == 0x000008, "Member 'FMovieSceneTangentData::ArriveTangentWeight' has a wrong offset!");
static_assert(offsetof(FMovieSceneTangentData, LeaveTangentWeight) == 0x00000C, "Member 'FMovieSceneTangentData::LeaveTangentWeight' has a wrong offset!");
static_assert(offsetof(FMovieSceneTangentData, TangentWeightMode) == 0x000010, "Member 'FMovieSceneTangentData::TangentWeightMode' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneFloatValue
// 0x001C (0x001C - 0x0000)
struct FMovieSceneFloatValue final
{
public:
	float                                         Value;                                             // 0x0000(0x0004)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneTangentData                 Tangent;                                           // 0x0004(0x0014)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	ERichCurveInterpMode                          InterpMode;                                        // 0x0018(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERichCurveTangentMode                         TangentMode;                                       // 0x0019(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         PaddingByte;                                       // 0x001A(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B[0x1];                                       // 0x001B(0x0001)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneFloatValue) == 0x000004, "Wrong alignment on FMovieSceneFloatValue");
static_assert(sizeof(FMovieSceneFloatValue) == 0x00001C, "Wrong size on FMovieSceneFloatValue");
static_assert(offsetof(FMovieSceneFloatValue, Value) == 0x000000, "Member 'FMovieSceneFloatValue::Value' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatValue, Tangent) == 0x000004, "Member 'FMovieSceneFloatValue::Tangent' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatValue, InterpMode) == 0x000018, "Member 'FMovieSceneFloatValue::InterpMode' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatValue, TangentMode) == 0x000019, "Member 'FMovieSceneFloatValue::TangentMode' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatValue, PaddingByte) == 0x00001A, "Member 'FMovieSceneFloatValue::PaddingByte' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneKeyHandleMap
// 0x0000 (0x0060 - 0x0060)
struct FMovieSceneKeyHandleMap final : public FKeyHandleLookupTable
{
};
static_assert(alignof(FMovieSceneKeyHandleMap) == 0x000008, "Wrong alignment on FMovieSceneKeyHandleMap");
static_assert(sizeof(FMovieSceneKeyHandleMap) == 0x000060, "Wrong size on FMovieSceneKeyHandleMap");

// ScriptStruct MovieScene.MovieSceneFloatChannel
// 0x0098 (0x00A0 - 0x0008)
struct FMovieSceneFloatChannel final : public FMovieSceneChannel
{
public:
	ERichCurveExtrapolation                       PreInfinityExtrap;                                 // 0x0008(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ERichCurveExtrapolation                       PostInfinityExtrap;                                // 0x0009(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A[0x6];                                        // 0x000A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FFrameNumber>                   Times;                                             // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneFloatValue>          Values;                                            // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	float                                         DefaultValue;                                      // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bHasDefaultValue;                                  // 0x0034(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_35[0x3];                                       // 0x0035(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneKeyHandleMap                KeyHandles;                                        // 0x0038(0x0060)(Transient, NativeAccessSpecifierPrivate)
	struct FFrameRate                             TickResolution;                                    // 0x0098(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneFloatChannel) == 0x000008, "Wrong alignment on FMovieSceneFloatChannel");
static_assert(sizeof(FMovieSceneFloatChannel) == 0x0000A0, "Wrong size on FMovieSceneFloatChannel");
static_assert(offsetof(FMovieSceneFloatChannel, PreInfinityExtrap) == 0x000008, "Member 'FMovieSceneFloatChannel::PreInfinityExtrap' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, PostInfinityExtrap) == 0x000009, "Member 'FMovieSceneFloatChannel::PostInfinityExtrap' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, Times) == 0x000010, "Member 'FMovieSceneFloatChannel::Times' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, Values) == 0x000020, "Member 'FMovieSceneFloatChannel::Values' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, DefaultValue) == 0x000030, "Member 'FMovieSceneFloatChannel::DefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, bHasDefaultValue) == 0x000034, "Member 'FMovieSceneFloatChannel::bHasDefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, KeyHandles) == 0x000038, "Member 'FMovieSceneFloatChannel::KeyHandles' has a wrong offset!");
static_assert(offsetof(FMovieSceneFloatChannel, TickResolution) == 0x000098, "Member 'FMovieSceneFloatChannel::TickResolution' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldEntityMetaData
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneEvaluationFieldEntityMetaData final
{
public:
	class FString                                 OverrideBoundPropertyPath;                         // 0x0000(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ForcedTime;                                        // 0x0010(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	ESectionEvaluationFlags                       Flags;                                             // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bEvaluateInSequencePreRoll : 1;                    // 0x0019(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateInSequencePostRoll : 1;                   // 0x0019(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationFieldEntityMetaData) == 0x000008, "Wrong alignment on FMovieSceneEvaluationFieldEntityMetaData");
static_assert(sizeof(FMovieSceneEvaluationFieldEntityMetaData) == 0x000020, "Wrong size on FMovieSceneEvaluationFieldEntityMetaData");
static_assert(offsetof(FMovieSceneEvaluationFieldEntityMetaData, OverrideBoundPropertyPath) == 0x000000, "Member 'FMovieSceneEvaluationFieldEntityMetaData::OverrideBoundPropertyPath' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationFieldEntityMetaData, ForcedTime) == 0x000010, "Member 'FMovieSceneEvaluationFieldEntityMetaData::ForcedTime' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationFieldEntityMetaData, Flags) == 0x000018, "Member 'FMovieSceneEvaluationFieldEntityMetaData::Flags' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldEntityKey
// 0x000C (0x000C - 0x0000)
struct FMovieSceneEvaluationFieldEntityKey final
{
public:
	TWeakObjectPtr<class UObject>                 EntityOwner;                                       // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        EntityID;                                          // 0x0008(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationFieldEntityKey) == 0x000004, "Wrong alignment on FMovieSceneEvaluationFieldEntityKey");
static_assert(sizeof(FMovieSceneEvaluationFieldEntityKey) == 0x00000C, "Wrong size on FMovieSceneEvaluationFieldEntityKey");
static_assert(offsetof(FMovieSceneEvaluationFieldEntityKey, EntityOwner) == 0x000000, "Member 'FMovieSceneEvaluationFieldEntityKey::EntityOwner' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationFieldEntityKey, EntityID) == 0x000008, "Member 'FMovieSceneEvaluationFieldEntityKey::EntityID' has a wrong offset!");

// ScriptStruct MovieScene.MovieScenePossessable
// 0x0048 (0x0048 - 0x0000)
struct FMovieScenePossessable final
{
public:
	TArray<class FName>                           Tags;                                              // 0x0000(0x0010)(Edit, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	struct FGuid                                  Guid;                                              // 0x0010(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FString                                 Name;                                              // 0x0020(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UClass*                                 PossessedObjectClass;                              // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FGuid                                  ParentGuid;                                        // 0x0038(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieScenePossessable) == 0x000008, "Wrong alignment on FMovieScenePossessable");
static_assert(sizeof(FMovieScenePossessable) == 0x000048, "Wrong size on FMovieScenePossessable");
static_assert(offsetof(FMovieScenePossessable, Tags) == 0x000000, "Member 'FMovieScenePossessable::Tags' has a wrong offset!");
static_assert(offsetof(FMovieScenePossessable, Guid) == 0x000010, "Member 'FMovieScenePossessable::Guid' has a wrong offset!");
static_assert(offsetof(FMovieScenePossessable, Name) == 0x000020, "Member 'FMovieScenePossessable::Name' has a wrong offset!");
static_assert(offsetof(FMovieScenePossessable, PossessedObjectClass) == 0x000030, "Member 'FMovieScenePossessable::PossessedObjectClass' has a wrong offset!");
static_assert(offsetof(FMovieScenePossessable, ParentGuid) == 0x000038, "Member 'FMovieScenePossessable::ParentGuid' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationInstanceKey
// 0x0004 (0x0004 - 0x0000)
struct alignas(0x02) FMovieSceneEvaluationInstanceKey final
{
public:
	uint8                                         Pad_0[0x4];                                        // 0x0000(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationInstanceKey) == 0x000002, "Wrong alignment on FMovieSceneEvaluationInstanceKey");
static_assert(sizeof(FMovieSceneEvaluationInstanceKey) == 0x000004, "Wrong size on FMovieSceneEvaluationInstanceKey");

// ScriptStruct MovieScene.MovieSceneSegment
// 0x0058 (0x0058 - 0x0000)
struct alignas(0x08) FMovieSceneSegment final
{
public:
	uint8                                         Pad_0[0x58];                                       // 0x0000(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSegment) == 0x000008, "Wrong alignment on FMovieSceneSegment");
static_assert(sizeof(FMovieSceneSegment) == 0x000058, "Wrong size on FMovieSceneSegment");

// ScriptStruct MovieScene.MovieSceneIntegerChannel
// 0x0088 (0x0090 - 0x0008)
struct FMovieSceneIntegerChannel final : public FMovieSceneChannel
{
public:
	TArray<struct FFrameNumber>                   Times;                                             // 0x0008(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	int32                                         DefaultValue;                                      // 0x0018(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bHasDefaultValue;                                  // 0x001C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1D[0x3];                                       // 0x001D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<int32>                                 Values;                                            // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_30[0x60];                                      // 0x0030(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneIntegerChannel) == 0x000008, "Wrong alignment on FMovieSceneIntegerChannel");
static_assert(sizeof(FMovieSceneIntegerChannel) == 0x000090, "Wrong size on FMovieSceneIntegerChannel");
static_assert(offsetof(FMovieSceneIntegerChannel, Times) == 0x000008, "Member 'FMovieSceneIntegerChannel::Times' has a wrong offset!");
static_assert(offsetof(FMovieSceneIntegerChannel, DefaultValue) == 0x000018, "Member 'FMovieSceneIntegerChannel::DefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneIntegerChannel, bHasDefaultValue) == 0x00001C, "Member 'FMovieSceneIntegerChannel::bHasDefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneIntegerChannel, Values) == 0x000020, "Member 'FMovieSceneIntegerChannel::Values' has a wrong offset!");

// ScriptStruct MovieScene.SectionEvaluationData
// 0x000C (0x000C - 0x0000)
struct FSectionEvaluationData final
{
public:
	int32                                         ImplIndex;                                         // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ForcedTime;                                        // 0x0004(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESectionEvaluationFlags                       Flags;                                             // 0x0008(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FSectionEvaluationData) == 0x000004, "Wrong alignment on FSectionEvaluationData");
static_assert(sizeof(FSectionEvaluationData) == 0x00000C, "Wrong size on FSectionEvaluationData");
static_assert(offsetof(FSectionEvaluationData, ImplIndex) == 0x000000, "Member 'FSectionEvaluationData::ImplIndex' has a wrong offset!");
static_assert(offsetof(FSectionEvaluationData, ForcedTime) == 0x000004, "Member 'FSectionEvaluationData::ForcedTime' has a wrong offset!");
static_assert(offsetof(FSectionEvaluationData, Flags) == 0x000008, "Member 'FSectionEvaluationData::Flags' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackImplementation
// 0x0000 (0x0010 - 0x0010)
struct FMovieSceneTrackImplementation : public FMovieSceneEvalTemplateBase
{
};
static_assert(alignof(FMovieSceneTrackImplementation) == 0x000008, "Wrong alignment on FMovieSceneTrackImplementation");
static_assert(sizeof(FMovieSceneTrackImplementation) == 0x000010, "Wrong size on FMovieSceneTrackImplementation");

// ScriptStruct MovieScene.MovieSceneEvaluationKey
// 0x000C (0x000C - 0x0000)
struct FMovieSceneEvaluationKey final
{
public:
	struct FMovieSceneSequenceID                  SequenceID;                                        // 0x0000(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneTrackIdentifier             TrackIdentifier;                                   // 0x0004(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        SectionIndex;                                      // 0x0008(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationKey) == 0x000004, "Wrong alignment on FMovieSceneEvaluationKey");
static_assert(sizeof(FMovieSceneEvaluationKey) == 0x00000C, "Wrong size on FMovieSceneEvaluationKey");
static_assert(offsetof(FMovieSceneEvaluationKey, SequenceID) == 0x000000, "Member 'FMovieSceneEvaluationKey::SequenceID' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationKey, TrackIdentifier) == 0x000004, "Member 'FMovieSceneEvaluationKey::TrackIdentifier' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationKey, SectionIndex) == 0x000008, "Member 'FMovieSceneEvaluationKey::SectionIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieScenePropertySectionData
// 0x0018 (0x0018 - 0x0000)
struct FMovieScenePropertySectionData final
{
public:
	class FName                                   PropertyName;                                      // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FString                                 PropertyPath;                                      // 0x0008(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieScenePropertySectionData) == 0x000008, "Wrong alignment on FMovieScenePropertySectionData");
static_assert(sizeof(FMovieScenePropertySectionData) == 0x000018, "Wrong size on FMovieScenePropertySectionData");
static_assert(offsetof(FMovieScenePropertySectionData, PropertyName) == 0x000000, "Member 'FMovieScenePropertySectionData::PropertyName' has a wrong offset!");
static_assert(offsetof(FMovieScenePropertySectionData, PropertyPath) == 0x000008, "Member 'FMovieScenePropertySectionData::PropertyPath' has a wrong offset!");

// ScriptStruct MovieScene.MovieScenePropertyBinding
// 0x0014 (0x0014 - 0x0000)
struct FMovieScenePropertyBinding final
{
public:
	class FName                                   PropertyName;                                      // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   PropertyPath;                                      // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCanUseClassLookup;                                // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieScenePropertyBinding) == 0x000004, "Wrong alignment on FMovieScenePropertyBinding");
static_assert(sizeof(FMovieScenePropertyBinding) == 0x000014, "Wrong size on FMovieScenePropertyBinding");
static_assert(offsetof(FMovieScenePropertyBinding, PropertyName) == 0x000000, "Member 'FMovieScenePropertyBinding::PropertyName' has a wrong offset!");
static_assert(offsetof(FMovieScenePropertyBinding, PropertyPath) == 0x000008, "Member 'FMovieScenePropertyBinding::PropertyPath' has a wrong offset!");
static_assert(offsetof(FMovieScenePropertyBinding, bCanUseClassLookup) == 0x000010, "Member 'FMovieScenePropertyBinding::bCanUseClassLookup' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceInstanceData
// 0x0008 (0x0008 - 0x0000)
struct alignas(0x08) FMovieSceneSequenceInstanceData
{
public:
	uint8                                         Pad_0[0x8];                                        // 0x0000(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSequenceInstanceData) == 0x000008, "Wrong alignment on FMovieSceneSequenceInstanceData");
static_assert(sizeof(FMovieSceneSequenceInstanceData) == 0x000008, "Wrong size on FMovieSceneSequenceInstanceData");

// ScriptStruct MovieScene.MovieSceneEvaluationOperand
// 0x0014 (0x0014 - 0x0000)
struct FMovieSceneEvaluationOperand final
{
public:
	struct FGuid                                  ObjectBindingID;                                   // 0x0000(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneSequenceID                  SequenceID;                                        // 0x0010(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationOperand) == 0x000004, "Wrong alignment on FMovieSceneEvaluationOperand");
static_assert(sizeof(FMovieSceneEvaluationOperand) == 0x000014, "Wrong size on FMovieSceneEvaluationOperand");
static_assert(offsetof(FMovieSceneEvaluationOperand, ObjectBindingID) == 0x000000, "Member 'FMovieSceneEvaluationOperand::ObjectBindingID' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationOperand, SequenceID) == 0x000010, "Member 'FMovieSceneEvaluationOperand::SequenceID' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneOrderedEvaluationKey
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneOrderedEvaluationKey final
{
public:
	struct FMovieSceneEvaluationKey               Key;                                               // 0x0000(0x000C)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        SetupIndex;                                        // 0x000C(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        TearDownIndex;                                     // 0x000E(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneOrderedEvaluationKey) == 0x000004, "Wrong alignment on FMovieSceneOrderedEvaluationKey");
static_assert(sizeof(FMovieSceneOrderedEvaluationKey) == 0x000010, "Wrong size on FMovieSceneOrderedEvaluationKey");
static_assert(offsetof(FMovieSceneOrderedEvaluationKey, Key) == 0x000000, "Member 'FMovieSceneOrderedEvaluationKey::Key' has a wrong offset!");
static_assert(offsetof(FMovieSceneOrderedEvaluationKey, SetupIndex) == 0x00000C, "Member 'FMovieSceneOrderedEvaluationKey::SetupIndex' has a wrong offset!");
static_assert(offsetof(FMovieSceneOrderedEvaluationKey, TearDownIndex) == 0x00000E, "Member 'FMovieSceneOrderedEvaluationKey::TearDownIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationMetaData
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneEvaluationMetaData final
{
public:
	TArray<struct FMovieSceneSequenceID>          ActiveSequences;                                   // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	TArray<struct FMovieSceneOrderedEvaluationKey> ActiveEntities;                                   // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationMetaData) == 0x000008, "Wrong alignment on FMovieSceneEvaluationMetaData");
static_assert(sizeof(FMovieSceneEvaluationMetaData) == 0x000020, "Wrong size on FMovieSceneEvaluationMetaData");
static_assert(offsetof(FMovieSceneEvaluationMetaData, ActiveSequences) == 0x000000, "Member 'FMovieSceneEvaluationMetaData::ActiveSequences' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationMetaData, ActiveEntities) == 0x000010, "Member 'FMovieSceneEvaluationMetaData::ActiveEntities' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneExpansionState
// 0x0001 (0x0001 - 0x0000)
struct FMovieSceneExpansionState final
{
public:
	bool                                          bExpanded;                                         // 0x0000(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneExpansionState) == 0x000001, "Wrong alignment on FMovieSceneExpansionState");
static_assert(sizeof(FMovieSceneExpansionState) == 0x000001, "Wrong size on FMovieSceneExpansionState");
static_assert(offsetof(FMovieSceneExpansionState, bExpanded) == 0x000000, "Member 'FMovieSceneExpansionState::bExpanded' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneByteChannel
// 0x0090 (0x0098 - 0x0008)
struct FMovieSceneByteChannel : public FMovieSceneChannel
{
public:
	TArray<struct FFrameNumber>                   Times;                                             // 0x0008(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	uint8                                         DefaultValue;                                      // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bHasDefaultValue;                                  // 0x0019(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<uint8>                                 Values;                                            // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	class UEnum*                                  Enum;                                              // 0x0030(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_38[0x60];                                      // 0x0038(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneByteChannel) == 0x000008, "Wrong alignment on FMovieSceneByteChannel");
static_assert(sizeof(FMovieSceneByteChannel) == 0x000098, "Wrong size on FMovieSceneByteChannel");
static_assert(offsetof(FMovieSceneByteChannel, Times) == 0x000008, "Member 'FMovieSceneByteChannel::Times' has a wrong offset!");
static_assert(offsetof(FMovieSceneByteChannel, DefaultValue) == 0x000018, "Member 'FMovieSceneByteChannel::DefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneByteChannel, bHasDefaultValue) == 0x000019, "Member 'FMovieSceneByteChannel::bHasDefaultValue' has a wrong offset!");
static_assert(offsetof(FMovieSceneByteChannel, Values) == 0x000020, "Member 'FMovieSceneByteChannel::Values' has a wrong offset!");
static_assert(offsetof(FMovieSceneByteChannel, Enum) == 0x000030, "Member 'FMovieSceneByteChannel::Enum' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneObjectBindingID
// 0x0018 (0x0018 - 0x0000)
struct FMovieSceneObjectBindingID final
{
public:
	struct FGuid                                  Guid;                                              // 0x0000(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         SequenceID;                                        // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	int32                                         ResolveParentIndex;                                // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneObjectBindingID) == 0x000004, "Wrong alignment on FMovieSceneObjectBindingID");
static_assert(sizeof(FMovieSceneObjectBindingID) == 0x000018, "Wrong size on FMovieSceneObjectBindingID");
static_assert(offsetof(FMovieSceneObjectBindingID, Guid) == 0x000000, "Member 'FMovieSceneObjectBindingID::Guid' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectBindingID, SequenceID) == 0x000010, "Member 'FMovieSceneObjectBindingID::SequenceID' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectBindingID, ResolveParentIndex) == 0x000014, "Member 'FMovieSceneObjectBindingID::ResolveParentIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneMarkedFrame
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneMarkedFrame final
{
public:
	struct FFrameNumber                           FrameNumber;                                       // 0x0000(0x0004)(Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 Label;                                             // 0x0008(0x0010)(Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsDeterminismFence;                               // 0x0018(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneMarkedFrame) == 0x000008, "Wrong alignment on FMovieSceneMarkedFrame");
static_assert(sizeof(FMovieSceneMarkedFrame) == 0x000020, "Wrong size on FMovieSceneMarkedFrame");
static_assert(offsetof(FMovieSceneMarkedFrame, FrameNumber) == 0x000000, "Member 'FMovieSceneMarkedFrame::FrameNumber' has a wrong offset!");
static_assert(offsetof(FMovieSceneMarkedFrame, Label) == 0x000008, "Member 'FMovieSceneMarkedFrame::Label' has a wrong offset!");
static_assert(offsetof(FMovieSceneMarkedFrame, bIsDeterminismFence) == 0x000018, "Member 'FMovieSceneMarkedFrame::bIsDeterminismFence' has a wrong offset!");

// ScriptStruct MovieScene.MovieScenePropertySectionTemplate
// 0x0018 (0x0038 - 0x0020)
struct FMovieScenePropertySectionTemplate : public FMovieSceneEvalTemplate
{
public:
	struct FMovieScenePropertySectionData         PropertyData;                                      // 0x0020(0x0018)(Protected, NativeAccessSpecifierProtected)
};
static_assert(alignof(FMovieScenePropertySectionTemplate) == 0x000008, "Wrong alignment on FMovieScenePropertySectionTemplate");
static_assert(sizeof(FMovieScenePropertySectionTemplate) == 0x000038, "Wrong size on FMovieScenePropertySectionTemplate");
static_assert(offsetof(FMovieScenePropertySectionTemplate, PropertyData) == 0x000020, "Member 'FMovieScenePropertySectionTemplate::PropertyData' has a wrong offset!");

// ScriptStruct MovieScene.TrackInstanceInputComponent
// 0x0010 (0x0010 - 0x0000)
struct FTrackInstanceInputComponent final
{
public:
	class UMovieSceneSection*                     Section;                                           // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         OutputIndex;                                       // 0x0008(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FTrackInstanceInputComponent) == 0x000008, "Wrong alignment on FTrackInstanceInputComponent");
static_assert(sizeof(FTrackInstanceInputComponent) == 0x000010, "Wrong size on FTrackInstanceInputComponent");
static_assert(offsetof(FTrackInstanceInputComponent, Section) == 0x000000, "Member 'FTrackInstanceInputComponent::Section' has a wrong offset!");
static_assert(offsetof(FTrackInstanceInputComponent, OutputIndex) == 0x000008, "Member 'FTrackInstanceInputComponent::OutputIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationHookComponent
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneEvaluationHookComponent final
{
public:
	TScriptInterface<class IMovieSceneEvaluationHook> Interface;                                     // 0x0000(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	uint8                                         Pad_10[0x10];                                      // 0x0010(0x0010)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationHookComponent) == 0x000008, "Wrong alignment on FMovieSceneEvaluationHookComponent");
static_assert(sizeof(FMovieSceneEvaluationHookComponent) == 0x000020, "Wrong size on FMovieSceneEvaluationHookComponent");
static_assert(offsetof(FMovieSceneEvaluationHookComponent, Interface) == 0x000000, "Member 'FMovieSceneEvaluationHookComponent::Interface' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackInstanceComponent
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneTrackInstanceComponent final
{
public:
	class UMovieSceneSection*                     Owner;                                             // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UMovieSceneTrackInstance>   TrackInstanceClass;                                // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTrackInstanceComponent) == 0x000008, "Wrong alignment on FMovieSceneTrackInstanceComponent");
static_assert(sizeof(FMovieSceneTrackInstanceComponent) == 0x000010, "Wrong size on FMovieSceneTrackInstanceComponent");
static_assert(offsetof(FMovieSceneTrackInstanceComponent, Owner) == 0x000000, "Member 'FMovieSceneTrackInstanceComponent::Owner' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackInstanceComponent, TrackInstanceClass) == 0x000008, "Member 'FMovieSceneTrackInstanceComponent::TrackInstanceClass' has a wrong offset!");

// ScriptStruct MovieScene.EasingComponentData
// 0x0008 (0x0008 - 0x0000)
struct FEasingComponentData final
{
public:
	class UMovieSceneSection*                     Section;                                           // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FEasingComponentData) == 0x000008, "Wrong alignment on FEasingComponentData");
static_assert(sizeof(FEasingComponentData) == 0x000008, "Wrong size on FEasingComponentData");
static_assert(offsetof(FEasingComponentData, Section) == 0x000000, "Member 'FEasingComponentData::Section' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneDeterminismData
// 0x0018 (0x0018 - 0x0000)
struct FMovieSceneDeterminismData final
{
public:
	TArray<struct FFrameTime>                     Fences;                                            // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	bool                                          bParentSequenceRequiresLowerFence;                 // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bParentSequenceRequiresUpperFence;                 // 0x0011(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12[0x6];                                       // 0x0012(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneDeterminismData) == 0x000008, "Wrong alignment on FMovieSceneDeterminismData");
static_assert(sizeof(FMovieSceneDeterminismData) == 0x000018, "Wrong size on FMovieSceneDeterminismData");
static_assert(offsetof(FMovieSceneDeterminismData, Fences) == 0x000000, "Member 'FMovieSceneDeterminismData::Fences' has a wrong offset!");
static_assert(offsetof(FMovieSceneDeterminismData, bParentSequenceRequiresLowerFence) == 0x000010, "Member 'FMovieSceneDeterminismData::bParentSequenceRequiresLowerFence' has a wrong offset!");
static_assert(offsetof(FMovieSceneDeterminismData, bParentSequenceRequiresUpperFence) == 0x000011, "Member 'FMovieSceneDeterminismData::bParentSequenceRequiresUpperFence' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSectionGroup
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneSectionGroup final
{
public:
	TArray<TWeakObjectPtr<class UMovieSceneSection>> Sections;                                       // 0x0000(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, UObjectWrapper, NativeAccessSpecifierProtected)
};
static_assert(alignof(FMovieSceneSectionGroup) == 0x000008, "Wrong alignment on FMovieSceneSectionGroup");
static_assert(sizeof(FMovieSceneSectionGroup) == 0x000010, "Wrong size on FMovieSceneSectionGroup");
static_assert(offsetof(FMovieSceneSectionGroup, Sections) == 0x000000, "Member 'FMovieSceneSectionGroup::Sections' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneObjectBindingIDs
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneObjectBindingIDs final
{
public:
	TArray<struct FMovieSceneObjectBindingID>     IDs;                                               // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneObjectBindingIDs) == 0x000008, "Wrong alignment on FMovieSceneObjectBindingIDs");
static_assert(sizeof(FMovieSceneObjectBindingIDs) == 0x000010, "Wrong size on FMovieSceneObjectBindingIDs");
static_assert(offsetof(FMovieSceneObjectBindingIDs, IDs) == 0x000000, "Member 'FMovieSceneObjectBindingIDs::IDs' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackLabels
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneTrackLabels final
{
public:
	TArray<class FString>                         Strings;                                           // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTrackLabels) == 0x000008, "Wrong alignment on FMovieSceneTrackLabels");
static_assert(sizeof(FMovieSceneTrackLabels) == 0x000010, "Wrong size on FMovieSceneTrackLabels");
static_assert(offsetof(FMovieSceneTrackLabels, Strings) == 0x000000, "Member 'FMovieSceneTrackLabels::Strings' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEditorData
// 0x00F0 (0x00F0 - 0x0000)
struct FMovieSceneEditorData final
{
public:
	TMap<class FString, struct FMovieSceneExpansionState> ExpansionStates;                           // 0x0000(0x0050)(NativeAccessSpecifierPublic)
	TArray<class FString>                         PinnedNodes;                                       // 0x0050(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
	double                                        ViewStart;                                         // 0x0060(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	double                                        ViewEnd;                                           // 0x0068(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	double                                        WorkStart;                                         // 0x0070(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	double                                        WorkEnd;                                           // 0x0078(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSet<struct FFrameNumber>                     MarkedFrames;                                      // 0x0080(0x0050)(Deprecated, NativeAccessSpecifierPublic)
	struct FFloatRange                            WorkingRange;                                      // 0x00D0(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFloatRange                            ViewRange;                                         // 0x00E0(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEditorData) == 0x000008, "Wrong alignment on FMovieSceneEditorData");
static_assert(sizeof(FMovieSceneEditorData) == 0x0000F0, "Wrong size on FMovieSceneEditorData");
static_assert(offsetof(FMovieSceneEditorData, ExpansionStates) == 0x000000, "Member 'FMovieSceneEditorData::ExpansionStates' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, PinnedNodes) == 0x000050, "Member 'FMovieSceneEditorData::PinnedNodes' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, ViewStart) == 0x000060, "Member 'FMovieSceneEditorData::ViewStart' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, ViewEnd) == 0x000068, "Member 'FMovieSceneEditorData::ViewEnd' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, WorkStart) == 0x000070, "Member 'FMovieSceneEditorData::WorkStart' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, WorkEnd) == 0x000078, "Member 'FMovieSceneEditorData::WorkEnd' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, MarkedFrames) == 0x000080, "Member 'FMovieSceneEditorData::MarkedFrames' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, WorkingRange) == 0x0000D0, "Member 'FMovieSceneEditorData::WorkingRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneEditorData, ViewRange) == 0x0000E0, "Member 'FMovieSceneEditorData::ViewRange' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTimecodeSource
// 0x0018 (0x0018 - 0x0000)
struct FMovieSceneTimecodeSource final
{
public:
	struct FTimecode                              Timecode;                                          // 0x0000(0x0014)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           DeltaFrame;                                        // 0x0014(0x0004)(Edit, EditConst, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTimecodeSource) == 0x000004, "Wrong alignment on FMovieSceneTimecodeSource");
static_assert(sizeof(FMovieSceneTimecodeSource) == 0x000018, "Wrong size on FMovieSceneTimecodeSource");
static_assert(offsetof(FMovieSceneTimecodeSource, Timecode) == 0x000000, "Member 'FMovieSceneTimecodeSource::Timecode' has a wrong offset!");
static_assert(offsetof(FMovieSceneTimecodeSource, DeltaFrame) == 0x000014, "Member 'FMovieSceneTimecodeSource::DeltaFrame' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneBinding
// 0x0030 (0x0030 - 0x0000)
struct FMovieSceneBinding final
{
public:
	struct FGuid                                  ObjectGuid;                                        // 0x0000(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FString                                 BindingName;                                       // 0x0010(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<class UMovieSceneTrack*>               Tracks;                                            // 0x0020(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneBinding) == 0x000008, "Wrong alignment on FMovieSceneBinding");
static_assert(sizeof(FMovieSceneBinding) == 0x000030, "Wrong size on FMovieSceneBinding");
static_assert(offsetof(FMovieSceneBinding, ObjectGuid) == 0x000000, "Member 'FMovieSceneBinding::ObjectGuid' has a wrong offset!");
static_assert(offsetof(FMovieSceneBinding, BindingName) == 0x000010, "Member 'FMovieSceneBinding::BindingName' has a wrong offset!");
static_assert(offsetof(FMovieSceneBinding, Tracks) == 0x000020, "Member 'FMovieSceneBinding::Tracks' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneBindingOverrideData
// 0x0024 (0x0024 - 0x0000)
struct FMovieSceneBindingOverrideData final
{
public:
	struct FMovieSceneObjectBindingID             ObjectBindingID;                                   // 0x0000(0x0018)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TWeakObjectPtr<class UObject>                 Object;                                            // 0x0018(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bOverridesDefault;                                 // 0x0020(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x3];                                       // 0x0021(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneBindingOverrideData) == 0x000004, "Wrong alignment on FMovieSceneBindingOverrideData");
static_assert(sizeof(FMovieSceneBindingOverrideData) == 0x000024, "Wrong size on FMovieSceneBindingOverrideData");
static_assert(offsetof(FMovieSceneBindingOverrideData, ObjectBindingID) == 0x000000, "Member 'FMovieSceneBindingOverrideData::ObjectBindingID' has a wrong offset!");
static_assert(offsetof(FMovieSceneBindingOverrideData, Object) == 0x000018, "Member 'FMovieSceneBindingOverrideData::Object' has a wrong offset!");
static_assert(offsetof(FMovieSceneBindingOverrideData, bOverridesDefault) == 0x000020, "Member 'FMovieSceneBindingOverrideData::bOverridesDefault' has a wrong offset!");

// ScriptStruct MovieScene.OptionalMovieSceneBlendType
// 0x0002 (0x0002 - 0x0000)
struct FOptionalMovieSceneBlendType final
{
public:
	EMovieSceneBlendType                          BlendType;                                         // 0x0000(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsValid;                                          // 0x0001(0x0001)(BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FOptionalMovieSceneBlendType) == 0x000001, "Wrong alignment on FOptionalMovieSceneBlendType");
static_assert(sizeof(FOptionalMovieSceneBlendType) == 0x000002, "Wrong size on FOptionalMovieSceneBlendType");
static_assert(offsetof(FOptionalMovieSceneBlendType, BlendType) == 0x000000, "Member 'FOptionalMovieSceneBlendType::BlendType' has a wrong offset!");
static_assert(offsetof(FOptionalMovieSceneBlendType, bIsValid) == 0x000001, "Member 'FOptionalMovieSceneBlendType::bIsValid' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneCompiledSequenceFlagStruct
// 0x0001 (0x0001 - 0x0000)
struct FMovieSceneCompiledSequenceFlagStruct final
{
public:
	uint8                                         bParentSequenceRequiresLowerFence : 1;             // 0x0000(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bParentSequenceRequiresUpperFence : 1;             // 0x0000(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
};
static_assert(alignof(FMovieSceneCompiledSequenceFlagStruct) == 0x000001, "Wrong alignment on FMovieSceneCompiledSequenceFlagStruct");
static_assert(sizeof(FMovieSceneCompiledSequenceFlagStruct) == 0x000001, "Wrong size on FMovieSceneCompiledSequenceFlagStruct");

// ScriptStruct MovieScene.MovieSceneSequenceCompilerMaskStruct
// 0x0001 (0x0001 - 0x0000)
struct FMovieSceneSequenceCompilerMaskStruct final
{
public:
	uint8                                         bHierarchy : 1;                                    // 0x0000(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluationTemplate : 1;                           // 0x0000(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluationTemplateField : 1;                      // 0x0000(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEntityComponentField : 1;                         // 0x0000(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
};
static_assert(alignof(FMovieSceneSequenceCompilerMaskStruct) == 0x000001, "Wrong alignment on FMovieSceneSequenceCompilerMaskStruct");
static_assert(sizeof(FMovieSceneSequenceCompilerMaskStruct) == 0x000001, "Wrong size on FMovieSceneSequenceCompilerMaskStruct");

// ScriptStruct MovieScene.MovieSceneEntitySystemGraphNodes
// 0x0038 (0x0038 - 0x0000)
struct alignas(0x08) FMovieSceneEntitySystemGraphNodes final
{
public:
	uint8                                         Pad_0[0x38];                                       // 0x0000(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEntitySystemGraphNodes) == 0x000008, "Wrong alignment on FMovieSceneEntitySystemGraphNodes");
static_assert(sizeof(FMovieSceneEntitySystemGraphNodes) == 0x000038, "Wrong size on FMovieSceneEntitySystemGraphNodes");

// ScriptStruct MovieScene.MovieSceneEntitySystemGraph
// 0x0138 (0x0138 - 0x0000)
struct FMovieSceneEntitySystemGraph final
{
public:
	uint8                                         Pad_0[0x80];                                       // 0x0000(0x0080)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneEntitySystemGraphNodes      Nodes;                                             // 0x0080(0x0038)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_B8[0x80];                                      // 0x00B8(0x0080)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEntitySystemGraph) == 0x000008, "Wrong alignment on FMovieSceneEntitySystemGraph");
static_assert(sizeof(FMovieSceneEntitySystemGraph) == 0x000138, "Wrong size on FMovieSceneEntitySystemGraph");
static_assert(offsetof(FMovieSceneEntitySystemGraph, Nodes) == 0x000080, "Member 'FMovieSceneEntitySystemGraph::Nodes' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEntitySystemGraphNode
// 0x0028 (0x0028 - 0x0000)
struct FMovieSceneEntitySystemGraphNode final
{
public:
	uint8                                         Pad_0[0x20];                                       // 0x0000(0x0020)(Fixing Size After Last Property [ Dumper-7 ])
	class UMovieSceneEntitySystem*                System;                                            // 0x0020(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEntitySystemGraphNode) == 0x000008, "Wrong alignment on FMovieSceneEntitySystemGraphNode");
static_assert(sizeof(FMovieSceneEntitySystemGraphNode) == 0x000028, "Wrong size on FMovieSceneEntitySystemGraphNode");
static_assert(offsetof(FMovieSceneEntitySystemGraphNode, System) == 0x000020, "Member 'FMovieSceneEntitySystemGraphNode::System' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEmptyStruct
// 0x0001 (0x0001 - 0x0000)
struct FMovieSceneEmptyStruct final
{
public:
	uint8                                         Pad_0[0x1];                                        // 0x0000(0x0001)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEmptyStruct) == 0x000001, "Wrong alignment on FMovieSceneEmptyStruct");
static_assert(sizeof(FMovieSceneEmptyStruct) == 0x000001, "Wrong size on FMovieSceneEmptyStruct");

// ScriptStruct MovieScene.MovieSceneEvaluationField
// 0x0030 (0x0030 - 0x0000)
struct FMovieSceneEvaluationField final
{
public:
	TArray<struct FMovieSceneFrameRange>          Ranges;                                            // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneEvaluationGroup>     Groups;                                            // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneEvaluationMetaData>  MetaData;                                          // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneEvaluationField) == 0x000008, "Wrong alignment on FMovieSceneEvaluationField");
static_assert(sizeof(FMovieSceneEvaluationField) == 0x000030, "Wrong size on FMovieSceneEvaluationField");
static_assert(offsetof(FMovieSceneEvaluationField, Ranges) == 0x000000, "Member 'FMovieSceneEvaluationField::Ranges' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationField, Groups) == 0x000010, "Member 'FMovieSceneEvaluationField::Groups' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationField, MetaData) == 0x000020, "Member 'FMovieSceneEvaluationField::MetaData' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSegmentIdentifier
// 0x0004 (0x0004 - 0x0000)
struct FMovieSceneSegmentIdentifier final
{
public:
	int32                                         IdentifierIndex;                                   // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSegmentIdentifier) == 0x000004, "Wrong alignment on FMovieSceneSegmentIdentifier");
static_assert(sizeof(FMovieSceneSegmentIdentifier) == 0x000004, "Wrong size on FMovieSceneSegmentIdentifier");
static_assert(offsetof(FMovieSceneSegmentIdentifier, IdentifierIndex) == 0x000000, "Member 'FMovieSceneSegmentIdentifier::IdentifierIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldSegmentPtr
// 0x0004 (0x000C - 0x0008)
struct FMovieSceneEvaluationFieldSegmentPtr final : public FMovieSceneEvaluationFieldTrackPtr
{
public:
	struct FMovieSceneSegmentIdentifier           SegmentID;                                         // 0x0008(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationFieldSegmentPtr) == 0x000004, "Wrong alignment on FMovieSceneEvaluationFieldSegmentPtr");
static_assert(sizeof(FMovieSceneEvaluationFieldSegmentPtr) == 0x00000C, "Wrong size on FMovieSceneEvaluationFieldSegmentPtr");
static_assert(offsetof(FMovieSceneEvaluationFieldSegmentPtr, SegmentID) == 0x000008, "Member 'FMovieSceneEvaluationFieldSegmentPtr::SegmentID' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldEntityTree
// 0x0060 (0x0060 - 0x0000)
struct alignas(0x08) FMovieSceneEvaluationFieldEntityTree final
{
public:
	uint8                                         Pad_0[0x60];                                       // 0x0000(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationFieldEntityTree) == 0x000008, "Wrong alignment on FMovieSceneEvaluationFieldEntityTree");
static_assert(sizeof(FMovieSceneEvaluationFieldEntityTree) == 0x000060, "Wrong size on FMovieSceneEvaluationFieldEntityTree");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldEntity
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneEvaluationFieldEntity final
{
public:
	struct FMovieSceneEvaluationFieldEntityKey    Key;                                               // 0x0000(0x000C)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         SharedMetaDataIndex;                               // 0x000C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationFieldEntity) == 0x000004, "Wrong alignment on FMovieSceneEvaluationFieldEntity");
static_assert(sizeof(FMovieSceneEvaluationFieldEntity) == 0x000010, "Wrong size on FMovieSceneEvaluationFieldEntity");
static_assert(offsetof(FMovieSceneEvaluationFieldEntity, Key) == 0x000000, "Member 'FMovieSceneEvaluationFieldEntity::Key' has a wrong offset!");
static_assert(offsetof(FMovieSceneEvaluationFieldEntity, SharedMetaDataIndex) == 0x00000C, "Member 'FMovieSceneEvaluationFieldEntity::SharedMetaDataIndex' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationFieldSharedEntityMetaData
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneEvaluationFieldSharedEntityMetaData final
{
public:
	struct FGuid                                  ObjectBindingID;                                   // 0x0000(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationFieldSharedEntityMetaData) == 0x000004, "Wrong alignment on FMovieSceneEvaluationFieldSharedEntityMetaData");
static_assert(sizeof(FMovieSceneEvaluationFieldSharedEntityMetaData) == 0x000010, "Wrong size on FMovieSceneEvaluationFieldSharedEntityMetaData");
static_assert(offsetof(FMovieSceneEvaluationFieldSharedEntityMetaData, ObjectBindingID) == 0x000000, "Member 'FMovieSceneEvaluationFieldSharedEntityMetaData::ObjectBindingID' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEntityComponentField
// 0x00F0 (0x00F0 - 0x0000)
struct FMovieSceneEntityComponentField final
{
public:
	struct FMovieSceneEvaluationFieldEntityTree   PersistentEntityTree;                              // 0x0000(0x0060)(NativeAccessSpecifierPrivate)
	struct FMovieSceneEvaluationFieldEntityTree   OneShotEntityTree;                                 // 0x0060(0x0060)(NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneEvaluationFieldEntity> Entities;                                        // 0x00C0(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneEvaluationFieldEntityMetaData> EntityMetaData;                          // 0x00D0(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneEvaluationFieldSharedEntityMetaData> SharedMetaData;                    // 0x00E0(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneEntityComponentField) == 0x000008, "Wrong alignment on FMovieSceneEntityComponentField");
static_assert(sizeof(FMovieSceneEntityComponentField) == 0x0000F0, "Wrong size on FMovieSceneEntityComponentField");
static_assert(offsetof(FMovieSceneEntityComponentField, PersistentEntityTree) == 0x000000, "Member 'FMovieSceneEntityComponentField::PersistentEntityTree' has a wrong offset!");
static_assert(offsetof(FMovieSceneEntityComponentField, OneShotEntityTree) == 0x000060, "Member 'FMovieSceneEntityComponentField::OneShotEntityTree' has a wrong offset!");
static_assert(offsetof(FMovieSceneEntityComponentField, Entities) == 0x0000C0, "Member 'FMovieSceneEntityComponentField::Entities' has a wrong offset!");
static_assert(offsetof(FMovieSceneEntityComponentField, EntityMetaData) == 0x0000D0, "Member 'FMovieSceneEntityComponentField::EntityMetaData' has a wrong offset!");
static_assert(offsetof(FMovieSceneEntityComponentField, SharedMetaData) == 0x0000E0, "Member 'FMovieSceneEntityComponentField::SharedMetaData' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationHookEvent
// 0x0038 (0x0038 - 0x0000)
struct FMovieSceneEvaluationHookEvent final
{
public:
	struct FMovieSceneEvaluationHookComponent     Hook;                                              // 0x0000(0x0020)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_20[0x18];                                      // 0x0020(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneEvaluationHookEvent) == 0x000008, "Wrong alignment on FMovieSceneEvaluationHookEvent");
static_assert(sizeof(FMovieSceneEvaluationHookEvent) == 0x000038, "Wrong size on FMovieSceneEvaluationHookEvent");
static_assert(offsetof(FMovieSceneEvaluationHookEvent, Hook) == 0x000000, "Member 'FMovieSceneEvaluationHookEvent::Hook' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEvaluationHookEventContainer
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneEvaluationHookEventContainer final
{
public:
	TArray<struct FMovieSceneEvaluationHookEvent> Events;                                            // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEvaluationHookEventContainer) == 0x000008, "Wrong alignment on FMovieSceneEvaluationHookEventContainer");
static_assert(sizeof(FMovieSceneEvaluationHookEventContainer) == 0x000010, "Wrong size on FMovieSceneEvaluationHookEventContainer");
static_assert(offsetof(FMovieSceneEvaluationHookEventContainer, Events) == 0x000000, "Member 'FMovieSceneEvaluationHookEventContainer::Events' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSubSectionData
// 0x001C (0x001C - 0x0000)
struct FMovieSceneSubSectionData final
{
public:
	TWeakObjectPtr<class UMovieSceneSubSection>   Section;                                           // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FGuid                                  ObjectBindingID;                                   // 0x0008(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESectionEvaluationFlags                       Flags;                                             // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSubSectionData) == 0x000004, "Wrong alignment on FMovieSceneSubSectionData");
static_assert(sizeof(FMovieSceneSubSectionData) == 0x00001C, "Wrong size on FMovieSceneSubSectionData");
static_assert(offsetof(FMovieSceneSubSectionData, Section) == 0x000000, "Member 'FMovieSceneSubSectionData::Section' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSectionData, ObjectBindingID) == 0x000008, "Member 'FMovieSceneSubSectionData::ObjectBindingID' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSectionData, Flags) == 0x000018, "Member 'FMovieSceneSubSectionData::Flags' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneKeyTimeStruct
// 0x0020 (0x0028 - 0x0008)
struct FMovieSceneKeyTimeStruct final : public FMovieSceneKeyStruct
{
public:
	struct FFrameNumber                           Time;                                              // 0x0008(0x0004)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x1C];                                       // 0x000C(0x001C)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneKeyTimeStruct) == 0x000008, "Wrong alignment on FMovieSceneKeyTimeStruct");
static_assert(sizeof(FMovieSceneKeyTimeStruct) == 0x000028, "Wrong size on FMovieSceneKeyTimeStruct");
static_assert(offsetof(FMovieSceneKeyTimeStruct, Time) == 0x000008, "Member 'FMovieSceneKeyTimeStruct::Time' has a wrong offset!");

// ScriptStruct MovieScene.GeneratedMovieSceneKeyStruct
// 0x0050 (0x0050 - 0x0000)
struct alignas(0x10) FGeneratedMovieSceneKeyStruct final
{
public:
	uint8                                         Pad_0[0x50];                                       // 0x0000(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FGeneratedMovieSceneKeyStruct) == 0x000010, "Wrong alignment on FGeneratedMovieSceneKeyStruct");
static_assert(sizeof(FGeneratedMovieSceneKeyStruct) == 0x000050, "Wrong size on FGeneratedMovieSceneKeyStruct");

// ScriptStruct MovieScene.MovieSceneObjectPathChannelKeyValue
// 0x0030 (0x0030 - 0x0000)
struct FMovieSceneObjectPathChannelKeyValue final
{
public:
	TSoftObjectPtr<class UObject>                 SoftPtr;                                           // 0x0000(0x0028)(UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UObject*                                HardPtr;                                           // 0x0028(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneObjectPathChannelKeyValue) == 0x000008, "Wrong alignment on FMovieSceneObjectPathChannelKeyValue");
static_assert(sizeof(FMovieSceneObjectPathChannelKeyValue) == 0x000030, "Wrong size on FMovieSceneObjectPathChannelKeyValue");
static_assert(offsetof(FMovieSceneObjectPathChannelKeyValue, SoftPtr) == 0x000000, "Member 'FMovieSceneObjectPathChannelKeyValue::SoftPtr' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectPathChannelKeyValue, HardPtr) == 0x000028, "Member 'FMovieSceneObjectPathChannelKeyValue::HardPtr' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneObjectPathChannel
// 0x00B8 (0x00C0 - 0x0008)
struct FMovieSceneObjectPathChannel final : public FMovieSceneChannel
{
public:
	class UClass*                                 PropertyClass;                                     // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<struct FFrameNumber>                   Times;                                             // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	TArray<struct FMovieSceneObjectPathChannelKeyValue> Values;                                      // 0x0020(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	struct FMovieSceneObjectPathChannelKeyValue   DefaultValue;                                      // 0x0030(0x0030)(NativeAccessSpecifierPrivate)
	uint8                                         Pad_60[0x60];                                      // 0x0060(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneObjectPathChannel) == 0x000008, "Wrong alignment on FMovieSceneObjectPathChannel");
static_assert(sizeof(FMovieSceneObjectPathChannel) == 0x0000C0, "Wrong size on FMovieSceneObjectPathChannel");
static_assert(offsetof(FMovieSceneObjectPathChannel, PropertyClass) == 0x000008, "Member 'FMovieSceneObjectPathChannel::PropertyClass' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectPathChannel, Times) == 0x000010, "Member 'FMovieSceneObjectPathChannel::Times' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectPathChannel, Values) == 0x000020, "Member 'FMovieSceneObjectPathChannel::Values' has a wrong offset!");
static_assert(offsetof(FMovieSceneObjectPathChannel, DefaultValue) == 0x000030, "Member 'FMovieSceneObjectPathChannel::DefaultValue' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneEasingSettings
// 0x0038 (0x0038 - 0x0000)
struct FMovieSceneEasingSettings final
{
public:
	int32                                         AutoEaseInDuration;                                // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         AutoEaseOutDuration;                               // 0x0004(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TScriptInterface<class IMovieSceneEasingFunction> EaseIn;                                        // 0x0008(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bManualEaseIn;                                     // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x3];                                       // 0x0019(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ManualEaseInDuration;                              // 0x001C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TScriptInterface<class IMovieSceneEasingFunction> EaseOut;                                       // 0x0020(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
	bool                                          bManualEaseOut;                                    // 0x0030(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_31[0x3];                                       // 0x0031(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         ManualEaseOutDuration;                             // 0x0034(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneEasingSettings) == 0x000008, "Wrong alignment on FMovieSceneEasingSettings");
static_assert(sizeof(FMovieSceneEasingSettings) == 0x000038, "Wrong size on FMovieSceneEasingSettings");
static_assert(offsetof(FMovieSceneEasingSettings, AutoEaseInDuration) == 0x000000, "Member 'FMovieSceneEasingSettings::AutoEaseInDuration' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, AutoEaseOutDuration) == 0x000004, "Member 'FMovieSceneEasingSettings::AutoEaseOutDuration' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, EaseIn) == 0x000008, "Member 'FMovieSceneEasingSettings::EaseIn' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, bManualEaseIn) == 0x000018, "Member 'FMovieSceneEasingSettings::bManualEaseIn' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, ManualEaseInDuration) == 0x00001C, "Member 'FMovieSceneEasingSettings::ManualEaseInDuration' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, EaseOut) == 0x000020, "Member 'FMovieSceneEasingSettings::EaseOut' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, bManualEaseOut) == 0x000030, "Member 'FMovieSceneEasingSettings::bManualEaseOut' has a wrong offset!");
static_assert(offsetof(FMovieSceneEasingSettings, ManualEaseOutDuration) == 0x000034, "Member 'FMovieSceneEasingSettings::ManualEaseOutDuration' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSectionEvalOptions
// 0x0002 (0x0002 - 0x0000)
struct FMovieSceneSectionEvalOptions final
{
public:
	bool                                          bCanEditCompletionMode;                            // 0x0000(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovieSceneCompletionMode                     CompletionMode;                                    // 0x0001(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSectionEvalOptions) == 0x000001, "Wrong alignment on FMovieSceneSectionEvalOptions");
static_assert(sizeof(FMovieSceneSectionEvalOptions) == 0x000002, "Wrong size on FMovieSceneSectionEvalOptions");
static_assert(offsetof(FMovieSceneSectionEvalOptions, bCanEditCompletionMode) == 0x000000, "Member 'FMovieSceneSectionEvalOptions::bCanEditCompletionMode' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionEvalOptions, CompletionMode) == 0x000001, "Member 'FMovieSceneSectionEvalOptions::CompletionMode' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSectionParameters
// 0x0024 (0x0024 - 0x0000)
struct FMovieSceneSectionParameters final
{
public:
	struct FFrameNumber                           StartFrameOffset;                                  // 0x0000(0x0004)(Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCanLoop;                                          // 0x0004(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_5[0x3];                                        // 0x0005(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FFrameNumber                           EndFrameOffset;                                    // 0x0008(0x0004)(Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           FirstLoopStartFrameOffset;                         // 0x000C(0x0004)(Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         TimeScale;                                         // 0x0010(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         HierarchicalBias;                                  // 0x0014(0x0004)(Edit, BlueprintVisible, ZeroConstructor, Config, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartOffset;                                       // 0x0018(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PrerollTime;                                       // 0x001C(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PostrollTime;                                      // 0x0020(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSectionParameters) == 0x000004, "Wrong alignment on FMovieSceneSectionParameters");
static_assert(sizeof(FMovieSceneSectionParameters) == 0x000024, "Wrong size on FMovieSceneSectionParameters");
static_assert(offsetof(FMovieSceneSectionParameters, StartFrameOffset) == 0x000000, "Member 'FMovieSceneSectionParameters::StartFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, bCanLoop) == 0x000004, "Member 'FMovieSceneSectionParameters::bCanLoop' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, EndFrameOffset) == 0x000008, "Member 'FMovieSceneSectionParameters::EndFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, FirstLoopStartFrameOffset) == 0x00000C, "Member 'FMovieSceneSectionParameters::FirstLoopStartFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, TimeScale) == 0x000010, "Member 'FMovieSceneSectionParameters::TimeScale' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, HierarchicalBias) == 0x000014, "Member 'FMovieSceneSectionParameters::HierarchicalBias' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, StartOffset) == 0x000018, "Member 'FMovieSceneSectionParameters::StartOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, PrerollTime) == 0x00001C, "Member 'FMovieSceneSectionParameters::PrerollTime' has a wrong offset!");
static_assert(offsetof(FMovieSceneSectionParameters, PostrollTime) == 0x000020, "Member 'FMovieSceneSectionParameters::PostrollTime' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceHierarchyNode
// 0x0018 (0x0018 - 0x0000)
struct FMovieSceneSequenceHierarchyNode final
{
public:
	struct FMovieSceneSequenceID                  ParentID;                                          // 0x0000(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_4[0x4];                                        // 0x0004(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FMovieSceneSequenceID>          Children;                                          // 0x0008(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSequenceHierarchyNode) == 0x000008, "Wrong alignment on FMovieSceneSequenceHierarchyNode");
static_assert(sizeof(FMovieSceneSequenceHierarchyNode) == 0x000018, "Wrong size on FMovieSceneSequenceHierarchyNode");
static_assert(offsetof(FMovieSceneSequenceHierarchyNode, ParentID) == 0x000000, "Member 'FMovieSceneSequenceHierarchyNode::ParentID' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceHierarchyNode, Children) == 0x000008, "Member 'FMovieSceneSequenceHierarchyNode::Children' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSubSequenceTree
// 0x0060 (0x0060 - 0x0000)
struct alignas(0x08) FMovieSceneSubSequenceTree final
{
public:
	uint8                                         Pad_0[0x60];                                       // 0x0000(0x0060)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSubSequenceTree) == 0x000008, "Wrong alignment on FMovieSceneSubSequenceTree");
static_assert(sizeof(FMovieSceneSubSequenceTree) == 0x000060, "Wrong size on FMovieSceneSubSequenceTree");

// ScriptStruct MovieScene.MovieSceneTimeTransform
// 0x000C (0x000C - 0x0000)
struct FMovieSceneTimeTransform final
{
public:
	float                                         TimeScale;                                         // 0x0000(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameTime                             Offset;                                            // 0x0004(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTimeTransform) == 0x000004, "Wrong alignment on FMovieSceneTimeTransform");
static_assert(sizeof(FMovieSceneTimeTransform) == 0x00000C, "Wrong size on FMovieSceneTimeTransform");
static_assert(offsetof(FMovieSceneTimeTransform, TimeScale) == 0x000000, "Member 'FMovieSceneTimeTransform::TimeScale' has a wrong offset!");
static_assert(offsetof(FMovieSceneTimeTransform, Offset) == 0x000004, "Member 'FMovieSceneTimeTransform::Offset' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTimeWarping
// 0x0008 (0x0008 - 0x0000)
struct FMovieSceneTimeWarping final
{
public:
	struct FFrameNumber                           Start;                                             // 0x0000(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           End;                                               // 0x0004(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTimeWarping) == 0x000004, "Wrong alignment on FMovieSceneTimeWarping");
static_assert(sizeof(FMovieSceneTimeWarping) == 0x000008, "Wrong size on FMovieSceneTimeWarping");
static_assert(offsetof(FMovieSceneTimeWarping, Start) == 0x000000, "Member 'FMovieSceneTimeWarping::Start' has a wrong offset!");
static_assert(offsetof(FMovieSceneTimeWarping, End) == 0x000004, "Member 'FMovieSceneTimeWarping::End' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneNestedSequenceTransform
// 0x0014 (0x0014 - 0x0000)
struct FMovieSceneNestedSequenceTransform final
{
public:
	struct FMovieSceneTimeTransform               LinearTransform;                                   // 0x0000(0x000C)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneTimeWarping                 Warping;                                           // 0x000C(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneNestedSequenceTransform) == 0x000004, "Wrong alignment on FMovieSceneNestedSequenceTransform");
static_assert(sizeof(FMovieSceneNestedSequenceTransform) == 0x000014, "Wrong size on FMovieSceneNestedSequenceTransform");
static_assert(offsetof(FMovieSceneNestedSequenceTransform, LinearTransform) == 0x000000, "Member 'FMovieSceneNestedSequenceTransform::LinearTransform' has a wrong offset!");
static_assert(offsetof(FMovieSceneNestedSequenceTransform, Warping) == 0x00000C, "Member 'FMovieSceneNestedSequenceTransform::Warping' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceTransform
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneSequenceTransform final
{
public:
	struct FMovieSceneTimeTransform               LinearTransform;                                   // 0x0000(0x000C)(NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<struct FMovieSceneNestedSequenceTransform> NestedTransforms;                              // 0x0010(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSequenceTransform) == 0x000008, "Wrong alignment on FMovieSceneSequenceTransform");
static_assert(sizeof(FMovieSceneSequenceTransform) == 0x000020, "Wrong size on FMovieSceneSequenceTransform");
static_assert(offsetof(FMovieSceneSequenceTransform, LinearTransform) == 0x000000, "Member 'FMovieSceneSequenceTransform::LinearTransform' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceTransform, NestedTransforms) == 0x000010, "Member 'FMovieSceneSequenceTransform::NestedTransforms' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceInstanceDataPtr
// 0x0018 (0x0018 - 0x0000)
struct alignas(0x08) FMovieSceneSequenceInstanceDataPtr final
{
public:
	uint8                                         Pad_0[0x18];                                       // 0x0000(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSequenceInstanceDataPtr) == 0x000008, "Wrong alignment on FMovieSceneSequenceInstanceDataPtr");
static_assert(sizeof(FMovieSceneSequenceInstanceDataPtr) == 0x000018, "Wrong size on FMovieSceneSequenceInstanceDataPtr");

// ScriptStruct MovieScene.MovieSceneSubSequenceData
// 0x0108 (0x0108 - 0x0000)
struct FMovieSceneSubSequenceData final
{
public:
	struct FSoftObjectPath                        Sequence;                                          // 0x0000(0x0018)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneSequenceTransform           OuterToInnerTransform;                             // 0x0018(0x0020)(NativeAccessSpecifierPublic)
	struct FMovieSceneSequenceTransform           RootToSequenceTransform;                           // 0x0038(0x0020)(NativeAccessSpecifierPublic)
	struct FFrameRate                             TickResolution;                                    // 0x0058(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneSequenceID                  DeterministicSequenceID;                           // 0x0060(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FMovieSceneFrameRange                  ParentPlayRange;                                   // 0x0064(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ParentStartFrameOffset;                            // 0x0074(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ParentEndFrameOffset;                              // 0x0078(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ParentFirstLoopStartFrameOffset;                   // 0x007C(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCanLoop;                                          // 0x0080(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_81[0x3];                                       // 0x0081(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFrameRange                  PlayRange;                                         // 0x0084(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneFrameRange                  FullPlayRange;                                     // 0x0094(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneFrameRange                  UnwarpedPlayRange;                                 // 0x00A4(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneFrameRange                  PreRollRange;                                      // 0x00B4(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	struct FMovieSceneFrameRange                  PostRollRange;                                     // 0x00C4(0x0010)(NoDestructor, NativeAccessSpecifierPublic)
	int16                                         HierarchicalBias;                                  // 0x00D4(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bHasHierarchicalEasing;                            // 0x00D6(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D7[0x1];                                       // 0x00D7(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneSequenceInstanceDataPtr     InstanceData;                                      // 0x00D8(0x0018)(NativeAccessSpecifierPublic)
	uint8                                         Pad_F0[0x8];                                       // 0x00F0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  SubSectionSignature;                               // 0x00F8(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneSubSequenceData) == 0x000008, "Wrong alignment on FMovieSceneSubSequenceData");
static_assert(sizeof(FMovieSceneSubSequenceData) == 0x000108, "Wrong size on FMovieSceneSubSequenceData");
static_assert(offsetof(FMovieSceneSubSequenceData, Sequence) == 0x000000, "Member 'FMovieSceneSubSequenceData::Sequence' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, OuterToInnerTransform) == 0x000018, "Member 'FMovieSceneSubSequenceData::OuterToInnerTransform' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, RootToSequenceTransform) == 0x000038, "Member 'FMovieSceneSubSequenceData::RootToSequenceTransform' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, TickResolution) == 0x000058, "Member 'FMovieSceneSubSequenceData::TickResolution' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, DeterministicSequenceID) == 0x000060, "Member 'FMovieSceneSubSequenceData::DeterministicSequenceID' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, ParentPlayRange) == 0x000064, "Member 'FMovieSceneSubSequenceData::ParentPlayRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, ParentStartFrameOffset) == 0x000074, "Member 'FMovieSceneSubSequenceData::ParentStartFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, ParentEndFrameOffset) == 0x000078, "Member 'FMovieSceneSubSequenceData::ParentEndFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, ParentFirstLoopStartFrameOffset) == 0x00007C, "Member 'FMovieSceneSubSequenceData::ParentFirstLoopStartFrameOffset' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, bCanLoop) == 0x000080, "Member 'FMovieSceneSubSequenceData::bCanLoop' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, PlayRange) == 0x000084, "Member 'FMovieSceneSubSequenceData::PlayRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, FullPlayRange) == 0x000094, "Member 'FMovieSceneSubSequenceData::FullPlayRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, UnwarpedPlayRange) == 0x0000A4, "Member 'FMovieSceneSubSequenceData::UnwarpedPlayRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, PreRollRange) == 0x0000B4, "Member 'FMovieSceneSubSequenceData::PreRollRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, PostRollRange) == 0x0000C4, "Member 'FMovieSceneSubSequenceData::PostRollRange' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, HierarchicalBias) == 0x0000D4, "Member 'FMovieSceneSubSequenceData::HierarchicalBias' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, bHasHierarchicalEasing) == 0x0000D6, "Member 'FMovieSceneSubSequenceData::bHasHierarchicalEasing' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, InstanceData) == 0x0000D8, "Member 'FMovieSceneSubSequenceData::InstanceData' has a wrong offset!");
static_assert(offsetof(FMovieSceneSubSequenceData, SubSectionSignature) == 0x0000F8, "Member 'FMovieSceneSubSequenceData::SubSectionSignature' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceHierarchy
// 0x0118 (0x0118 - 0x0000)
struct FMovieSceneSequenceHierarchy final
{
public:
	struct FMovieSceneSequenceHierarchyNode       RootNode;                                          // 0x0000(0x0018)(NativeAccessSpecifierPrivate)
	struct FMovieSceneSubSequenceTree             Tree;                                              // 0x0018(0x0060)(NativeAccessSpecifierPrivate)
	TMap<struct FMovieSceneSequenceID, struct FMovieSceneSubSequenceData> SubSequences;              // 0x0078(0x0050)(NativeAccessSpecifierPrivate)
	TMap<struct FMovieSceneSequenceID, struct FMovieSceneSequenceHierarchyNode> Hierarchy;           // 0x00C8(0x0050)(NativeAccessSpecifierPrivate)
};
static_assert(alignof(FMovieSceneSequenceHierarchy) == 0x000008, "Wrong alignment on FMovieSceneSequenceHierarchy");
static_assert(sizeof(FMovieSceneSequenceHierarchy) == 0x000118, "Wrong size on FMovieSceneSequenceHierarchy");
static_assert(offsetof(FMovieSceneSequenceHierarchy, RootNode) == 0x000000, "Member 'FMovieSceneSequenceHierarchy::RootNode' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceHierarchy, Tree) == 0x000018, "Member 'FMovieSceneSequenceHierarchy::Tree' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceHierarchy, SubSequences) == 0x000078, "Member 'FMovieSceneSequenceHierarchy::SubSequences' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceHierarchy, Hierarchy) == 0x0000C8, "Member 'FMovieSceneSequenceHierarchy::Hierarchy' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSubSequenceTreeEntry
// 0x0018 (0x0018 - 0x0000)
struct alignas(0x08) FMovieSceneSubSequenceTreeEntry final
{
public:
	uint8                                         Pad_0[0x18];                                       // 0x0000(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSubSequenceTreeEntry) == 0x000008, "Wrong alignment on FMovieSceneSubSequenceTreeEntry");
static_assert(sizeof(FMovieSceneSubSequenceTreeEntry) == 0x000018, "Wrong size on FMovieSceneSubSequenceTreeEntry");

// ScriptStruct MovieScene.MovieSceneSequencePlaybackParams
// 0x0028 (0x0028 - 0x0000)
struct FMovieSceneSequencePlaybackParams final
{
public:
	struct FFrameTime                             Frame;                                             // 0x0000(0x0008)(Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         Time;                                              // 0x0008(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_C[0x4];                                        // 0x000C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 MarkedFrame;                                       // 0x0010(0x0010)(Edit, BlueprintVisible, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovieScenePositionType                       PositionType;                                      // 0x0020(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EUpdatePositionMethod                         UpdateMethod;                                      // 0x0021(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_22[0x6];                                       // 0x0022(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSequencePlaybackParams) == 0x000008, "Wrong alignment on FMovieSceneSequencePlaybackParams");
static_assert(sizeof(FMovieSceneSequencePlaybackParams) == 0x000028, "Wrong size on FMovieSceneSequencePlaybackParams");
static_assert(offsetof(FMovieSceneSequencePlaybackParams, Frame) == 0x000000, "Member 'FMovieSceneSequencePlaybackParams::Frame' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackParams, Time) == 0x000008, "Member 'FMovieSceneSequencePlaybackParams::Time' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackParams, MarkedFrame) == 0x000010, "Member 'FMovieSceneSequencePlaybackParams::MarkedFrame' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackParams, PositionType) == 0x000020, "Member 'FMovieSceneSequencePlaybackParams::PositionType' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackParams, UpdateMethod) == 0x000021, "Member 'FMovieSceneSequencePlaybackParams::UpdateMethod' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceLoopCount
// 0x0004 (0x0004 - 0x0000)
struct FMovieSceneSequenceLoopCount final
{
public:
	int32                                         Value;                                             // 0x0000(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSequenceLoopCount) == 0x000004, "Wrong alignment on FMovieSceneSequenceLoopCount");
static_assert(sizeof(FMovieSceneSequenceLoopCount) == 0x000004, "Wrong size on FMovieSceneSequenceLoopCount");
static_assert(offsetof(FMovieSceneSequenceLoopCount, Value) == 0x000000, "Member 'FMovieSceneSequenceLoopCount::Value' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequencePlaybackSettings
// 0x0014 (0x0014 - 0x0000)
struct FMovieSceneSequencePlaybackSettings final
{
public:
	uint8                                         bAutoPlay : 1;                                     // 0x0000(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneSequenceLoopCount           LoopCount;                                         // 0x0004(0x0004)(Edit, BlueprintVisible, NoDestructor, NativeAccessSpecifierPublic)
	float                                         PlayRate;                                          // 0x0008(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         StartTime;                                         // 0x000C(0x0004)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bRandomStartTime : 1;                              // 0x0010(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bRestoreState : 1;                                 // 0x0010(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableMovementInput : 1;                         // 0x0010(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableLookAtInput : 1;                           // 0x0010(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHidePlayer : 1;                                   // 0x0010(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bHideHud : 1;                                      // 0x0010(0x0001)(BitIndex: 0x05, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bDisableCameraCuts : 1;                            // 0x0010(0x0001)(BitIndex: 0x06, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bPauseAtEnd : 1;                                   // 0x0010(0x0001)(BitIndex: 0x07, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_11[0x3];                                       // 0x0011(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSequencePlaybackSettings) == 0x000004, "Wrong alignment on FMovieSceneSequencePlaybackSettings");
static_assert(sizeof(FMovieSceneSequencePlaybackSettings) == 0x000014, "Wrong size on FMovieSceneSequencePlaybackSettings");
static_assert(offsetof(FMovieSceneSequencePlaybackSettings, LoopCount) == 0x000004, "Member 'FMovieSceneSequencePlaybackSettings::LoopCount' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackSettings, PlayRate) == 0x000008, "Member 'FMovieSceneSequencePlaybackSettings::PlayRate' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequencePlaybackSettings, StartTime) == 0x00000C, "Member 'FMovieSceneSequencePlaybackSettings::StartTime' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceReplProperties
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneSequenceReplProperties final
{
public:
	struct FFrameTime                             LastKnownPosition;                                 // 0x0000(0x0008)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovieScenePlayerStatus                       LastKnownStatus;                                   // 0x0008(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         LastKnownNumLoops;                                 // 0x000C(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSequenceReplProperties) == 0x000004, "Wrong alignment on FMovieSceneSequenceReplProperties");
static_assert(sizeof(FMovieSceneSequenceReplProperties) == 0x000010, "Wrong size on FMovieSceneSequenceReplProperties");
static_assert(offsetof(FMovieSceneSequenceReplProperties, LastKnownPosition) == 0x000000, "Member 'FMovieSceneSequenceReplProperties::LastKnownPosition' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceReplProperties, LastKnownStatus) == 0x000008, "Member 'FMovieSceneSequenceReplProperties::LastKnownStatus' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceReplProperties, LastKnownNumLoops) == 0x00000C, "Member 'FMovieSceneSequenceReplProperties::LastKnownNumLoops' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSequenceActorPointers
// 0x0018 (0x0018 - 0x0000)
struct FMovieSceneSequenceActorPointers final
{
public:
	class AActor*                                 SequenceActor;                                     // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TScriptInterface<class IMovieSceneSequenceActor> SequenceActorInterface;                         // 0x0008(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneSequenceActorPointers) == 0x000008, "Wrong alignment on FMovieSceneSequenceActorPointers");
static_assert(sizeof(FMovieSceneSequenceActorPointers) == 0x000018, "Wrong size on FMovieSceneSequenceActorPointers");
static_assert(offsetof(FMovieSceneSequenceActorPointers, SequenceActor) == 0x000000, "Member 'FMovieSceneSequenceActorPointers::SequenceActor' has a wrong offset!");
static_assert(offsetof(FMovieSceneSequenceActorPointers, SequenceActorInterface) == 0x000008, "Member 'FMovieSceneSequenceActorPointers::SequenceActorInterface' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneWarpCounter
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneWarpCounter final
{
public:
	TArray<uint32>                                WarpCounts;                                        // 0x0000(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneWarpCounter) == 0x000008, "Wrong alignment on FMovieSceneWarpCounter");
static_assert(sizeof(FMovieSceneWarpCounter) == 0x000010, "Wrong size on FMovieSceneWarpCounter");
static_assert(offsetof(FMovieSceneWarpCounter, WarpCounts) == 0x000000, "Member 'FMovieSceneWarpCounter::WarpCounts' has a wrong offset!");

// ScriptStruct MovieScene.SpawnableObjectTemplateInfo
// 0x0008 (0x0008 - 0x0000)
struct FSpawnableObjectTemplateInfo final
{
public:
	bool                                          bIsACharacter;                                     // 0x0000(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsSkeletalMeshActor;                              // 0x0001(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_2[0x2];                                        // 0x0002(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	float                                         CapsuleScaledHalfHeight;                           // 0x0004(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FSpawnableObjectTemplateInfo) == 0x000004, "Wrong alignment on FSpawnableObjectTemplateInfo");
static_assert(sizeof(FSpawnableObjectTemplateInfo) == 0x000008, "Wrong size on FSpawnableObjectTemplateInfo");
static_assert(offsetof(FSpawnableObjectTemplateInfo, bIsACharacter) == 0x000000, "Member 'FSpawnableObjectTemplateInfo::bIsACharacter' has a wrong offset!");
static_assert(offsetof(FSpawnableObjectTemplateInfo, bIsSkeletalMeshActor) == 0x000001, "Member 'FSpawnableObjectTemplateInfo::bIsSkeletalMeshActor' has a wrong offset!");
static_assert(offsetof(FSpawnableObjectTemplateInfo, CapsuleScaledHalfHeight) == 0x000004, "Member 'FSpawnableObjectTemplateInfo::CapsuleScaledHalfHeight' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneSpawnable
// 0x00A0 (0x00A0 - 0x0000)
struct FMovieSceneSpawnable final
{
public:
	struct FTransform                             SpawnTransform;                                    // 0x0000(0x0030)(Edit, IsPlainOldData, NoDestructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	TArray<class FName>                           Tags;                                              // 0x0030(0x0010)(Edit, ZeroConstructor, AdvancedDisplay, NativeAccessSpecifierPublic)
	bool                                          bContinuouslyRespawn;                              // 0x0040(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bNetAddressableName;                               // 0x0041(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEvaluateTracksWhenNotSpawned;                     // 0x0042(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bPhxLoadFullObjectTemplate;                        // 0x0043(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FSpawnableObjectTemplateInfo           ObjectTemplateInfo;                                // 0x0044(0x0008)(NoDestructor, NativeAccessSpecifierPublic)
	struct FGuid                                  Guid;                                              // 0x004C(0x0010)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_5C[0x4];                                       // 0x005C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	class FString                                 Name;                                              // 0x0060(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UObject*                                ObjectTemplate;                                    // 0x0070(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TArray<struct FGuid>                          ChildPossessables;                                 // 0x0078(0x0010)(ZeroConstructor, NativeAccessSpecifierPrivate)
	ESpawnOwnership                               Ownership;                                         // 0x0088(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_89[0x3];                                       // 0x0089(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   LevelName;                                         // 0x008C(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_94[0xC];                                       // 0x0094(0x000C)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneSpawnable) == 0x000010, "Wrong alignment on FMovieSceneSpawnable");
static_assert(sizeof(FMovieSceneSpawnable) == 0x0000A0, "Wrong size on FMovieSceneSpawnable");
static_assert(offsetof(FMovieSceneSpawnable, SpawnTransform) == 0x000000, "Member 'FMovieSceneSpawnable::SpawnTransform' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, Tags) == 0x000030, "Member 'FMovieSceneSpawnable::Tags' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, bContinuouslyRespawn) == 0x000040, "Member 'FMovieSceneSpawnable::bContinuouslyRespawn' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, bNetAddressableName) == 0x000041, "Member 'FMovieSceneSpawnable::bNetAddressableName' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, bEvaluateTracksWhenNotSpawned) == 0x000042, "Member 'FMovieSceneSpawnable::bEvaluateTracksWhenNotSpawned' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, bPhxLoadFullObjectTemplate) == 0x000043, "Member 'FMovieSceneSpawnable::bPhxLoadFullObjectTemplate' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, ObjectTemplateInfo) == 0x000044, "Member 'FMovieSceneSpawnable::ObjectTemplateInfo' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, Guid) == 0x00004C, "Member 'FMovieSceneSpawnable::Guid' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, Name) == 0x000060, "Member 'FMovieSceneSpawnable::Name' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, ObjectTemplate) == 0x000070, "Member 'FMovieSceneSpawnable::ObjectTemplate' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, ChildPossessables) == 0x000078, "Member 'FMovieSceneSpawnable::ChildPossessables' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, Ownership) == 0x000088, "Member 'FMovieSceneSpawnable::Ownership' has a wrong offset!");
static_assert(offsetof(FMovieSceneSpawnable, LevelName) == 0x00008C, "Member 'FMovieSceneSpawnable::LevelName' has a wrong offset!");

// ScriptStruct MovieScene.TestMovieSceneEvalTemplate
// 0x0000 (0x0020 - 0x0020)
struct FTestMovieSceneEvalTemplate final : public FMovieSceneEvalTemplate
{
};
static_assert(alignof(FTestMovieSceneEvalTemplate) == 0x000008, "Wrong alignment on FTestMovieSceneEvalTemplate");
static_assert(sizeof(FTestMovieSceneEvalTemplate) == 0x000020, "Wrong size on FTestMovieSceneEvalTemplate");

// ScriptStruct MovieScene.MovieSceneTrackDisplayOptions
// 0x0004 (0x0004 - 0x0000)
struct alignas(0x04) FMovieSceneTrackDisplayOptions final
{
public:
	uint8                                         bShowVerticalFrames : 1;                           // 0x0000(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneTrackDisplayOptions) == 0x000004, "Wrong alignment on FMovieSceneTrackDisplayOptions");
static_assert(sizeof(FMovieSceneTrackDisplayOptions) == 0x000004, "Wrong size on FMovieSceneTrackDisplayOptions");

// ScriptStruct MovieScene.MovieSceneTrackEvalOptions
// 0x0004 (0x0004 - 0x0000)
struct alignas(0x04) FMovieSceneTrackEvalOptions final
{
public:
	uint8                                         bCanEvaluateNearestSection : 1;                    // 0x0000(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvalNearestSection : 1;                           // 0x0000(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateInPreroll : 1;                            // 0x0000(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateInPostroll : 1;                           // 0x0000(0x0001)(BitIndex: 0x03, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bEvaluateNearestSection : 1;                       // 0x0000(0x0001)(BitIndex: 0x04, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneTrackEvalOptions) == 0x000004, "Wrong alignment on FMovieSceneTrackEvalOptions");
static_assert(sizeof(FMovieSceneTrackEvalOptions) == 0x000004, "Wrong size on FMovieSceneTrackEvalOptions");

// ScriptStruct MovieScene.MovieSceneTrackEvaluationFieldEntry
// 0x0020 (0x0020 - 0x0000)
struct FMovieSceneTrackEvaluationFieldEntry final
{
public:
	class UMovieSceneSection*                     Section;                                           // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumberRange                      Range;                                             // 0x0008(0x0010)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FFrameNumber                           ForcedTime;                                        // 0x0018(0x0004)(NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ESectionEvaluationFlags                       Flags;                                             // 0x001C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0x1];                                       // 0x001D(0x0001)(Fixing Size After Last Property [ Dumper-7 ])
	int16                                         LegacySortOrder;                                   // 0x001E(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTrackEvaluationFieldEntry) == 0x000008, "Wrong alignment on FMovieSceneTrackEvaluationFieldEntry");
static_assert(sizeof(FMovieSceneTrackEvaluationFieldEntry) == 0x000020, "Wrong size on FMovieSceneTrackEvaluationFieldEntry");
static_assert(offsetof(FMovieSceneTrackEvaluationFieldEntry, Section) == 0x000000, "Member 'FMovieSceneTrackEvaluationFieldEntry::Section' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackEvaluationFieldEntry, Range) == 0x000008, "Member 'FMovieSceneTrackEvaluationFieldEntry::Range' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackEvaluationFieldEntry, ForcedTime) == 0x000018, "Member 'FMovieSceneTrackEvaluationFieldEntry::ForcedTime' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackEvaluationFieldEntry, Flags) == 0x00001C, "Member 'FMovieSceneTrackEvaluationFieldEntry::Flags' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackEvaluationFieldEntry, LegacySortOrder) == 0x00001E, "Member 'FMovieSceneTrackEvaluationFieldEntry::LegacySortOrder' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackEvaluationField
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneTrackEvaluationField final
{
public:
	TArray<struct FMovieSceneTrackEvaluationFieldEntry> Entries;                                     // 0x0000(0x0010)(ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTrackEvaluationField) == 0x000008, "Wrong alignment on FMovieSceneTrackEvaluationField");
static_assert(sizeof(FMovieSceneTrackEvaluationField) == 0x000010, "Wrong size on FMovieSceneTrackEvaluationField");
static_assert(offsetof(FMovieSceneTrackEvaluationField, Entries) == 0x000000, "Member 'FMovieSceneTrackEvaluationField::Entries' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackInstanceInput
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneTrackInstanceInput final
{
public:
	class UMovieSceneSection*                     Section;                                           // 0x0000(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_8[0x8];                                        // 0x0008(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FMovieSceneTrackInstanceInput) == 0x000008, "Wrong alignment on FMovieSceneTrackInstanceInput");
static_assert(sizeof(FMovieSceneTrackInstanceInput) == 0x000010, "Wrong size on FMovieSceneTrackInstanceInput");
static_assert(offsetof(FMovieSceneTrackInstanceInput, Section) == 0x000000, "Member 'FMovieSceneTrackInstanceInput::Section' has a wrong offset!");

// ScriptStruct MovieScene.MovieSceneTrackInstanceEntry
// 0x0010 (0x0010 - 0x0000)
struct FMovieSceneTrackInstanceEntry final
{
public:
	class UObject*                                BoundObject;                                       // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UMovieSceneTrackInstance*               TrackInstance;                                     // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FMovieSceneTrackInstanceEntry) == 0x000008, "Wrong alignment on FMovieSceneTrackInstanceEntry");
static_assert(sizeof(FMovieSceneTrackInstanceEntry) == 0x000010, "Wrong size on FMovieSceneTrackInstanceEntry");
static_assert(offsetof(FMovieSceneTrackInstanceEntry, BoundObject) == 0x000000, "Member 'FMovieSceneTrackInstanceEntry::BoundObject' has a wrong offset!");
static_assert(offsetof(FMovieSceneTrackInstanceEntry, TrackInstance) == 0x000008, "Member 'FMovieSceneTrackInstanceEntry::TrackInstance' has a wrong offset!");

}

