#pragma once

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

// Package: MovieSceneTracks

#include "Basic.hpp"

#include "CoreUObject_structs.hpp"
#include "CoreUObject_classes.hpp"
#include "MovieSceneTracks_structs.hpp"
#include "MovieScene_structs.hpp"
#include "MovieScene_classes.hpp"
#include "Engine_structs.hpp"


namespace SDK
{

// Class MovieSceneTracks.MovieScenePropertyTrack
// 0x0030 (0x00C0 - 0x0090)
class UMovieScenePropertyTrack : public UMovieSceneNameableTrack
{
public:
	class UMovieSceneSection*                     SectionToKey;                                      // 0x0090(0x0008)(ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FMovieScenePropertyBinding             PropertyBinding;                                   // 0x0098(0x0014)(NoDestructor, Protected, NativeAccessSpecifierProtected)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x00B0(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)

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

// Class MovieSceneTracks.MovieSceneByteTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneByteTrack final : public UMovieScenePropertyTrack
{
public:
	class UEnum*                                  Enum;                                              // 0x00C0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneByteTrack">();
	}
	static class UMovieSceneByteTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneByteTrack>();
	}
};
static_assert(alignof(UMovieSceneByteTrack) == 0x000008, "Wrong alignment on UMovieSceneByteTrack");
static_assert(sizeof(UMovieSceneByteTrack) == 0x0000C8, "Wrong size on UMovieSceneByteTrack");
static_assert(offsetof(UMovieSceneByteTrack, Enum) == 0x0000C0, "Member 'UMovieSceneByteTrack::Enum' has a wrong offset!");

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

// Class MovieSceneTracks.IntegerChannelEvaluatorSystem
// 0x0000 (0x0040 - 0x0040)
class UIntegerChannelEvaluatorSystem final : public UMovieSceneEntitySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"IntegerChannelEvaluatorSystem">();
	}
	static class UIntegerChannelEvaluatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UIntegerChannelEvaluatorSystem>();
	}
};
static_assert(alignof(UIntegerChannelEvaluatorSystem) == 0x000008, "Wrong alignment on UIntegerChannelEvaluatorSystem");
static_assert(sizeof(UIntegerChannelEvaluatorSystem) == 0x000040, "Wrong size on UIntegerChannelEvaluatorSystem");

// Class MovieSceneTracks.MovieScenePropertySystem
// 0x0018 (0x0058 - 0x0040)
class UMovieScenePropertySystem : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x8];                                       // 0x0040(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UMovieScenePropertyInstantiatorSystem*  InstantiatorSystem;                                // 0x0048(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	uint8                                         Pad_50[0x8];                                       // 0x0050(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScenePropertySystem">();
	}
	static class UMovieScenePropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScenePropertySystem>();
	}
};
static_assert(alignof(UMovieScenePropertySystem) == 0x000008, "Wrong alignment on UMovieScenePropertySystem");
static_assert(sizeof(UMovieScenePropertySystem) == 0x000058, "Wrong size on UMovieScenePropertySystem");
static_assert(offsetof(UMovieScenePropertySystem, InstantiatorSystem) == 0x000048, "Member 'UMovieScenePropertySystem::InstantiatorSystem' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneBoolPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneBoolPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneBoolPropertySystem">();
	}
	static class UMovieSceneBoolPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneBoolPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneBoolPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneBoolPropertySystem");
static_assert(sizeof(UMovieSceneBoolPropertySystem) == 0x000058, "Wrong size on UMovieSceneBoolPropertySystem");

// Class MovieSceneTracks.MovieSceneParameterSection
// 0x0080 (0x0168 - 0x00E8)
class UMovieSceneParameterSection : public UMovieSceneSection
{
public:
	TArray<struct FBoolParameterNameAndCurve>     BoolParameterNamesAndCurves;                       // 0x00E8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FScalarParameterNameAndCurve>   ScalarParameterNamesAndCurves;                     // 0x00F8(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FVector2DParameterNameAndCurves> Vector2DParameterNamesAndCurves;                  // 0x0108(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FVectorParameterNameAndCurves>  VectorParameterNamesAndCurves;                     // 0x0118(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FColorParameterNameAndCurves>   ColorParameterNamesAndCurves;                      // 0x0128(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FTransformParameterNameAndCurves> TransformParameterNamesAndCurves;                // 0x0138(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FPhxMaterialLayerScalarParameterAndCurve> PhxMaterialLayerScalarParametersAndCurves; // 0x0148(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)
	TArray<struct FPhxMaterialLayerColorParameterAndCurves> PhxMaterialLayerColorParametersAndCurves; // 0x0158(0x0010)(ZeroConstructor, Protected, NativeAccessSpecifierProtected)

public:
	void AddBoolParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, bool InValue);
	void AddColorParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, const struct FLinearColor& InValue);
	void AddScalarParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, float InValue);
	void AddTransformParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, const struct FTransform& InValue);
	void AddVector2DParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, const struct FVector2D& InValue);
	void AddVectorParameterKey(class FName InParameterName, const struct FFrameNumber& InTime, const struct FVector& InValue);
	bool RemoveBoolParameter(class FName InParameterName);
	bool RemoveColorParameter(class FName InParameterName);
	bool RemoveScalarParameter(class FName InParameterName);
	bool RemoveTransformParameter(class FName InParameterName);
	bool RemoveVector2DParameter(class FName InParameterName);
	bool RemoveVectorParameter(class FName InParameterName);

	void GetParameterNames(TSet<class FName>* ParameterNames) const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneParameterSection">();
	}
	static class UMovieSceneParameterSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneParameterSection>();
	}
};
static_assert(alignof(UMovieSceneParameterSection) == 0x000008, "Wrong alignment on UMovieSceneParameterSection");
static_assert(sizeof(UMovieSceneParameterSection) == 0x000168, "Wrong size on UMovieSceneParameterSection");
static_assert(offsetof(UMovieSceneParameterSection, BoolParameterNamesAndCurves) == 0x0000E8, "Member 'UMovieSceneParameterSection::BoolParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, ScalarParameterNamesAndCurves) == 0x0000F8, "Member 'UMovieSceneParameterSection::ScalarParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, Vector2DParameterNamesAndCurves) == 0x000108, "Member 'UMovieSceneParameterSection::Vector2DParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, VectorParameterNamesAndCurves) == 0x000118, "Member 'UMovieSceneParameterSection::VectorParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, ColorParameterNamesAndCurves) == 0x000128, "Member 'UMovieSceneParameterSection::ColorParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, TransformParameterNamesAndCurves) == 0x000138, "Member 'UMovieSceneParameterSection::TransformParameterNamesAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, PhxMaterialLayerScalarParametersAndCurves) == 0x000148, "Member 'UMovieSceneParameterSection::PhxMaterialLayerScalarParametersAndCurves' has a wrong offset!");
static_assert(offsetof(UMovieSceneParameterSection, PhxMaterialLayerColorParametersAndCurves) == 0x000158, "Member 'UMovieSceneParameterSection::PhxMaterialLayerColorParametersAndCurves' has a wrong offset!");

// Class MovieSceneTracks.ByteChannelEvaluatorSystem
// 0x0000 (0x0040 - 0x0040)
class UByteChannelEvaluatorSystem final : public UMovieSceneEntitySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"ByteChannelEvaluatorSystem">();
	}
	static class UByteChannelEvaluatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UByteChannelEvaluatorSystem>();
	}
};
static_assert(alignof(UByteChannelEvaluatorSystem) == 0x000008, "Wrong alignment on UByteChannelEvaluatorSystem");
static_assert(sizeof(UByteChannelEvaluatorSystem) == 0x000040, "Wrong size on UByteChannelEvaluatorSystem");

// Class MovieSceneTracks.MovieScene3DConstraintSection
// 0x0028 (0x0110 - 0x00E8)
class UMovieScene3DConstraintSection : public UMovieSceneSection
{
public:
	struct FGuid                                  ConstraintId;                                      // 0x00E8(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
	struct FMovieSceneObjectBindingID             ConstraintBindingID;                               // 0x00F8(0x0018)(Edit, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	void SetConstraintBindingID(const struct FMovieSceneObjectBindingID& InConstraintBindingID);

	const struct FMovieSceneObjectBindingID GetConstraintBindingID() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DConstraintSection">();
	}
	static class UMovieScene3DConstraintSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DConstraintSection>();
	}
};
static_assert(alignof(UMovieScene3DConstraintSection) == 0x000008, "Wrong alignment on UMovieScene3DConstraintSection");
static_assert(sizeof(UMovieScene3DConstraintSection) == 0x000110, "Wrong size on UMovieScene3DConstraintSection");
static_assert(offsetof(UMovieScene3DConstraintSection, ConstraintId) == 0x0000E8, "Member 'UMovieScene3DConstraintSection::ConstraintId' has a wrong offset!");
static_assert(offsetof(UMovieScene3DConstraintSection, ConstraintBindingID) == 0x0000F8, "Member 'UMovieScene3DConstraintSection::ConstraintBindingID' has a wrong offset!");

// Class MovieSceneTracks.MovieScene3DPathSection
// 0x00A8 (0x01B8 - 0x0110)
class UMovieScene3DPathSection final : public UMovieScene3DConstraintSection
{
public:
	struct FMovieSceneFloatChannel                TimingCurve;                                       // 0x0110(0x00A0)(NativeAccessSpecifierPublic)
	EMovieScene3DPathSection_Axis                 FrontAxisEnum;                                     // 0x01B0(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EMovieScene3DPathSection_Axis                 UpAxisEnum;                                        // 0x01B1(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1B2[0x2];                                      // 0x01B2(0x0002)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bFollow : 1;                                       // 0x01B4(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bReverse : 1;                                      // 0x01B4(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bForceUpright : 1;                                 // 0x01B4(0x0001)(BitIndex: 0x02, PropSize: 0x0001 (Edit, BlueprintVisible, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_1B5[0x3];                                      // 0x01B5(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DPathSection">();
	}
	static class UMovieScene3DPathSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DPathSection>();
	}
};
static_assert(alignof(UMovieScene3DPathSection) == 0x000008, "Wrong alignment on UMovieScene3DPathSection");
static_assert(sizeof(UMovieScene3DPathSection) == 0x0001B8, "Wrong size on UMovieScene3DPathSection");
static_assert(offsetof(UMovieScene3DPathSection, TimingCurve) == 0x000110, "Member 'UMovieScene3DPathSection::TimingCurve' has a wrong offset!");
static_assert(offsetof(UMovieScene3DPathSection, FrontAxisEnum) == 0x0001B0, "Member 'UMovieScene3DPathSection::FrontAxisEnum' has a wrong offset!");
static_assert(offsetof(UMovieScene3DPathSection, UpAxisEnum) == 0x0001B1, "Member 'UMovieScene3DPathSection::UpAxisEnum' has a wrong offset!");

// Class MovieSceneTracks.FloatChannelEvaluatorSystem
// 0x0000 (0x0040 - 0x0040)
class UFloatChannelEvaluatorSystem final : public UMovieSceneEntitySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"FloatChannelEvaluatorSystem">();
	}
	static class UFloatChannelEvaluatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UFloatChannelEvaluatorSystem>();
	}
};
static_assert(alignof(UFloatChannelEvaluatorSystem) == 0x000008, "Wrong alignment on UFloatChannelEvaluatorSystem");
static_assert(sizeof(UFloatChannelEvaluatorSystem) == 0x000040, "Wrong size on UFloatChannelEvaluatorSystem");

// Class MovieSceneTracks.MovieSceneTransformOrigin
// 0x0000 (0x0000 - 0x0000)
class IMovieSceneTransformOrigin final
{
public:
	struct FTransform BP_GetTransformOrigin() const;

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

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

// Class MovieSceneTracks.MovieScene3DAttachSection
// 0x0020 (0x0130 - 0x0110)
class UMovieScene3DAttachSection final : public UMovieScene3DConstraintSection
{
public:
	uint8                                         Pad_110[0x8];                                      // 0x0110(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   AttachSocketName;                                  // 0x0118(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   AttachComponentName;                               // 0x0120(0x0008)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AttachmentLocationRule;                            // 0x0128(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AttachmentRotationRule;                            // 0x0129(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EAttachmentRule                               AttachmentScaleRule;                               // 0x012A(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDetachmentRule                               DetachmentLocationRule;                            // 0x012B(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDetachmentRule                               DetachmentRotationRule;                            // 0x012C(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDetachmentRule                               DetachmentScaleRule;                               // 0x012D(0x0001)(Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_12E[0x2];                                      // 0x012E(0x0002)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DAttachSection">();
	}
	static class UMovieScene3DAttachSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DAttachSection>();
	}
};
static_assert(alignof(UMovieScene3DAttachSection) == 0x000008, "Wrong alignment on UMovieScene3DAttachSection");
static_assert(sizeof(UMovieScene3DAttachSection) == 0x000130, "Wrong size on UMovieScene3DAttachSection");
static_assert(offsetof(UMovieScene3DAttachSection, AttachSocketName) == 0x000118, "Member 'UMovieScene3DAttachSection::AttachSocketName' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, AttachComponentName) == 0x000120, "Member 'UMovieScene3DAttachSection::AttachComponentName' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, AttachmentLocationRule) == 0x000128, "Member 'UMovieScene3DAttachSection::AttachmentLocationRule' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, AttachmentRotationRule) == 0x000129, "Member 'UMovieScene3DAttachSection::AttachmentRotationRule' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, AttachmentScaleRule) == 0x00012A, "Member 'UMovieScene3DAttachSection::AttachmentScaleRule' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, DetachmentLocationRule) == 0x00012B, "Member 'UMovieScene3DAttachSection::DetachmentLocationRule' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, DetachmentRotationRule) == 0x00012C, "Member 'UMovieScene3DAttachSection::DetachmentRotationRule' has a wrong offset!");
static_assert(offsetof(UMovieScene3DAttachSection, DetachmentScaleRule) == 0x00012D, "Member 'UMovieScene3DAttachSection::DetachmentScaleRule' has a wrong offset!");

// Class MovieSceneTracks.MovieScene3DConstraintTrack
// 0x0010 (0x00A0 - 0x0090)
class UMovieScene3DConstraintTrack : public UMovieSceneTrack
{
public:
	TArray<class UMovieSceneSection*>             ConstraintSections;                                // 0x0090(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)

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

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

// Class MovieSceneTracks.MovieScene3DPathTrack
// 0x0008 (0x00A8 - 0x00A0)
class UMovieScene3DPathTrack final : public UMovieScene3DConstraintTrack
{
public:
	uint8                                         Pad_A0[0x8];                                       // 0x00A0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScene3DTransformPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieScene3DTransformPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DTransformPropertySystem">();
	}
	static class UMovieScene3DTransformPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DTransformPropertySystem>();
	}
};
static_assert(alignof(UMovieScene3DTransformPropertySystem) == 0x000008, "Wrong alignment on UMovieScene3DTransformPropertySystem");
static_assert(sizeof(UMovieScene3DTransformPropertySystem) == 0x000058, "Wrong size on UMovieScene3DTransformPropertySystem");

// Class MovieSceneTracks.MovieScene3DTransformSection
// 0x0658 (0x0740 - 0x00E8)
class UMovieScene3DTransformSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneTransformMask               TransformMask;                                     // 0x00F0(0x0004)(NoDestructor, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F4[0x4];                                       // 0x00F4(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                Translation[0x3];                                  // 0x00F8(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                Rotation[0x3];                                     // 0x02D8(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                Scale[0x3];                                        // 0x04B8(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                ManualWeight;                                      // 0x0698(0x00A0)(NativeAccessSpecifierPrivate)
	bool                                          bUseQuaternionInterpolation;                       // 0x0738(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_739[0x7];                                      // 0x0739(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DTransformSection">();
	}
	static class UMovieScene3DTransformSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DTransformSection>();
	}
};
static_assert(alignof(UMovieScene3DTransformSection) == 0x000008, "Wrong alignment on UMovieScene3DTransformSection");
static_assert(sizeof(UMovieScene3DTransformSection) == 0x000740, "Wrong size on UMovieScene3DTransformSection");
static_assert(offsetof(UMovieScene3DTransformSection, TransformMask) == 0x0000F0, "Member 'UMovieScene3DTransformSection::TransformMask' has a wrong offset!");
static_assert(offsetof(UMovieScene3DTransformSection, Translation) == 0x0000F8, "Member 'UMovieScene3DTransformSection::Translation' has a wrong offset!");
static_assert(offsetof(UMovieScene3DTransformSection, Rotation) == 0x0002D8, "Member 'UMovieScene3DTransformSection::Rotation' has a wrong offset!");
static_assert(offsetof(UMovieScene3DTransformSection, Scale) == 0x0004B8, "Member 'UMovieScene3DTransformSection::Scale' has a wrong offset!");
static_assert(offsetof(UMovieScene3DTransformSection, ManualWeight) == 0x000698, "Member 'UMovieScene3DTransformSection::ManualWeight' has a wrong offset!");
static_assert(offsetof(UMovieScene3DTransformSection, bUseQuaternionInterpolation) == 0x000738, "Member 'UMovieScene3DTransformSection::bUseQuaternionInterpolation' has a wrong offset!");

// Class MovieSceneTracks.MovieScene3DTransformTrack
// 0x0000 (0x00C0 - 0x00C0)
class UMovieScene3DTransformTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScene3DTransformTrack">();
	}
	static class UMovieScene3DTransformTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScene3DTransformTrack>();
	}
};
static_assert(alignof(UMovieScene3DTransformTrack) == 0x000008, "Wrong alignment on UMovieScene3DTransformTrack");
static_assert(sizeof(UMovieScene3DTransformTrack) == 0x0000C0, "Wrong size on UMovieScene3DTransformTrack");

// Class MovieSceneTracks.MovieSceneActorReferenceSection
// 0x0140 (0x0228 - 0x00E8)
class UMovieSceneActorReferenceSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneActorReferenceData          ActorReferenceData;                                // 0x00E8(0x00B0)(NativeAccessSpecifierPrivate)
	struct FIntegralCurve                         ActorGuidIndexCurve;                               // 0x0198(0x0080)(Deprecated, NativeAccessSpecifierPrivate)
	TArray<class FString>                         ActorGuidStrings;                                  // 0x0218(0x0010)(ZeroConstructor, Deprecated, NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneActorReferenceSection">();
	}
	static class UMovieSceneActorReferenceSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneActorReferenceSection>();
	}
};
static_assert(alignof(UMovieSceneActorReferenceSection) == 0x000008, "Wrong alignment on UMovieSceneActorReferenceSection");
static_assert(sizeof(UMovieSceneActorReferenceSection) == 0x000228, "Wrong size on UMovieSceneActorReferenceSection");
static_assert(offsetof(UMovieSceneActorReferenceSection, ActorReferenceData) == 0x0000E8, "Member 'UMovieSceneActorReferenceSection::ActorReferenceData' has a wrong offset!");
static_assert(offsetof(UMovieSceneActorReferenceSection, ActorGuidIndexCurve) == 0x000198, "Member 'UMovieSceneActorReferenceSection::ActorGuidIndexCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneActorReferenceSection, ActorGuidStrings) == 0x000218, "Member 'UMovieSceneActorReferenceSection::ActorGuidStrings' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneActorReferenceTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneActorReferenceTrack final : public UMovieScenePropertyTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneAudioSection
// 0x0250 (0x0338 - 0x00E8)
class UMovieSceneAudioSection final : public UMovieSceneSection
{
public:
	class USoundBase*                             Sound;                                             // 0x00E8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FFrameNumber                           StartFrameOffset;                                  // 0x00F0(0x0004)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         StartOffset;                                       // 0x00F4(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         AudioStartTime;                                    // 0x00F8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         AudioDilationFactor;                               // 0x00FC(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         AudioVolume;                                       // 0x0100(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_104[0x4];                                      // 0x0104(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                SoundVolume;                                       // 0x0108(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                PitchMultiplier;                                   // 0x01A8(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneActorReferenceData          AttachActorData;                                   // 0x0248(0x00B0)(NativeAccessSpecifierPrivate)
	bool                                          bLooping;                                          // 0x02F8(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bSuppressSubtitles;                                // 0x02F9(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bOverrideAttenuation;                              // 0x02FA(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_2FB[0x5];                                      // 0x02FB(0x0005)(Fixing Size After Last Property [ Dumper-7 ])
	class USoundAttenuation*                      AttenuationSettings;                               // 0x0300(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	TDelegate<void(const TArray<struct FSubtitleCue>& Subtitles, float CueDuration)> OnQueueSubtitles; // 0x0308(0x0010)(ZeroConstructor, InstancedReference, NoDestructor, NativeAccessSpecifierPrivate)
	TMulticastInlineDelegate<void()>              OnAudioFinished;                                   // 0x0318(0x0010)(ZeroConstructor, InstancedReference, NativeAccessSpecifierPrivate)
	TMulticastInlineDelegate<void(const class USoundWave* PlayingSoundWave, const float PlaybackPercent)> OnAudioPlaybackPercent; // 0x0328(0x0010)(ZeroConstructor, InstancedReference, NativeAccessSpecifierPrivate)

public:
	void SetSound(class USoundBase* InSound);
	void SetStartOffset(const struct FFrameNumber& InStartOffset);

	class USoundBase* GetSound() const;
	struct FFrameNumber GetStartOffset() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneAudioSection">();
	}
	static class UMovieSceneAudioSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneAudioSection>();
	}
};
static_assert(alignof(UMovieSceneAudioSection) == 0x000008, "Wrong alignment on UMovieSceneAudioSection");
static_assert(sizeof(UMovieSceneAudioSection) == 0x000338, "Wrong size on UMovieSceneAudioSection");
static_assert(offsetof(UMovieSceneAudioSection, Sound) == 0x0000E8, "Member 'UMovieSceneAudioSection::Sound' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, StartFrameOffset) == 0x0000F0, "Member 'UMovieSceneAudioSection::StartFrameOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, StartOffset) == 0x0000F4, "Member 'UMovieSceneAudioSection::StartOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, AudioStartTime) == 0x0000F8, "Member 'UMovieSceneAudioSection::AudioStartTime' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, AudioDilationFactor) == 0x0000FC, "Member 'UMovieSceneAudioSection::AudioDilationFactor' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, AudioVolume) == 0x000100, "Member 'UMovieSceneAudioSection::AudioVolume' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, SoundVolume) == 0x000108, "Member 'UMovieSceneAudioSection::SoundVolume' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, PitchMultiplier) == 0x0001A8, "Member 'UMovieSceneAudioSection::PitchMultiplier' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, AttachActorData) == 0x000248, "Member 'UMovieSceneAudioSection::AttachActorData' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, bLooping) == 0x0002F8, "Member 'UMovieSceneAudioSection::bLooping' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, bSuppressSubtitles) == 0x0002F9, "Member 'UMovieSceneAudioSection::bSuppressSubtitles' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, bOverrideAttenuation) == 0x0002FA, "Member 'UMovieSceneAudioSection::bOverrideAttenuation' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, AttenuationSettings) == 0x000300, "Member 'UMovieSceneAudioSection::AttenuationSettings' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, OnQueueSubtitles) == 0x000308, "Member 'UMovieSceneAudioSection::OnQueueSubtitles' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, OnAudioFinished) == 0x000318, "Member 'UMovieSceneAudioSection::OnAudioFinished' has a wrong offset!");
static_assert(offsetof(UMovieSceneAudioSection, OnAudioPlaybackPercent) == 0x000328, "Member 'UMovieSceneAudioSection::OnAudioPlaybackPercent' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneAudioTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneAudioTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             AudioSections;                                     // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneBaseValueEvaluatorSystem
// 0x0000 (0x0040 - 0x0040)
class UMovieSceneBaseValueEvaluatorSystem final : public UMovieSceneEntitySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneBaseValueEvaluatorSystem">();
	}
	static class UMovieSceneBaseValueEvaluatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneBaseValueEvaluatorSystem>();
	}
};
static_assert(alignof(UMovieSceneBaseValueEvaluatorSystem) == 0x000008, "Wrong alignment on UMovieSceneBaseValueEvaluatorSystem");
static_assert(sizeof(UMovieSceneBaseValueEvaluatorSystem) == 0x000040, "Wrong size on UMovieSceneBaseValueEvaluatorSystem");

// Class MovieSceneTracks.MovieSceneBoolTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneBoolTrack : public UMovieScenePropertyTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneBytePropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneBytePropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneBytePropertySystem">();
	}
	static class UMovieSceneBytePropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneBytePropertySystem>();
	}
};
static_assert(alignof(UMovieSceneBytePropertySystem) == 0x000008, "Wrong alignment on UMovieSceneBytePropertySystem");
static_assert(sizeof(UMovieSceneBytePropertySystem) == 0x000058, "Wrong size on UMovieSceneBytePropertySystem");

// Class MovieSceneTracks.MovieSceneByteSection
// 0x00A0 (0x0188 - 0x00E8)
class UMovieSceneByteSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneByteChannel                 ByteCurve;                                         // 0x00F0(0x0098)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneCameraAnimSection
// 0x0040 (0x0128 - 0x00E8)
class UMovieSceneCameraAnimSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneCameraAnimSectionData       AnimData;                                          // 0x00E8(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	class UCameraAnim*                            CameraAnim;                                        // 0x0108(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         PlayRate;                                          // 0x0110(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         PlayScale;                                         // 0x0114(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         BlendInTime;                                       // 0x0118(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         BlendOutTime;                                      // 0x011C(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	bool                                          bLooping;                                          // 0x0120(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_121[0x7];                                      // 0x0121(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneCameraAnimSection">();
	}
	static class UMovieSceneCameraAnimSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneCameraAnimSection>();
	}
};
static_assert(alignof(UMovieSceneCameraAnimSection) == 0x000008, "Wrong alignment on UMovieSceneCameraAnimSection");
static_assert(sizeof(UMovieSceneCameraAnimSection) == 0x000128, "Wrong size on UMovieSceneCameraAnimSection");
static_assert(offsetof(UMovieSceneCameraAnimSection, AnimData) == 0x0000E8, "Member 'UMovieSceneCameraAnimSection::AnimData' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, CameraAnim) == 0x000108, "Member 'UMovieSceneCameraAnimSection::CameraAnim' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, PlayRate) == 0x000110, "Member 'UMovieSceneCameraAnimSection::PlayRate' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, PlayScale) == 0x000114, "Member 'UMovieSceneCameraAnimSection::PlayScale' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, BlendInTime) == 0x000118, "Member 'UMovieSceneCameraAnimSection::BlendInTime' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, BlendOutTime) == 0x00011C, "Member 'UMovieSceneCameraAnimSection::BlendOutTime' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraAnimSection, bLooping) == 0x000120, "Member 'UMovieSceneCameraAnimSection::bLooping' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneCameraAnimTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneCameraAnimTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             CameraAnimSections;                                // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneCameraCutSection
// 0x0078 (0x0160 - 0x00E8)
class UMovieSceneCameraCutSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	bool                                          bLockPreviousCamera;                               // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_F1[0x3];                                       // 0x00F1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FGuid                                  CameraGuid;                                        // 0x00F4(0x0010)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FMovieSceneObjectBindingID             CameraBindingID;                                   // 0x0104(0x0018)(Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_11C[0x4];                                      // 0x011C(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTransform                             InitialCameraCutTransform;                         // 0x0120(0x0030)(IsPlainOldData, NoDestructor, NativeAccessSpecifierPrivate)
	bool                                          bHasInitialCameraCutTransform;                     // 0x0150(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_151[0xF];                                      // 0x0151(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	void SetCameraBindingID(const struct FMovieSceneObjectBindingID& InCameraBindingID);

	const struct FMovieSceneObjectBindingID GetCameraBindingID() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneCameraCutSection">();
	}
	static class UMovieSceneCameraCutSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneCameraCutSection>();
	}
};
static_assert(alignof(UMovieSceneCameraCutSection) == 0x000010, "Wrong alignment on UMovieSceneCameraCutSection");
static_assert(sizeof(UMovieSceneCameraCutSection) == 0x000160, "Wrong size on UMovieSceneCameraCutSection");
static_assert(offsetof(UMovieSceneCameraCutSection, bLockPreviousCamera) == 0x0000F0, "Member 'UMovieSceneCameraCutSection::bLockPreviousCamera' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraCutSection, CameraGuid) == 0x0000F4, "Member 'UMovieSceneCameraCutSection::CameraGuid' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraCutSection, CameraBindingID) == 0x000104, "Member 'UMovieSceneCameraCutSection::CameraBindingID' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraCutSection, InitialCameraCutTransform) == 0x000120, "Member 'UMovieSceneCameraCutSection::InitialCameraCutTransform' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraCutSection, bHasInitialCameraCutTransform) == 0x000150, "Member 'UMovieSceneCameraCutSection::bHasInitialCameraCutTransform' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneCameraCutTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneCameraCutTrack final : public UMovieSceneNameableTrack
{
public:
	bool                                          bCanBlend;                                         // 0x0090(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_91[0x7];                                       // 0x0091(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneCameraCutTrackInstance
// 0x0068 (0x00B8 - 0x0050)
class UMovieSceneCameraCutTrackInstance final : public UMovieSceneTrackInstance
{
public:
	uint8                                         Pad_50[0x68];                                      // 0x0050(0x0068)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneCameraShakeSection
// 0x0040 (0x0128 - 0x00E8)
class UMovieSceneCameraShakeSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneCameraShakeSectionData      ShakeData;                                         // 0x00E8(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)
	TSubclassOf<class UCameraShakeBase>           ShakeClass;                                        // 0x0108(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PlayScale;                                         // 0x0110(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ECameraShakePlaySpace                         PlaySpace;                                         // 0x0114(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_115[0x3];                                      // 0x0115(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FRotator                               UserDefinedPlaySpace;                              // 0x0118(0x000C)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_124[0x4];                                      // 0x0124(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneCameraShakeSection">();
	}
	static class UMovieSceneCameraShakeSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneCameraShakeSection>();
	}
};
static_assert(alignof(UMovieSceneCameraShakeSection) == 0x000008, "Wrong alignment on UMovieSceneCameraShakeSection");
static_assert(sizeof(UMovieSceneCameraShakeSection) == 0x000128, "Wrong size on UMovieSceneCameraShakeSection");
static_assert(offsetof(UMovieSceneCameraShakeSection, ShakeData) == 0x0000E8, "Member 'UMovieSceneCameraShakeSection::ShakeData' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraShakeSection, ShakeClass) == 0x000108, "Member 'UMovieSceneCameraShakeSection::ShakeClass' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraShakeSection, PlayScale) == 0x000110, "Member 'UMovieSceneCameraShakeSection::PlayScale' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraShakeSection, PlaySpace) == 0x000114, "Member 'UMovieSceneCameraShakeSection::PlaySpace' has a wrong offset!");
static_assert(offsetof(UMovieSceneCameraShakeSection, UserDefinedPlaySpace) == 0x000118, "Member 'UMovieSceneCameraShakeSection::UserDefinedPlaySpace' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneCameraShakeSourceShakeSection
// 0x0020 (0x0108 - 0x00E8)
class UMovieSceneCameraShakeSourceShakeSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneCameraShakeSectionData      ShakeData;                                         // 0x00E8(0x0020)(Edit, NoDestructor, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneCameraShakeSourceShakeSection">();
	}
	static class UMovieSceneCameraShakeSourceShakeSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneCameraShakeSourceShakeSection>();
	}
};
static_assert(alignof(UMovieSceneCameraShakeSourceShakeSection) == 0x000008, "Wrong alignment on UMovieSceneCameraShakeSourceShakeSection");
static_assert(sizeof(UMovieSceneCameraShakeSourceShakeSection) == 0x000108, "Wrong size on UMovieSceneCameraShakeSourceShakeSection");
static_assert(offsetof(UMovieSceneCameraShakeSourceShakeSection, ShakeData) == 0x0000E8, "Member 'UMovieSceneCameraShakeSourceShakeSection::ShakeData' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneCameraShakeSourceShakeTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneCameraShakeSourceShakeTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             CameraShakeSections;                               // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneCameraShakeSourceTriggerSection
// 0x0088 (0x0170 - 0x00E8)
class UMovieSceneCameraShakeSourceTriggerSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneCameraShakeSourceTriggerChannel Channel;                                       // 0x00E8(0x0088)(NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneCameraShakeSourceTriggerTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneCameraShakeSourceTriggerTrack final : public UMovieSceneTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, Protected, NativeAccessSpecifierProtected)

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

// Class MovieSceneTracks.MovieSceneCameraShakeTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneCameraShakeTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             CameraShakeSections;                               // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneCinematicShotSection
// 0x0028 (0x0190 - 0x0168)
class UMovieSceneCinematicShotSection final : public UMovieSceneSubSection
{
public:
	class FString                                 ShotDisplayName;                                   // 0x0168(0x0010)(ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class FText                                   DisplayName;                                       // 0x0178(0x0018)(Deprecated, NativeAccessSpecifierPrivate)

public:
	void SetShotDisplayName(const class FString& InShotDisplayName);

	class FString GetShotDisplayName() const;

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneCinematicShotSection">();
	}
	static class UMovieSceneCinematicShotSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneCinematicShotSection>();
	}
};
static_assert(alignof(UMovieSceneCinematicShotSection) == 0x000008, "Wrong alignment on UMovieSceneCinematicShotSection");
static_assert(sizeof(UMovieSceneCinematicShotSection) == 0x000190, "Wrong size on UMovieSceneCinematicShotSection");
static_assert(offsetof(UMovieSceneCinematicShotSection, ShotDisplayName) == 0x000168, "Member 'UMovieSceneCinematicShotSection::ShotDisplayName' has a wrong offset!");
static_assert(offsetof(UMovieSceneCinematicShotSection, DisplayName) == 0x000178, "Member 'UMovieSceneCinematicShotSection::DisplayName' has a wrong offset!");

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

// Class MovieSceneTracks.MovieSceneColorPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneColorPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneColorPropertySystem">();
	}
	static class UMovieSceneColorPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneColorPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneColorPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneColorPropertySystem");
static_assert(sizeof(UMovieSceneColorPropertySystem) == 0x000058, "Wrong size on UMovieSceneColorPropertySystem");

// Class MovieSceneTracks.MovieSceneColorSection
// 0x0288 (0x0370 - 0x00E8)
class UMovieSceneColorSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                RedCurve;                                          // 0x00F0(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                GreenCurve;                                        // 0x0190(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                BlueCurve;                                         // 0x0230(0x00A0)(NativeAccessSpecifierPrivate)
	struct FMovieSceneFloatChannel                AlphaCurve;                                        // 0x02D0(0x00A0)(NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneColorSection">();
	}
	static class UMovieSceneColorSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneColorSection>();
	}
};
static_assert(alignof(UMovieSceneColorSection) == 0x000008, "Wrong alignment on UMovieSceneColorSection");
static_assert(sizeof(UMovieSceneColorSection) == 0x000370, "Wrong size on UMovieSceneColorSection");
static_assert(offsetof(UMovieSceneColorSection, RedCurve) == 0x0000F0, "Member 'UMovieSceneColorSection::RedCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneColorSection, GreenCurve) == 0x000190, "Member 'UMovieSceneColorSection::GreenCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneColorSection, BlueCurve) == 0x000230, "Member 'UMovieSceneColorSection::BlueCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneColorSection, AlphaCurve) == 0x0002D0, "Member 'UMovieSceneColorSection::AlphaCurve' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneColorTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneColorTrack final : public UMovieScenePropertyTrack
{
public:
	bool                                          bIsSlateColor;                                     // 0x00C0(0x0001)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C1[0x7];                                       // 0x00C1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneColorTrack">();
	}
	static class UMovieSceneColorTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneColorTrack>();
	}
};
static_assert(alignof(UMovieSceneColorTrack) == 0x000008, "Wrong alignment on UMovieSceneColorTrack");
static_assert(sizeof(UMovieSceneColorTrack) == 0x0000C8, "Wrong size on UMovieSceneColorTrack");
static_assert(offsetof(UMovieSceneColorTrack, bIsSlateColor) == 0x0000C0, "Member 'UMovieSceneColorTrack::bIsSlateColor' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneComponentAttachmentInvalidatorSystem
// 0x0000 (0x0040 - 0x0040)
class UMovieSceneComponentAttachmentInvalidatorSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneComponentAttachmentInvalidatorSystem">();
	}
	static class UMovieSceneComponentAttachmentInvalidatorSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneComponentAttachmentInvalidatorSystem>();
	}
};
static_assert(alignof(UMovieSceneComponentAttachmentInvalidatorSystem) == 0x000008, "Wrong alignment on UMovieSceneComponentAttachmentInvalidatorSystem");
static_assert(sizeof(UMovieSceneComponentAttachmentInvalidatorSystem) == 0x000040, "Wrong size on UMovieSceneComponentAttachmentInvalidatorSystem");

// Class MovieSceneTracks.MovieSceneComponentAttachmentSystem
// 0x0180 (0x01C0 - 0x0040)
class UMovieSceneComponentAttachmentSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	uint8                                         Pad_40[0x180];                                     // 0x0040(0x0180)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneComponentMobilitySystem
// 0x01E0 (0x0220 - 0x0040)
class UMovieSceneComponentMobilitySystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	uint8                                         Pad_40[0x1E0];                                     // 0x0040(0x01E0)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneComponentTransformSystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneComponentTransformSystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneComponentTransformSystem">();
	}
	static class UMovieSceneComponentTransformSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneComponentTransformSystem>();
	}
};
static_assert(alignof(UMovieSceneComponentTransformSystem) == 0x000008, "Wrong alignment on UMovieSceneComponentTransformSystem");
static_assert(sizeof(UMovieSceneComponentTransformSystem) == 0x000058, "Wrong size on UMovieSceneComponentTransformSystem");

// Class MovieSceneTracks.MovieSceneDeferredComponentMovementSystem
// 0x0018 (0x0058 - 0x0040)
class UMovieSceneDeferredComponentMovementSystem final : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x18];                                      // 0x0040(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneEnumPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneEnumPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEnumPropertySystem">();
	}
	static class UMovieSceneEnumPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEnumPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneEnumPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneEnumPropertySystem");
static_assert(sizeof(UMovieSceneEnumPropertySystem) == 0x000058, "Wrong size on UMovieSceneEnumPropertySystem");

// Class MovieSceneTracks.MovieSceneEnumSection
// 0x00A0 (0x0188 - 0x00E8)
class UMovieSceneEnumSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneByteChannel                 EnumCurve;                                         // 0x00F0(0x0098)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneEnumTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneEnumTrack final : public UMovieScenePropertyTrack
{
public:
	class UEnum*                                  Enum;                                              // 0x00C0(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEnumTrack">();
	}
	static class UMovieSceneEnumTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEnumTrack>();
	}
};
static_assert(alignof(UMovieSceneEnumTrack) == 0x000008, "Wrong alignment on UMovieSceneEnumTrack");
static_assert(sizeof(UMovieSceneEnumTrack) == 0x0000C8, "Wrong size on UMovieSceneEnumTrack");
static_assert(offsetof(UMovieSceneEnumTrack, Enum) == 0x0000C0, "Member 'UMovieSceneEnumTrack::Enum' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneEulerTransformPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneEulerTransformPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEulerTransformPropertySystem">();
	}
	static class UMovieSceneEulerTransformPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEulerTransformPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneEulerTransformPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneEulerTransformPropertySystem");
static_assert(sizeof(UMovieSceneEulerTransformPropertySystem) == 0x000058, "Wrong size on UMovieSceneEulerTransformPropertySystem");

// Class MovieSceneTracks.MovieSceneEulerTransformTrack
// 0x0000 (0x00C0 - 0x00C0)
class UMovieSceneEulerTransformTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEulerTransformTrack">();
	}
	static class UMovieSceneEulerTransformTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEulerTransformTrack>();
	}
};
static_assert(alignof(UMovieSceneEulerTransformTrack) == 0x000008, "Wrong alignment on UMovieSceneEulerTransformTrack");
static_assert(sizeof(UMovieSceneEulerTransformTrack) == 0x0000C0, "Wrong size on UMovieSceneEulerTransformTrack");

// Class MovieSceneTracks.MovieSceneEventSectionBase
// 0x0000 (0x00E8 - 0x00E8)
class UMovieSceneEventSectionBase : public UMovieSceneSection
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEventSectionBase">();
	}
	static class UMovieSceneEventSectionBase* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEventSectionBase>();
	}
};
static_assert(alignof(UMovieSceneEventSectionBase) == 0x000008, "Wrong alignment on UMovieSceneEventSectionBase");
static_assert(sizeof(UMovieSceneEventSectionBase) == 0x0000E8, "Wrong size on UMovieSceneEventSectionBase");

// Class MovieSceneTracks.MovieSceneEventRepeaterSection
// 0x0030 (0x0118 - 0x00E8)
class UMovieSceneEventRepeaterSection final : public UMovieSceneEventSectionBase
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneEvent                       Event;                                             // 0x00F0(0x0028)(Edit, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEventRepeaterSection">();
	}
	static class UMovieSceneEventRepeaterSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEventRepeaterSection>();
	}
};
static_assert(alignof(UMovieSceneEventRepeaterSection) == 0x000008, "Wrong alignment on UMovieSceneEventRepeaterSection");
static_assert(sizeof(UMovieSceneEventRepeaterSection) == 0x000118, "Wrong size on UMovieSceneEventRepeaterSection");
static_assert(offsetof(UMovieSceneEventRepeaterSection, Event) == 0x0000F0, "Member 'UMovieSceneEventRepeaterSection::Event' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneEventSection
// 0x0100 (0x01E8 - 0x00E8)
class UMovieSceneEventSection final : public UMovieSceneSection
{
public:
	struct FNameCurve                             Events;                                            // 0x00E8(0x0078)(Deprecated, NativeAccessSpecifierPrivate)
	struct FMovieSceneEventSectionData            EventData;                                         // 0x0160(0x0088)(NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneEventSection">();
	}
	static class UMovieSceneEventSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneEventSection>();
	}
};
static_assert(alignof(UMovieSceneEventSection) == 0x000008, "Wrong alignment on UMovieSceneEventSection");
static_assert(sizeof(UMovieSceneEventSection) == 0x0001E8, "Wrong size on UMovieSceneEventSection");
static_assert(offsetof(UMovieSceneEventSection, Events) == 0x0000E8, "Member 'UMovieSceneEventSection::Events' has a wrong offset!");
static_assert(offsetof(UMovieSceneEventSection, EventData) == 0x000160, "Member 'UMovieSceneEventSection::EventData' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneEventSystem
// 0x0050 (0x0090 - 0x0040)
class UMovieSceneEventSystem : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x50];                                      // 0x0040(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePreSpawnEventSystem
// 0x0000 (0x0090 - 0x0090)
class UMovieScenePreSpawnEventSystem final : public UMovieSceneEventSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScenePreSpawnEventSystem">();
	}
	static class UMovieScenePreSpawnEventSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScenePreSpawnEventSystem>();
	}
};
static_assert(alignof(UMovieScenePreSpawnEventSystem) == 0x000008, "Wrong alignment on UMovieScenePreSpawnEventSystem");
static_assert(sizeof(UMovieScenePreSpawnEventSystem) == 0x000090, "Wrong size on UMovieScenePreSpawnEventSystem");

// Class MovieSceneTracks.MovieScenePostSpawnEventSystem
// 0x0000 (0x0090 - 0x0090)
class UMovieScenePostSpawnEventSystem final : public UMovieSceneEventSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScenePostSpawnEventSystem">();
	}
	static class UMovieScenePostSpawnEventSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScenePostSpawnEventSystem>();
	}
};
static_assert(alignof(UMovieScenePostSpawnEventSystem) == 0x000008, "Wrong alignment on UMovieScenePostSpawnEventSystem");
static_assert(sizeof(UMovieScenePostSpawnEventSystem) == 0x000090, "Wrong size on UMovieScenePostSpawnEventSystem");

// Class MovieSceneTracks.MovieScenePostEvalEventSystem
// 0x0000 (0x0090 - 0x0090)
class UMovieScenePostEvalEventSystem final : public UMovieSceneEventSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScenePostEvalEventSystem">();
	}
	static class UMovieScenePostEvalEventSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScenePostEvalEventSystem>();
	}
};
static_assert(alignof(UMovieScenePostEvalEventSystem) == 0x000008, "Wrong alignment on UMovieScenePostEvalEventSystem");
static_assert(sizeof(UMovieScenePostEvalEventSystem) == 0x000090, "Wrong size on UMovieScenePostEvalEventSystem");

// Class MovieSceneTracks.MovieSceneEventTrack
// 0x0028 (0x00B8 - 0x0090)
class UMovieSceneEventTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x10];                                      // 0x0090(0x0010)(Fixing Size After Last Property [ Dumper-7 ])
	uint8                                         bFireEventsWhenForwards : 1;                       // 0x00A0(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         bFireEventsWhenBackwards : 1;                      // 0x00A0(0x0001)(BitIndex: 0x01, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_A1[0x3];                                       // 0x00A1(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	EFireEventsAtPosition                         EventPosition;                                     // 0x00A4(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A5[0x3];                                       // 0x00A5(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x00A8(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneEventTriggerSection
// 0x0090 (0x0178 - 0x00E8)
class UMovieSceneEventTriggerSection final : public UMovieSceneEventSectionBase
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneEventChannel                EventChannel;                                      // 0x00F0(0x0088)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneFadeSection
// 0x00B8 (0x01A0 - 0x00E8)
class UMovieSceneFadeSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneFloatChannel                FloatCurve;                                        // 0x00E8(0x00A0)(NativeAccessSpecifierPublic)
	struct FLinearColor                           FadeColor;                                         // 0x0188(0x0010)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         bFadeAudio : 1;                                    // 0x0198(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Edit, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic))
	uint8                                         Pad_199[0x7];                                      // 0x0199(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneFadeSection">();
	}
	static class UMovieSceneFadeSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneFadeSection>();
	}
};
static_assert(alignof(UMovieSceneFadeSection) == 0x000008, "Wrong alignment on UMovieSceneFadeSection");
static_assert(sizeof(UMovieSceneFadeSection) == 0x0001A0, "Wrong size on UMovieSceneFadeSection");
static_assert(offsetof(UMovieSceneFadeSection, FloatCurve) == 0x0000E8, "Member 'UMovieSceneFadeSection::FloatCurve' has a wrong offset!");
static_assert(offsetof(UMovieSceneFadeSection, FadeColor) == 0x000188, "Member 'UMovieSceneFadeSection::FadeColor' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneFloatTrack
// 0x0000 (0x00C0 - 0x00C0)
class UMovieSceneFloatTrack : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneFloatTrack">();
	}
	static class UMovieSceneFloatTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneFloatTrack>();
	}
};
static_assert(alignof(UMovieSceneFloatTrack) == 0x000008, "Wrong alignment on UMovieSceneFloatTrack");
static_assert(sizeof(UMovieSceneFloatTrack) == 0x0000C0, "Wrong size on UMovieSceneFloatTrack");

// Class MovieSceneTracks.MovieSceneFadeTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneFadeTrack final : public UMovieSceneFloatTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneFloatPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneFloatPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneFloatPropertySystem">();
	}
	static class UMovieSceneFloatPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneFloatPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneFloatPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneFloatPropertySystem");
static_assert(sizeof(UMovieSceneFloatPropertySystem) == 0x000058, "Wrong size on UMovieSceneFloatPropertySystem");

// Class MovieSceneTracks.MovieSceneFloatSection
// 0x00A8 (0x0190 - 0x00E8)
class UMovieSceneFloatSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                FloatCurve;                                        // 0x00F0(0x00A0)(Protected, NativeAccessSpecifierProtected)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneFloatSection">();
	}
	static class UMovieSceneFloatSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneFloatSection>();
	}
};
static_assert(alignof(UMovieSceneFloatSection) == 0x000008, "Wrong alignment on UMovieSceneFloatSection");
static_assert(sizeof(UMovieSceneFloatSection) == 0x000190, "Wrong size on UMovieSceneFloatSection");
static_assert(offsetof(UMovieSceneFloatSection, FloatCurve) == 0x0000F0, "Member 'UMovieSceneFloatSection::FloatCurve' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneHierarchicalBiasSystem
// 0x0000 (0x0040 - 0x0040)
class UMovieSceneHierarchicalBiasSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneHierarchicalBiasSystem">();
	}
	static class UMovieSceneHierarchicalBiasSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneHierarchicalBiasSystem>();
	}
};
static_assert(alignof(UMovieSceneHierarchicalBiasSystem) == 0x000008, "Wrong alignment on UMovieSceneHierarchicalBiasSystem");
static_assert(sizeof(UMovieSceneHierarchicalBiasSystem) == 0x000040, "Wrong size on UMovieSceneHierarchicalBiasSystem");

// Class MovieSceneTracks.MovieSceneInitialValueSystem
// 0x0000 (0x0040 - 0x0040)
class UMovieSceneInitialValueSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneInitialValueSystem">();
	}
	static class UMovieSceneInitialValueSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneInitialValueSystem>();
	}
};
static_assert(alignof(UMovieSceneInitialValueSystem) == 0x000008, "Wrong alignment on UMovieSceneInitialValueSystem");
static_assert(sizeof(UMovieSceneInitialValueSystem) == 0x000040, "Wrong size on UMovieSceneInitialValueSystem");

// Class MovieSceneTracks.MovieSceneIntegerPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneIntegerPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneIntegerPropertySystem">();
	}
	static class UMovieSceneIntegerPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneIntegerPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneIntegerPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneIntegerPropertySystem");
static_assert(sizeof(UMovieSceneIntegerPropertySystem) == 0x000058, "Wrong size on UMovieSceneIntegerPropertySystem");

// Class MovieSceneTracks.MovieSceneIntegerSection
// 0x0098 (0x0180 - 0x00E8)
class UMovieSceneIntegerSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneIntegerChannel              IntegerCurve;                                      // 0x00F0(0x0090)(NativeAccessSpecifierPrivate)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneIntegerSection">();
	}
	static class UMovieSceneIntegerSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneIntegerSection>();
	}
};
static_assert(alignof(UMovieSceneIntegerSection) == 0x000008, "Wrong alignment on UMovieSceneIntegerSection");
static_assert(sizeof(UMovieSceneIntegerSection) == 0x000180, "Wrong size on UMovieSceneIntegerSection");
static_assert(offsetof(UMovieSceneIntegerSection, IntegerCurve) == 0x0000F0, "Member 'UMovieSceneIntegerSection::IntegerCurve' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneIntegerTrack
// 0x0000 (0x00C0 - 0x00C0)
class UMovieSceneIntegerTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneIntegerTrack">();
	}
	static class UMovieSceneIntegerTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneIntegerTrack>();
	}
};
static_assert(alignof(UMovieSceneIntegerTrack) == 0x000008, "Wrong alignment on UMovieSceneIntegerTrack");
static_assert(sizeof(UMovieSceneIntegerTrack) == 0x0000C0, "Wrong size on UMovieSceneIntegerTrack");

// Class MovieSceneTracks.MovieSceneInterrogatedPropertyInstantiatorSystem
// 0x01A8 (0x01E8 - 0x0040)
class UMovieSceneInterrogatedPropertyInstantiatorSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	uint8                                         Pad_40[0x1A8];                                     // 0x0040(0x01A8)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneLevelVisibilitySection
// 0x0020 (0x0108 - 0x00E8)
class UMovieSceneLevelVisibilitySection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	ELevelVisibility                              Visibility;                                        // 0x00F0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_F1[0x7];                                       // 0x00F1(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class FName>                           LevelNames;                                        // 0x00F8(0x0010)(Edit, ZeroConstructor, NativeAccessSpecifierPrivate)

public:
	void SetLevelNames(const TArray<class FName>& InLevelNames);
	void SetVisibility(ELevelVisibility InVisibility);

	const TArray<class FName> GetLevelNames() const;
	ELevelVisibility GetVisibility() const;

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

// Class MovieSceneTracks.MovieSceneLevelVisibilitySystem
// 0x0168 (0x01A8 - 0x0040)
class UMovieSceneLevelVisibilitySystem final : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x168];                                     // 0x0040(0x0168)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

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

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

// Class MovieSceneTracks.MovieSceneMaterialTrack
// 0x0010 (0x00A0 - 0x0090)
class UMovieSceneMaterialTrack : public UMovieSceneNameableTrack
{
public:
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x0090(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneMaterialParameterCollectionTrack
// 0x0010 (0x00B0 - 0x00A0)
class UMovieSceneMaterialParameterCollectionTrack final : public UMovieSceneMaterialTrack
{
public:
	uint8                                         Pad_A0[0x8];                                       // 0x00A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UMaterialParameterCollection*           MPC;                                               // 0x00A8(0x0008)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneComponentMaterialTrack
// 0x0010 (0x00B0 - 0x00A0)
class UMovieSceneComponentMaterialTrack final : public UMovieSceneMaterialTrack
{
public:
	uint8                                         Pad_A0[0x8];                                       // 0x00A0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaterialIndex;                                     // 0x00A8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_AC[0x4];                                       // 0x00AC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneMotionVectorSimulationSystem
// 0x0058 (0x0098 - 0x0040)
class UMovieSceneMotionVectorSimulationSystem final : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x58];                                      // 0x0040(0x0058)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneObjectPropertySection
// 0x00C0 (0x01A8 - 0x00E8)
class UMovieSceneObjectPropertySection final : public UMovieSceneSection
{
public:
	struct FMovieSceneObjectPathChannel           ObjectChannel;                                     // 0x00E8(0x00C0)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneObjectPropertyTrack
// 0x0010 (0x00D0 - 0x00C0)
class UMovieSceneObjectPropertyTrack final : public UMovieScenePropertyTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	class UClass*                                 PropertyClass;                                     // 0x00C8(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneObjectPropertyTrack">();
	}
	static class UMovieSceneObjectPropertyTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneObjectPropertyTrack>();
	}
};
static_assert(alignof(UMovieSceneObjectPropertyTrack) == 0x000008, "Wrong alignment on UMovieSceneObjectPropertyTrack");
static_assert(sizeof(UMovieSceneObjectPropertyTrack) == 0x0000D0, "Wrong size on UMovieSceneObjectPropertyTrack");
static_assert(offsetof(UMovieSceneObjectPropertyTrack, PropertyClass) == 0x0000C8, "Member 'UMovieSceneObjectPropertyTrack::PropertyClass' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneParticleParameterTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneParticleParameterTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             Sections;                                          // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneParticleSection
// 0x0098 (0x0180 - 0x00E8)
class UMovieSceneParticleSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneParticleChannel             ParticleKeys;                                      // 0x00E8(0x0098)(NativeAccessSpecifierPublic)

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneParticleSection">();
	}
	static class UMovieSceneParticleSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneParticleSection>();
	}
};
static_assert(alignof(UMovieSceneParticleSection) == 0x000008, "Wrong alignment on UMovieSceneParticleSection");
static_assert(sizeof(UMovieSceneParticleSection) == 0x000180, "Wrong size on UMovieSceneParticleSection");
static_assert(offsetof(UMovieSceneParticleSection, ParticleKeys) == 0x0000E8, "Member 'UMovieSceneParticleSection::ParticleKeys' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneParticleTrack
// 0x0018 (0x00A8 - 0x0090)
class UMovieSceneParticleTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             ParticleSections;                                  // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieScenePiecewiseBoolBlenderSystem
// 0x0028 (0x0090 - 0x0068)
class UMovieScenePiecewiseBoolBlenderSystem final : public UMovieSceneBlenderSystem
{
public:
	uint8                                         Pad_68[0x28];                                      // 0x0068(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePiecewiseByteBlenderSystem
// 0x0028 (0x0090 - 0x0068)
class UMovieScenePiecewiseByteBlenderSystem final : public UMovieSceneBlenderSystem
{
public:
	uint8                                         Pad_68[0x28];                                      // 0x0068(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePiecewiseEnumBlenderSystem
// 0x0028 (0x0090 - 0x0068)
class UMovieScenePiecewiseEnumBlenderSystem final : public UMovieSceneBlenderSystem
{
public:
	uint8                                         Pad_68[0x28];                                      // 0x0068(0x0028)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePiecewiseFloatBlenderSystem
// 0x00C0 (0x0128 - 0x0068)
class UMovieScenePiecewiseFloatBlenderSystem final : public UMovieSceneBlenderSystem
{
public:
	uint8                                         Pad_68[0xC0];                                      // 0x0068(0x00C0)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePiecewiseIntegerBlenderSystem
// 0x0048 (0x00B0 - 0x0068)
class UMovieScenePiecewiseIntegerBlenderSystem final : public UMovieSceneBlenderSystem
{
public:
	uint8                                         Pad_68[0x48];                                      // 0x0068(0x0048)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieScenePrimitiveMaterialSection
// 0x00C0 (0x01A8 - 0x00E8)
class UMovieScenePrimitiveMaterialSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneObjectPathChannel           MaterialChannel;                                   // 0x00E8(0x00C0)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieScenePrimitiveMaterialTrack
// 0x0010 (0x00D0 - 0x00C0)
class UMovieScenePrimitiveMaterialTrack final : public UMovieScenePropertyTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	int32                                         MaterialIndex;                                     // 0x00C8(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_CC[0x4];                                       // 0x00CC(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieScenePrimitiveMaterialTrack">();
	}
	static class UMovieScenePrimitiveMaterialTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieScenePrimitiveMaterialTrack>();
	}
};
static_assert(alignof(UMovieScenePrimitiveMaterialTrack) == 0x000008, "Wrong alignment on UMovieScenePrimitiveMaterialTrack");
static_assert(sizeof(UMovieScenePrimitiveMaterialTrack) == 0x0000D0, "Wrong size on UMovieScenePrimitiveMaterialTrack");
static_assert(offsetof(UMovieScenePrimitiveMaterialTrack, MaterialIndex) == 0x0000C8, "Member 'UMovieScenePrimitiveMaterialTrack::MaterialIndex' has a wrong offset!");

// Class MovieSceneTracks.MovieScenePropertyInstantiatorSystem
// 0x0208 (0x0248 - 0x0040)
class UMovieScenePropertyInstantiatorSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	uint8                                         Pad_40[0x208];                                     // 0x0040(0x0208)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneQuaternionInterpolationRotationSystem
// 0x0000 (0x0040 - 0x0040)
class UMovieSceneQuaternionInterpolationRotationSystem final : public UMovieSceneEntitySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneQuaternionInterpolationRotationSystem">();
	}
	static class UMovieSceneQuaternionInterpolationRotationSystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneQuaternionInterpolationRotationSystem>();
	}
};
static_assert(alignof(UMovieSceneQuaternionInterpolationRotationSystem) == 0x000008, "Wrong alignment on UMovieSceneQuaternionInterpolationRotationSystem");
static_assert(sizeof(UMovieSceneQuaternionInterpolationRotationSystem) == 0x000040, "Wrong size on UMovieSceneQuaternionInterpolationRotationSystem");

// Class MovieSceneTracks.MovieSceneSkeletalAnimationSection
// 0x0188 (0x0270 - 0x00E8)
class alignas(0x10) UMovieSceneSkeletalAnimationSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneSkeletalAnimationParams     Params_0;                                          // 0x00E8(0x00D8)(Edit, BlueprintVisible, NativeAccessSpecifierPublic)
	class UAnimSequence*                          AnimSequence;                                      // 0x01C0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	class UAnimSequenceBase*                      Animation;                                         // 0x01C8(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         StartOffset;                                       // 0x01D0(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         EndOffset;                                         // 0x01D4(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	float                                         PlayRate;                                          // 0x01D8(0x0004)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         bReverse : 1;                                      // 0x01DC(0x0001)(BitIndex: 0x00, PropSize: 0x0001 (Deprecated, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate))
	uint8                                         Pad_1DD[0x3];                                      // 0x01DD(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   SlotName;                                          // 0x01E0(0x0008)(ZeroConstructor, Deprecated, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	struct FVector                                StartLocationOffset;                               // 0x01E8(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               StartRotationOffset;                               // 0x01F4(0x000C)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bMatchWithPrevious;                                // 0x0200(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_201[0x3];                                      // 0x0201(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	class FName                                   MatchedBoneName;                                   // 0x0204(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FVector                                MatchedLocationOffset;                             // 0x020C(0x000C)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FRotator                               MatchedRotationOffset;                             // 0x0218(0x000C)(ZeroConstructor, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
	bool                                          bMatchTranslation;                                 // 0x0224(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchIncludeZHeight;                              // 0x0225(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchRotationYaw;                                 // 0x0226(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchRotationPitch;                               // 0x0227(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bMatchRotationRoll;                                // 0x0228(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_229[0x47];                                     // 0x0229(0x0047)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneSkeletalAnimationSection">();
	}
	static class UMovieSceneSkeletalAnimationSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneSkeletalAnimationSection>();
	}
};
static_assert(alignof(UMovieSceneSkeletalAnimationSection) == 0x000010, "Wrong alignment on UMovieSceneSkeletalAnimationSection");
static_assert(sizeof(UMovieSceneSkeletalAnimationSection) == 0x000270, "Wrong size on UMovieSceneSkeletalAnimationSection");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, Params_0) == 0x0000E8, "Member 'UMovieSceneSkeletalAnimationSection::Params_0' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, AnimSequence) == 0x0001C0, "Member 'UMovieSceneSkeletalAnimationSection::AnimSequence' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, Animation) == 0x0001C8, "Member 'UMovieSceneSkeletalAnimationSection::Animation' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, StartOffset) == 0x0001D0, "Member 'UMovieSceneSkeletalAnimationSection::StartOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, EndOffset) == 0x0001D4, "Member 'UMovieSceneSkeletalAnimationSection::EndOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, PlayRate) == 0x0001D8, "Member 'UMovieSceneSkeletalAnimationSection::PlayRate' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, SlotName) == 0x0001E0, "Member 'UMovieSceneSkeletalAnimationSection::SlotName' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, StartLocationOffset) == 0x0001E8, "Member 'UMovieSceneSkeletalAnimationSection::StartLocationOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, StartRotationOffset) == 0x0001F4, "Member 'UMovieSceneSkeletalAnimationSection::StartRotationOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchWithPrevious) == 0x000200, "Member 'UMovieSceneSkeletalAnimationSection::bMatchWithPrevious' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, MatchedBoneName) == 0x000204, "Member 'UMovieSceneSkeletalAnimationSection::MatchedBoneName' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, MatchedLocationOffset) == 0x00020C, "Member 'UMovieSceneSkeletalAnimationSection::MatchedLocationOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, MatchedRotationOffset) == 0x000218, "Member 'UMovieSceneSkeletalAnimationSection::MatchedRotationOffset' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchTranslation) == 0x000224, "Member 'UMovieSceneSkeletalAnimationSection::bMatchTranslation' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchIncludeZHeight) == 0x000225, "Member 'UMovieSceneSkeletalAnimationSection::bMatchIncludeZHeight' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchRotationYaw) == 0x000226, "Member 'UMovieSceneSkeletalAnimationSection::bMatchRotationYaw' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchRotationPitch) == 0x000227, "Member 'UMovieSceneSkeletalAnimationSection::bMatchRotationPitch' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationSection, bMatchRotationRoll) == 0x000228, "Member 'UMovieSceneSkeletalAnimationSection::bMatchRotationRoll' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneSkeletalAnimationTrack
// 0x0058 (0x00E8 - 0x0090)
class UMovieSceneSkeletalAnimationTrack final : public UMovieSceneNameableTrack
{
public:
	uint8                                         Pad_90[0x8];                                       // 0x0090(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	TArray<class UMovieSceneSection*>             AnimationSections;                                 // 0x0098(0x0010)(ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPublic)
	bool                                          bUseLegacySectionIndexBlend;                       // 0x00A8(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_A9[0x7];                                       // 0x00A9(0x0007)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneSkeletalAnimRootMotionTrackParams RootMotionParams;                            // 0x00B0(0x0030)(NativeAccessSpecifierPublic)
	bool                                          bBlendFirstChildOfRoot;                            // 0x00E0(0x0001)(Edit, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_E1[0x7];                                       // 0x00E1(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneSkeletalAnimationTrack">();
	}
	static class UMovieSceneSkeletalAnimationTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneSkeletalAnimationTrack>();
	}
};
static_assert(alignof(UMovieSceneSkeletalAnimationTrack) == 0x000008, "Wrong alignment on UMovieSceneSkeletalAnimationTrack");
static_assert(sizeof(UMovieSceneSkeletalAnimationTrack) == 0x0000E8, "Wrong size on UMovieSceneSkeletalAnimationTrack");
static_assert(offsetof(UMovieSceneSkeletalAnimationTrack, AnimationSections) == 0x000098, "Member 'UMovieSceneSkeletalAnimationTrack::AnimationSections' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationTrack, bUseLegacySectionIndexBlend) == 0x0000A8, "Member 'UMovieSceneSkeletalAnimationTrack::bUseLegacySectionIndexBlend' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationTrack, RootMotionParams) == 0x0000B0, "Member 'UMovieSceneSkeletalAnimationTrack::RootMotionParams' has a wrong offset!");
static_assert(offsetof(UMovieSceneSkeletalAnimationTrack, bBlendFirstChildOfRoot) == 0x0000E0, "Member 'UMovieSceneSkeletalAnimationTrack::bBlendFirstChildOfRoot' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneSlomoSection
// 0x00A0 (0x0188 - 0x00E8)
class UMovieSceneSlomoSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneFloatChannel                FloatCurve;                                        // 0x00E8(0x00A0)(NativeAccessSpecifierPublic)

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

// Class MovieSceneTracks.MovieSceneSlomoTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneSlomoTrack final : public UMovieSceneFloatTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneStringSection
// 0x00A0 (0x0188 - 0x00E8)
class UMovieSceneStringSection final : public UMovieSceneSection
{
public:
	struct FMovieSceneStringChannel               StringCurve;                                       // 0x00E8(0x00A0)(NativeAccessSpecifierPrivate)

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

// Class MovieSceneTracks.MovieSceneStringTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneStringTrack final : public UMovieScenePropertyTrack
{
public:
	uint8                                         Pad_C0[0x8];                                       // 0x00C0(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneTransformOriginSystem
// 0x0038 (0x0078 - 0x0040)
class UMovieSceneTransformOriginSystem final : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x38];                                      // 0x0040(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.MovieSceneTransformTrack
// 0x0000 (0x00C0 - 0x00C0)
class UMovieSceneTransformTrack final : public UMovieScenePropertyTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneTransformTrack">();
	}
	static class UMovieSceneTransformTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneTransformTrack>();
	}
};
static_assert(alignof(UMovieSceneTransformTrack) == 0x000008, "Wrong alignment on UMovieSceneTransformTrack");
static_assert(sizeof(UMovieSceneTransformTrack) == 0x0000C0, "Wrong size on UMovieSceneTransformTrack");

// Class MovieSceneTracks.MovieSceneVectorPropertySystem
// 0x0000 (0x0058 - 0x0058)
class UMovieSceneVectorPropertySystem final : public UMovieScenePropertySystem
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneVectorPropertySystem">();
	}
	static class UMovieSceneVectorPropertySystem* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneVectorPropertySystem>();
	}
};
static_assert(alignof(UMovieSceneVectorPropertySystem) == 0x000008, "Wrong alignment on UMovieSceneVectorPropertySystem");
static_assert(sizeof(UMovieSceneVectorPropertySystem) == 0x000058, "Wrong size on UMovieSceneVectorPropertySystem");

// Class MovieSceneTracks.MovieSceneVectorSection
// 0x0290 (0x0378 - 0x00E8)
class UMovieSceneVectorSection final : public UMovieSceneSection
{
public:
	uint8                                         Pad_E8[0x8];                                       // 0x00E8(0x0008)(Fixing Size After Last Property [ Dumper-7 ])
	struct FMovieSceneFloatChannel                Curves[0x4];                                       // 0x00F0(0x00A0)(NativeAccessSpecifierPrivate)
	int32                                         ChannelsUsed;                                      // 0x0370(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_374[0x4];                                      // 0x0374(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneVectorSection">();
	}
	static class UMovieSceneVectorSection* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneVectorSection>();
	}
};
static_assert(alignof(UMovieSceneVectorSection) == 0x000008, "Wrong alignment on UMovieSceneVectorSection");
static_assert(sizeof(UMovieSceneVectorSection) == 0x000378, "Wrong size on UMovieSceneVectorSection");
static_assert(offsetof(UMovieSceneVectorSection, Curves) == 0x0000F0, "Member 'UMovieSceneVectorSection::Curves' has a wrong offset!");
static_assert(offsetof(UMovieSceneVectorSection, ChannelsUsed) == 0x000370, "Member 'UMovieSceneVectorSection::ChannelsUsed' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneVectorTrack
// 0x0008 (0x00C8 - 0x00C0)
class UMovieSceneVectorTrack final : public UMovieScenePropertyTrack
{
public:
	int32                                         NumChannelsUsed;                                   // 0x00C0(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_C4[0x4];                                       // 0x00C4(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])

public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneVectorTrack">();
	}
	static class UMovieSceneVectorTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneVectorTrack>();
	}
};
static_assert(alignof(UMovieSceneVectorTrack) == 0x000008, "Wrong alignment on UMovieSceneVectorTrack");
static_assert(sizeof(UMovieSceneVectorTrack) == 0x0000C8, "Wrong size on UMovieSceneVectorTrack");
static_assert(offsetof(UMovieSceneVectorTrack, NumChannelsUsed) == 0x0000C0, "Member 'UMovieSceneVectorTrack::NumChannelsUsed' has a wrong offset!");

// Class MovieSceneTracks.MovieSceneVisibilityTrack
// 0x0000 (0x00C8 - 0x00C8)
class UMovieSceneVisibilityTrack final : public UMovieSceneBoolTrack
{
public:
	static class UClass* StaticClass()
	{
		return StaticClassImpl<"MovieSceneVisibilityTrack">();
	}
	static class UMovieSceneVisibilityTrack* GetDefaultObj()
	{
		return GetDefaultObjImpl<UMovieSceneVisibilityTrack>();
	}
};
static_assert(alignof(UMovieSceneVisibilityTrack) == 0x000008, "Wrong alignment on UMovieSceneVisibilityTrack");
static_assert(sizeof(UMovieSceneVisibilityTrack) == 0x0000C8, "Wrong size on UMovieSceneVisibilityTrack");

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

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

// Class MovieSceneTracks.MovieSceneHierarchicalEasingInstantiatorSystem
// 0x0050 (0x0090 - 0x0040)
class UMovieSceneHierarchicalEasingInstantiatorSystem final : public UMovieSceneEntityInstantiatorSystem
{
public:
	uint8                                         Pad_40[0x50];                                      // 0x0040(0x0050)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

// Class MovieSceneTracks.WeightAndEasingEvaluatorSystem
// 0x0038 (0x0078 - 0x0040)
class UWeightAndEasingEvaluatorSystem final : public UMovieSceneEntitySystem
{
public:
	uint8                                         Pad_40[0x38];                                      // 0x0040(0x0038)(Fixing Struct Size After Last Property [ Dumper-7 ])

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

}