#pragma once

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

// Package: TimeSynth

#include "Basic.hpp"

#include "TimeSynth_structs.hpp"


namespace SDK::Params
{

// Function TimeSynth.TimeSynthComponent.AddQuantizationEventDelegate
// 0x0014 (0x0014 - 0x0000)
struct TimeSynthComponent_AddQuantizationEventDelegate final
{
public:
	ETimeSynthEventQuantization                   QuantizationType;                                  // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	TDelegate<void(ETimeSynthEventQuantization QuantizationType, int32 NumBars, float Beat)> OnQuantizationEvent;                               // 0x0004(0x0010)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_AddQuantizationEventDelegate) == 0x000004, "Wrong alignment on TimeSynthComponent_AddQuantizationEventDelegate");
static_assert(sizeof(TimeSynthComponent_AddQuantizationEventDelegate) == 0x000014, "Wrong size on TimeSynthComponent_AddQuantizationEventDelegate");
static_assert(offsetof(TimeSynthComponent_AddQuantizationEventDelegate, QuantizationType) == 0x000000, "Member 'TimeSynthComponent_AddQuantizationEventDelegate::QuantizationType' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_AddQuantizationEventDelegate, OnQuantizationEvent) == 0x000004, "Member 'TimeSynthComponent_AddQuantizationEventDelegate::OnQuantizationEvent' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.PlayClip
// 0x0020 (0x0020 - 0x0000)
struct TimeSynthComponent_PlayClip final
{
public:
	class UTimeSynthClip*                         InClip;                                            // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class UTimeSynthVolumeGroup*                  InVolumeGroup;                                     // 0x0008(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	struct FTimeSynthClipHandle                   ReturnValue;                                       // 0x0010(0x000C)(Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_1C[0x4];                                       // 0x001C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(TimeSynthComponent_PlayClip) == 0x000008, "Wrong alignment on TimeSynthComponent_PlayClip");
static_assert(sizeof(TimeSynthComponent_PlayClip) == 0x000020, "Wrong size on TimeSynthComponent_PlayClip");
static_assert(offsetof(TimeSynthComponent_PlayClip, InClip) == 0x000000, "Member 'TimeSynthComponent_PlayClip::InClip' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_PlayClip, InVolumeGroup) == 0x000008, "Member 'TimeSynthComponent_PlayClip::InVolumeGroup' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_PlayClip, ReturnValue) == 0x000010, "Member 'TimeSynthComponent_PlayClip::ReturnValue' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetBPM
// 0x0004 (0x0004 - 0x0000)
struct TimeSynthComponent_SetBPM final
{
public:
	float                                         BeatsPerMinute;                                    // 0x0000(0x0004)(ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetBPM) == 0x000004, "Wrong alignment on TimeSynthComponent_SetBPM");
static_assert(sizeof(TimeSynthComponent_SetBPM) == 0x000004, "Wrong size on TimeSynthComponent_SetBPM");
static_assert(offsetof(TimeSynthComponent_SetBPM, BeatsPerMinute) == 0x000000, "Member 'TimeSynthComponent_SetBPM::BeatsPerMinute' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetEnvelopeFollowerEnabled
// 0x0001 (0x0001 - 0x0000)
struct TimeSynthComponent_SetEnvelopeFollowerEnabled final
{
public:
	bool                                          bInIsEnabled;                                      // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetEnvelopeFollowerEnabled) == 0x000001, "Wrong alignment on TimeSynthComponent_SetEnvelopeFollowerEnabled");
static_assert(sizeof(TimeSynthComponent_SetEnvelopeFollowerEnabled) == 0x000001, "Wrong size on TimeSynthComponent_SetEnvelopeFollowerEnabled");
static_assert(offsetof(TimeSynthComponent_SetEnvelopeFollowerEnabled, bInIsEnabled) == 0x000000, "Member 'TimeSynthComponent_SetEnvelopeFollowerEnabled::bInIsEnabled' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetEnvelopeFollowerSettings
// 0x000C (0x000C - 0x0000)
struct TimeSynthComponent_SetEnvelopeFollowerSettings final
{
public:
	struct FTimeSynthEnvelopeFollowerSettings     InSettings;                                        // 0x0000(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetEnvelopeFollowerSettings) == 0x000004, "Wrong alignment on TimeSynthComponent_SetEnvelopeFollowerSettings");
static_assert(sizeof(TimeSynthComponent_SetEnvelopeFollowerSettings) == 0x00000C, "Wrong size on TimeSynthComponent_SetEnvelopeFollowerSettings");
static_assert(offsetof(TimeSynthComponent_SetEnvelopeFollowerSettings, InSettings) == 0x000000, "Member 'TimeSynthComponent_SetEnvelopeFollowerSettings::InSettings' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetFFTSize
// 0x0001 (0x0001 - 0x0000)
struct TimeSynthComponent_SetFFTSize final
{
public:
	ETimeSynthFFTSize                             InFFTSize;                                         // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetFFTSize) == 0x000001, "Wrong alignment on TimeSynthComponent_SetFFTSize");
static_assert(sizeof(TimeSynthComponent_SetFFTSize) == 0x000001, "Wrong size on TimeSynthComponent_SetFFTSize");
static_assert(offsetof(TimeSynthComponent_SetFFTSize, InFFTSize) == 0x000000, "Member 'TimeSynthComponent_SetFFTSize::InFFTSize' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetFilterEnabled
// 0x0002 (0x0002 - 0x0000)
struct TimeSynthComponent_SetFilterEnabled final
{
public:
	ETimeSynthFilter                              Filter;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIsEnabled;                                        // 0x0001(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetFilterEnabled) == 0x000001, "Wrong alignment on TimeSynthComponent_SetFilterEnabled");
static_assert(sizeof(TimeSynthComponent_SetFilterEnabled) == 0x000002, "Wrong size on TimeSynthComponent_SetFilterEnabled");
static_assert(offsetof(TimeSynthComponent_SetFilterEnabled, Filter) == 0x000000, "Member 'TimeSynthComponent_SetFilterEnabled::Filter' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_SetFilterEnabled, bIsEnabled) == 0x000001, "Member 'TimeSynthComponent_SetFilterEnabled::bIsEnabled' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetFilterSettings
// 0x0010 (0x0010 - 0x0000)
struct TimeSynthComponent_SetFilterSettings final
{
public:
	ETimeSynthFilter                              Filter;                                            // 0x0000(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1[0x3];                                        // 0x0001(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTimeSynthFilterSettings               InSettings;                                        // 0x0004(0x000C)(ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetFilterSettings) == 0x000004, "Wrong alignment on TimeSynthComponent_SetFilterSettings");
static_assert(sizeof(TimeSynthComponent_SetFilterSettings) == 0x000010, "Wrong size on TimeSynthComponent_SetFilterSettings");
static_assert(offsetof(TimeSynthComponent_SetFilterSettings, Filter) == 0x000000, "Member 'TimeSynthComponent_SetFilterSettings::Filter' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_SetFilterSettings, InSettings) == 0x000004, "Member 'TimeSynthComponent_SetFilterSettings::InSettings' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetQuantizationSettings
// 0x0014 (0x0014 - 0x0000)
struct TimeSynthComponent_SetQuantizationSettings final
{
public:
	struct FTimeSynthQuantizationSettings         InQuantizationSettings;                            // 0x0000(0x0014)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetQuantizationSettings) == 0x000004, "Wrong alignment on TimeSynthComponent_SetQuantizationSettings");
static_assert(sizeof(TimeSynthComponent_SetQuantizationSettings) == 0x000014, "Wrong size on TimeSynthComponent_SetQuantizationSettings");
static_assert(offsetof(TimeSynthComponent_SetQuantizationSettings, InQuantizationSettings) == 0x000000, "Member 'TimeSynthComponent_SetQuantizationSettings::InQuantizationSettings' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetSeed
// 0x0004 (0x0004 - 0x0000)
struct TimeSynthComponent_SetSeed final
{
public:
	int32                                         InSeed;                                            // 0x0000(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetSeed) == 0x000004, "Wrong alignment on TimeSynthComponent_SetSeed");
static_assert(sizeof(TimeSynthComponent_SetSeed) == 0x000004, "Wrong size on TimeSynthComponent_SetSeed");
static_assert(offsetof(TimeSynthComponent_SetSeed, InSeed) == 0x000000, "Member 'TimeSynthComponent_SetSeed::InSeed' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.SetVolumeGroup
// 0x0010 (0x0010 - 0x0000)
struct TimeSynthComponent_SetVolumeGroup final
{
public:
	class UTimeSynthVolumeGroup*                  InVolumeGroup;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         VolumeDb;                                          // 0x0008(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         FadeTimeSec;                                       // 0x000C(0x0004)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_SetVolumeGroup) == 0x000008, "Wrong alignment on TimeSynthComponent_SetVolumeGroup");
static_assert(sizeof(TimeSynthComponent_SetVolumeGroup) == 0x000010, "Wrong size on TimeSynthComponent_SetVolumeGroup");
static_assert(offsetof(TimeSynthComponent_SetVolumeGroup, InVolumeGroup) == 0x000000, "Member 'TimeSynthComponent_SetVolumeGroup::InVolumeGroup' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_SetVolumeGroup, VolumeDb) == 0x000008, "Member 'TimeSynthComponent_SetVolumeGroup::VolumeDb' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_SetVolumeGroup, FadeTimeSec) == 0x00000C, "Member 'TimeSynthComponent_SetVolumeGroup::FadeTimeSec' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.StopClip
// 0x0010 (0x0010 - 0x0000)
struct TimeSynthComponent_StopClip final
{
public:
	struct FTimeSynthClipHandle                   InClipHandle;                                      // 0x0000(0x000C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	ETimeSynthEventClipQuantization               EventQuantization;                                 // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(TimeSynthComponent_StopClip) == 0x000004, "Wrong alignment on TimeSynthComponent_StopClip");
static_assert(sizeof(TimeSynthComponent_StopClip) == 0x000010, "Wrong size on TimeSynthComponent_StopClip");
static_assert(offsetof(TimeSynthComponent_StopClip, InClipHandle) == 0x000000, "Member 'TimeSynthComponent_StopClip::InClipHandle' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopClip, EventQuantization) == 0x00000C, "Member 'TimeSynthComponent_StopClip::EventQuantization' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.StopClipWithFadeOverride
// 0x0018 (0x0018 - 0x0000)
struct TimeSynthComponent_StopClipWithFadeOverride final
{
public:
	struct FTimeSynthClipHandle                   InClipHandle;                                      // 0x0000(0x000C)(Parm, NoDestructor, NativeAccessSpecifierPublic)
	ETimeSynthEventClipQuantization               EventQuantization;                                 // 0x000C(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTimeSynthTimeDef                      FadeTime;                                          // 0x0010(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_StopClipWithFadeOverride) == 0x000004, "Wrong alignment on TimeSynthComponent_StopClipWithFadeOverride");
static_assert(sizeof(TimeSynthComponent_StopClipWithFadeOverride) == 0x000018, "Wrong size on TimeSynthComponent_StopClipWithFadeOverride");
static_assert(offsetof(TimeSynthComponent_StopClipWithFadeOverride, InClipHandle) == 0x000000, "Member 'TimeSynthComponent_StopClipWithFadeOverride::InClipHandle' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopClipWithFadeOverride, EventQuantization) == 0x00000C, "Member 'TimeSynthComponent_StopClipWithFadeOverride::EventQuantization' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopClipWithFadeOverride, FadeTime) == 0x000010, "Member 'TimeSynthComponent_StopClipWithFadeOverride::FadeTime' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.StopSoundsOnVolumeGroup
// 0x0010 (0x0010 - 0x0000)
struct TimeSynthComponent_StopSoundsOnVolumeGroup final
{
public:
	class UTimeSynthVolumeGroup*                  InVolumeGroup;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETimeSynthEventClipQuantization               EventQuantization;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x7];                                        // 0x0009(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(TimeSynthComponent_StopSoundsOnVolumeGroup) == 0x000008, "Wrong alignment on TimeSynthComponent_StopSoundsOnVolumeGroup");
static_assert(sizeof(TimeSynthComponent_StopSoundsOnVolumeGroup) == 0x000010, "Wrong size on TimeSynthComponent_StopSoundsOnVolumeGroup");
static_assert(offsetof(TimeSynthComponent_StopSoundsOnVolumeGroup, InVolumeGroup) == 0x000000, "Member 'TimeSynthComponent_StopSoundsOnVolumeGroup::InVolumeGroup' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopSoundsOnVolumeGroup, EventQuantization) == 0x000008, "Member 'TimeSynthComponent_StopSoundsOnVolumeGroup::EventQuantization' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.StopSoundsOnVolumeGroupWithFadeOverride
// 0x0018 (0x0018 - 0x0000)
struct TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride final
{
public:
	class UTimeSynthVolumeGroup*                  InVolumeGroup;                                     // 0x0000(0x0008)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	ETimeSynthEventClipQuantization               EventQuantization;                                 // 0x0008(0x0001)(Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Size After Last Property [ Dumper-7 ])
	struct FTimeSynthTimeDef                      FadeTime;                                          // 0x000C(0x0008)(ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride) == 0x000008, "Wrong alignment on TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride");
static_assert(sizeof(TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride) == 0x000018, "Wrong size on TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride");
static_assert(offsetof(TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride, InVolumeGroup) == 0x000000, "Member 'TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride::InVolumeGroup' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride, EventQuantization) == 0x000008, "Member 'TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride::EventQuantization' has a wrong offset!");
static_assert(offsetof(TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride, FadeTime) == 0x00000C, "Member 'TimeSynthComponent_StopSoundsOnVolumeGroupWithFadeOverride::FadeTime' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.GetBPM
// 0x0004 (0x0004 - 0x0000)
struct TimeSynthComponent_GetBPM final
{
public:
	int32                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_GetBPM) == 0x000004, "Wrong alignment on TimeSynthComponent_GetBPM");
static_assert(sizeof(TimeSynthComponent_GetBPM) == 0x000004, "Wrong size on TimeSynthComponent_GetBPM");
static_assert(offsetof(TimeSynthComponent_GetBPM, ReturnValue) == 0x000000, "Member 'TimeSynthComponent_GetBPM::ReturnValue' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.GetEnvelopeFollowerValue
// 0x0004 (0x0004 - 0x0000)
struct TimeSynthComponent_GetEnvelopeFollowerValue final
{
public:
	float                                         ReturnValue;                                       // 0x0000(0x0004)(Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_GetEnvelopeFollowerValue) == 0x000004, "Wrong alignment on TimeSynthComponent_GetEnvelopeFollowerValue");
static_assert(sizeof(TimeSynthComponent_GetEnvelopeFollowerValue) == 0x000004, "Wrong size on TimeSynthComponent_GetEnvelopeFollowerValue");
static_assert(offsetof(TimeSynthComponent_GetEnvelopeFollowerValue, ReturnValue) == 0x000000, "Member 'TimeSynthComponent_GetEnvelopeFollowerValue::ReturnValue' has a wrong offset!");

// Function TimeSynth.TimeSynthComponent.GetSpectralData
// 0x0010 (0x0010 - 0x0000)
struct TimeSynthComponent_GetSpectralData final
{
public:
	TArray<struct FTimeSynthSpectralData>         ReturnValue;                                       // 0x0000(0x0010)(Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)
};
static_assert(alignof(TimeSynthComponent_GetSpectralData) == 0x000008, "Wrong alignment on TimeSynthComponent_GetSpectralData");
static_assert(sizeof(TimeSynthComponent_GetSpectralData) == 0x000010, "Wrong size on TimeSynthComponent_GetSpectralData");
static_assert(offsetof(TimeSynthComponent_GetSpectralData, ReturnValue) == 0x000000, "Member 'TimeSynthComponent_GetSpectralData::ReturnValue' has a wrong offset!");

}

