#pragma once

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

// Package: IrisCore

#include "Basic.hpp"

#include "NetCore_structs.hpp"


namespace SDK
{

// Enum IrisCore.EDataStreamSendStatus
// NumValues: 0x0003
enum class EDataStreamSendStatus : uint8
{
	Send                                     = 0,
	Pause                                    = 1,
	EDataStreamSendStatus_MAX                = 2,
};

// Enum IrisCore.ENetObjectCountLimiterMode
// NumValues: 0x0003
enum class ENetObjectCountLimiterMode : uint32
{
	RoundRobin                               = 0,
	Fill                                     = 1,
	ENetObjectCountLimiterMode_MAX           = 2,
};

// Enum IrisCore.ENetFilterType
// NumValues: 0x0003
enum class ENetFilterType : uint8
{
	PrePoll_Raw                              = 0,
	PostPoll_FragmentBased                   = 1,
	ENetFilterType_MAX                       = 2,
};

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

// ScriptStruct IrisCore.ArrayPropertyNetSerializerConfig
// 0x0030 (0x0040 - 0x0010)
struct FArrayPropertyNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint16                                        MaxElementCount;                                   // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        ElementCountBitCount;                              // 0x0012(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_14[0x4];                                       // 0x0014(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	TFieldPath<class FArrayProperty>              Property;                                          // 0x0018(0x0020)(HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_38[0x8];                                       // 0x0038(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FArrayPropertyNetSerializerConfig) == 0x000008, "Wrong alignment on FArrayPropertyNetSerializerConfig");
static_assert(sizeof(FArrayPropertyNetSerializerConfig) == 0x000040, "Wrong size on FArrayPropertyNetSerializerConfig");
static_assert(offsetof(FArrayPropertyNetSerializerConfig, MaxElementCount) == 0x000010, "Member 'FArrayPropertyNetSerializerConfig::MaxElementCount' has a wrong offset!");
static_assert(offsetof(FArrayPropertyNetSerializerConfig, ElementCountBitCount) == 0x000012, "Member 'FArrayPropertyNetSerializerConfig::ElementCountBitCount' has a wrong offset!");
static_assert(offsetof(FArrayPropertyNetSerializerConfig, Property) == 0x000018, "Member 'FArrayPropertyNetSerializerConfig::Property' has a wrong offset!");

// ScriptStruct IrisCore.DataStreamDefinition
// 0x0020 (0x0020 - 0x0000)
struct FDataStreamDefinition final
{
public:
	class FName                                   DataStreamName;                                    // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ClassName;                                         // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    Class;                                             // 0x0010(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	EDataStreamSendStatus                         DefaultSendStatus;                                 // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bAutoCreate;                                       // 0x0019(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1A[0x6];                                       // 0x001A(0x0006)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FDataStreamDefinition) == 0x000008, "Wrong alignment on FDataStreamDefinition");
static_assert(sizeof(FDataStreamDefinition) == 0x000020, "Wrong size on FDataStreamDefinition");
static_assert(offsetof(FDataStreamDefinition, DataStreamName) == 0x000000, "Member 'FDataStreamDefinition::DataStreamName' has a wrong offset!");
static_assert(offsetof(FDataStreamDefinition, ClassName) == 0x000008, "Member 'FDataStreamDefinition::ClassName' has a wrong offset!");
static_assert(offsetof(FDataStreamDefinition, Class) == 0x000010, "Member 'FDataStreamDefinition::Class' has a wrong offset!");
static_assert(offsetof(FDataStreamDefinition, DefaultSendStatus) == 0x000018, "Member 'FDataStreamDefinition::DefaultSendStatus' has a wrong offset!");
static_assert(offsetof(FDataStreamDefinition, bAutoCreate) == 0x000019, "Member 'FDataStreamDefinition::bAutoCreate' has a wrong offset!");

// ScriptStruct IrisCore.NameNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FNameNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FNameNetSerializerConfig) == 0x000008, "Wrong alignment on FNameNetSerializerConfig");
static_assert(sizeof(FNameNetSerializerConfig) == 0x000010, "Wrong size on FNameNetSerializerConfig");

// ScriptStruct IrisCore.EnumUint32NetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FEnumUint32NetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint32                                        LowerBound;                                        // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        UpperBound;                                        // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0xF];                                       // 0x0019(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumUint32NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumUint32NetSerializerConfig");
static_assert(sizeof(FEnumUint32NetSerializerConfig) == 0x000028, "Wrong size on FEnumUint32NetSerializerConfig");
static_assert(offsetof(FEnumUint32NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumUint32NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumUint32NetSerializerConfig, UpperBound) == 0x000014, "Member 'FEnumUint32NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumUint32NetSerializerConfig, BitCount) == 0x000018, "Member 'FEnumUint32NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.DateTimeNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FDateTimeNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FDateTimeNetSerializerConfig) == 0x000008, "Wrong alignment on FDateTimeNetSerializerConfig");
static_assert(sizeof(FDateTimeNetSerializerConfig) == 0x000010, "Wrong size on FDateTimeNetSerializerConfig");

// ScriptStruct IrisCore.EnumInt8NetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FEnumInt8NetSerializerConfig final : public FNetSerializerConfig
{
public:
	int8                                          LowerBound;                                        // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int8                                          UpperBound;                                        // 0x0011(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0012(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13[0xD];                                       // 0x0013(0x000D)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumInt8NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumInt8NetSerializerConfig");
static_assert(sizeof(FEnumInt8NetSerializerConfig) == 0x000020, "Wrong size on FEnumInt8NetSerializerConfig");
static_assert(offsetof(FEnumInt8NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumInt8NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumInt8NetSerializerConfig, UpperBound) == 0x000011, "Member 'FEnumInt8NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumInt8NetSerializerConfig, BitCount) == 0x000012, "Member 'FEnumInt8NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.EnumInt16NetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FEnumInt16NetSerializerConfig final : public FNetSerializerConfig
{
public:
	int16                                         LowerBound;                                        // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int16                                         UpperBound;                                        // 0x0012(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0014(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0xB];                                       // 0x0015(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumInt16NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumInt16NetSerializerConfig");
static_assert(sizeof(FEnumInt16NetSerializerConfig) == 0x000020, "Wrong size on FEnumInt16NetSerializerConfig");
static_assert(offsetof(FEnumInt16NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumInt16NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumInt16NetSerializerConfig, UpperBound) == 0x000012, "Member 'FEnumInt16NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumInt16NetSerializerConfig, BitCount) == 0x000014, "Member 'FEnumInt16NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Uint16RangeNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FUint16RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint16                                        LowerBound;                                        // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        UpperBound;                                        // 0x0012(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0014(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FUint16RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FUint16RangeNetSerializerConfig");
static_assert(sizeof(FUint16RangeNetSerializerConfig) == 0x000018, "Wrong size on FUint16RangeNetSerializerConfig");
static_assert(offsetof(FUint16RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FUint16RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FUint16RangeNetSerializerConfig, UpperBound) == 0x000012, "Member 'FUint16RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FUint16RangeNetSerializerConfig, BitCount) == 0x000014, "Member 'FUint16RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.EnumInt32NetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FEnumInt32NetSerializerConfig final : public FNetSerializerConfig
{
public:
	int32                                         LowerBound;                                        // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UpperBound;                                        // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0xF];                                       // 0x0019(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumInt32NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumInt32NetSerializerConfig");
static_assert(sizeof(FEnumInt32NetSerializerConfig) == 0x000028, "Wrong size on FEnumInt32NetSerializerConfig");
static_assert(offsetof(FEnumInt32NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumInt32NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumInt32NetSerializerConfig, UpperBound) == 0x000014, "Member 'FEnumInt32NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumInt32NetSerializerConfig, BitCount) == 0x000018, "Member 'FEnumInt32NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.GuidNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FGuidNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FGuidNetSerializerConfig) == 0x000008, "Wrong alignment on FGuidNetSerializerConfig");
static_assert(sizeof(FGuidNetSerializerConfig) == 0x000010, "Wrong size on FGuidNetSerializerConfig");

// ScriptStruct IrisCore.EnumInt64NetSerializerConfig
// 0x0020 (0x0030 - 0x0010)
struct FEnumInt64NetSerializerConfig final : public FNetSerializerConfig
{
public:
	int64                                         LowerBound;                                        // 0x0010(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         UpperBound;                                        // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0020(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0xF];                                       // 0x0021(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumInt64NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumInt64NetSerializerConfig");
static_assert(sizeof(FEnumInt64NetSerializerConfig) == 0x000030, "Wrong size on FEnumInt64NetSerializerConfig");
static_assert(offsetof(FEnumInt64NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumInt64NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumInt64NetSerializerConfig, UpperBound) == 0x000018, "Member 'FEnumInt64NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumInt64NetSerializerConfig, BitCount) == 0x000020, "Member 'FEnumInt64NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.SoftObjectPathNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FSoftObjectPathNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FSoftObjectPathNetSerializerConfig) == 0x000008, "Wrong alignment on FSoftObjectPathNetSerializerConfig");
static_assert(sizeof(FSoftObjectPathNetSerializerConfig) == 0x000010, "Wrong size on FSoftObjectPathNetSerializerConfig");

// ScriptStruct IrisCore.EnumUint8NetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FEnumUint8NetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         LowerBound;                                        // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         UpperBound;                                        // 0x0011(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0012(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13[0xD];                                       // 0x0013(0x000D)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumUint8NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumUint8NetSerializerConfig");
static_assert(sizeof(FEnumUint8NetSerializerConfig) == 0x000020, "Wrong size on FEnumUint8NetSerializerConfig");
static_assert(offsetof(FEnumUint8NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumUint8NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumUint8NetSerializerConfig, UpperBound) == 0x000011, "Member 'FEnumUint8NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumUint8NetSerializerConfig, BitCount) == 0x000012, "Member 'FEnumUint8NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.EnumUint16NetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FEnumUint16NetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint16                                        LowerBound;                                        // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint16                                        UpperBound;                                        // 0x0012(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0014(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0xB];                                       // 0x0015(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumUint16NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumUint16NetSerializerConfig");
static_assert(sizeof(FEnumUint16NetSerializerConfig) == 0x000020, "Wrong size on FEnumUint16NetSerializerConfig");
static_assert(offsetof(FEnumUint16NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumUint16NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumUint16NetSerializerConfig, UpperBound) == 0x000012, "Member 'FEnumUint16NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumUint16NetSerializerConfig, BitCount) == 0x000014, "Member 'FEnumUint16NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.EnumUint64NetSerializerConfig
// 0x0020 (0x0030 - 0x0010)
struct FEnumUint64NetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint64                                        LowerBound;                                        // 0x0010(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint64                                        UpperBound;                                        // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0020(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0xF];                                       // 0x0021(0x000F)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FEnumUint64NetSerializerConfig) == 0x000008, "Wrong alignment on FEnumUint64NetSerializerConfig");
static_assert(sizeof(FEnumUint64NetSerializerConfig) == 0x000030, "Wrong size on FEnumUint64NetSerializerConfig");
static_assert(offsetof(FEnumUint64NetSerializerConfig, LowerBound) == 0x000010, "Member 'FEnumUint64NetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FEnumUint64NetSerializerConfig, UpperBound) == 0x000018, "Member 'FEnumUint64NetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FEnumUint64NetSerializerConfig, BitCount) == 0x000020, "Member 'FEnumUint64NetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.FloatNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FFloatNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FFloatNetSerializerConfig) == 0x000008, "Wrong alignment on FFloatNetSerializerConfig");
static_assert(sizeof(FFloatNetSerializerConfig) == 0x000010, "Wrong size on FFloatNetSerializerConfig");

// ScriptStruct IrisCore.DoubleNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FDoubleNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FDoubleNetSerializerConfig) == 0x000008, "Wrong alignment on FDoubleNetSerializerConfig");
static_assert(sizeof(FDoubleNetSerializerConfig) == 0x000010, "Wrong size on FDoubleNetSerializerConfig");

// ScriptStruct IrisCore.BitfieldNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FBitfieldNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         BitMask;                                           // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FBitfieldNetSerializerConfig) == 0x000008, "Wrong alignment on FBitfieldNetSerializerConfig");
static_assert(sizeof(FBitfieldNetSerializerConfig) == 0x000018, "Wrong size on FBitfieldNetSerializerConfig");
static_assert(offsetof(FBitfieldNetSerializerConfig, BitMask) == 0x000010, "Member 'FBitfieldNetSerializerConfig::BitMask' has a wrong offset!");

// ScriptStruct IrisCore.LastResortPropertyNetSerializerConfig
// 0x0028 (0x0038 - 0x0010)
struct FLastResortPropertyNetSerializerConfig final : public FNetSerializerConfig
{
public:
	TFieldPath<class FProperty>                   Property;                                          // 0x0010(0x0020)(HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        MaxAllowedObjectReferences;                        // 0x0030(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_34[0x4];                                       // 0x0034(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FLastResortPropertyNetSerializerConfig) == 0x000008, "Wrong alignment on FLastResortPropertyNetSerializerConfig");
static_assert(sizeof(FLastResortPropertyNetSerializerConfig) == 0x000038, "Wrong size on FLastResortPropertyNetSerializerConfig");
static_assert(offsetof(FLastResortPropertyNetSerializerConfig, Property) == 0x000010, "Member 'FLastResortPropertyNetSerializerConfig::Property' has a wrong offset!");
static_assert(offsetof(FLastResortPropertyNetSerializerConfig, MaxAllowedObjectReferences) == 0x000030, "Member 'FLastResortPropertyNetSerializerConfig::MaxAllowedObjectReferences' has a wrong offset!");

// ScriptStruct IrisCore.NetRoleNetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FNetRoleNetSerializerConfig final : public FNetSerializerConfig
{
public:
	int32                                         RelativeInternalOffsetToOtherRole;                 // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         RelativeExternalOffsetToOtherRole;                 // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         LowerBound;                                        // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         UpperBound;                                        // 0x0019(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x001A(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         AutonomousProxyValue;                              // 0x001B(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         SimulatedProxyValue;                               // 0x001C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_1D[0xB];                                       // 0x001D(0x000B)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FNetRoleNetSerializerConfig) == 0x000008, "Wrong alignment on FNetRoleNetSerializerConfig");
static_assert(sizeof(FNetRoleNetSerializerConfig) == 0x000028, "Wrong size on FNetRoleNetSerializerConfig");
static_assert(offsetof(FNetRoleNetSerializerConfig, RelativeInternalOffsetToOtherRole) == 0x000010, "Member 'FNetRoleNetSerializerConfig::RelativeInternalOffsetToOtherRole' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, RelativeExternalOffsetToOtherRole) == 0x000014, "Member 'FNetRoleNetSerializerConfig::RelativeExternalOffsetToOtherRole' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, LowerBound) == 0x000018, "Member 'FNetRoleNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, UpperBound) == 0x000019, "Member 'FNetRoleNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, BitCount) == 0x00001A, "Member 'FNetRoleNetSerializerConfig::BitCount' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, AutonomousProxyValue) == 0x00001B, "Member 'FNetRoleNetSerializerConfig::AutonomousProxyValue' has a wrong offset!");
static_assert(offsetof(FNetRoleNetSerializerConfig, SimulatedProxyValue) == 0x00001C, "Member 'FNetRoleNetSerializerConfig::SimulatedProxyValue' has a wrong offset!");

// ScriptStruct IrisCore.FieldPathNetSerializerConfig
// 0x0020 (0x0030 - 0x0010)
struct FFieldPathNetSerializerConfig final : public FNetSerializerConfig
{
public:
	TFieldPath<class FProperty>                   Property;                                          // 0x0010(0x0020)(HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FFieldPathNetSerializerConfig) == 0x000008, "Wrong alignment on FFieldPathNetSerializerConfig");
static_assert(sizeof(FFieldPathNetSerializerConfig) == 0x000030, "Wrong size on FFieldPathNetSerializerConfig");
static_assert(offsetof(FFieldPathNetSerializerConfig, Property) == 0x000010, "Member 'FFieldPathNetSerializerConfig::Property' has a wrong offset!");

// ScriptStruct IrisCore.FieldPathNetSerializerSerializationHelper
// 0x0018 (0x0018 - 0x0000)
struct FFieldPathNetSerializerSerializationHelper final
{
public:
	TWeakObjectPtr<class UStruct>                 Owner;                                             // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TArray<class FName>                           PropertyPath;                                      // 0x0008(0x0010)(ZeroConstructor, NativeAccessSpecifierPublic)
};
static_assert(alignof(FFieldPathNetSerializerSerializationHelper) == 0x000008, "Wrong alignment on FFieldPathNetSerializerSerializationHelper");
static_assert(sizeof(FFieldPathNetSerializerSerializationHelper) == 0x000018, "Wrong size on FFieldPathNetSerializerSerializationHelper");
static_assert(offsetof(FFieldPathNetSerializerSerializationHelper, Owner) == 0x000000, "Member 'FFieldPathNetSerializerSerializationHelper::Owner' has a wrong offset!");
static_assert(offsetof(FFieldPathNetSerializerSerializationHelper, PropertyPath) == 0x000008, "Member 'FFieldPathNetSerializerSerializationHelper::PropertyPath' has a wrong offset!");

// ScriptStruct IrisCore.IntNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FIntNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         BitCount;                                          // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FIntNetSerializerConfig) == 0x000008, "Wrong alignment on FIntNetSerializerConfig");
static_assert(sizeof(FIntNetSerializerConfig) == 0x000018, "Wrong size on FIntNetSerializerConfig");
static_assert(offsetof(FIntNetSerializerConfig, BitCount) == 0x000010, "Member 'FIntNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Int8RangeNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FInt8RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	int8                                          LowerBound;                                        // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int8                                          UpperBound;                                        // 0x0011(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0012(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13[0x5];                                       // 0x0013(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FInt8RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FInt8RangeNetSerializerConfig");
static_assert(sizeof(FInt8RangeNetSerializerConfig) == 0x000018, "Wrong size on FInt8RangeNetSerializerConfig");
static_assert(offsetof(FInt8RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FInt8RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FInt8RangeNetSerializerConfig, UpperBound) == 0x000011, "Member 'FInt8RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FInt8RangeNetSerializerConfig, BitCount) == 0x000012, "Member 'FInt8RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Int16RangeNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FInt16RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	int16                                         LowerBound;                                        // 0x0010(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int16                                         UpperBound;                                        // 0x0012(0x0002)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0014(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_15[0x3];                                       // 0x0015(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FInt16RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FInt16RangeNetSerializerConfig");
static_assert(sizeof(FInt16RangeNetSerializerConfig) == 0x000018, "Wrong size on FInt16RangeNetSerializerConfig");
static_assert(offsetof(FInt16RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FInt16RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FInt16RangeNetSerializerConfig, UpperBound) == 0x000012, "Member 'FInt16RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FInt16RangeNetSerializerConfig, BitCount) == 0x000014, "Member 'FInt16RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Int32RangeNetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FInt32RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	int32                                         LowerBound;                                        // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int32                                         UpperBound;                                        // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FInt32RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FInt32RangeNetSerializerConfig");
static_assert(sizeof(FInt32RangeNetSerializerConfig) == 0x000020, "Wrong size on FInt32RangeNetSerializerConfig");
static_assert(offsetof(FInt32RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FInt32RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FInt32RangeNetSerializerConfig, UpperBound) == 0x000014, "Member 'FInt32RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FInt32RangeNetSerializerConfig, BitCount) == 0x000018, "Member 'FInt32RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Int64RangeNetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FInt64RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	int64                                         LowerBound;                                        // 0x0010(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	int64                                         UpperBound;                                        // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0020(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FInt64RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FInt64RangeNetSerializerConfig");
static_assert(sizeof(FInt64RangeNetSerializerConfig) == 0x000028, "Wrong size on FInt64RangeNetSerializerConfig");
static_assert(offsetof(FInt64RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FInt64RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FInt64RangeNetSerializerConfig, UpperBound) == 0x000018, "Member 'FInt64RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FInt64RangeNetSerializerConfig, BitCount) == 0x000020, "Member 'FInt64RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.IrisFastArraySerializer
// 0x0018 (0x0120 - 0x0108)
struct FIrisFastArraySerializer final : public FFastArraySerializer
{
public:
	uint8                                         Pad_108[0x4];                                      // 0x0108(0x0004)(Fixing Size After Last Property [ Dumper-7 ])
	uint32                                        ChangeMaskStorage[0x4];                            // 0x010C(0x0004)(ZeroConstructor, Transient, IsPlainOldData, RepSkip, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPrivate)
	uint8                                         Pad_11C[0x4];                                      // 0x011C(0x0004)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FIrisFastArraySerializer) == 0x000008, "Wrong alignment on FIrisFastArraySerializer");
static_assert(sizeof(FIrisFastArraySerializer) == 0x000120, "Wrong size on FIrisFastArraySerializer");
static_assert(offsetof(FIrisFastArraySerializer, ChangeMaskStorage) == 0x00010C, "Member 'FIrisFastArraySerializer::ChangeMaskStorage' has a wrong offset!");

// ScriptStruct IrisCore.NetBlobHandlerDefinition
// 0x0008 (0x0008 - 0x0000)
struct FNetBlobHandlerDefinition final
{
public:
	class FName                                   ClassName;                                         // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FNetBlobHandlerDefinition) == 0x000004, "Wrong alignment on FNetBlobHandlerDefinition");
static_assert(sizeof(FNetBlobHandlerDefinition) == 0x000008, "Wrong size on FNetBlobHandlerDefinition");
static_assert(offsetof(FNetBlobHandlerDefinition, ClassName) == 0x000000, "Member 'FNetBlobHandlerDefinition::ClassName' has a wrong offset!");

// ScriptStruct IrisCore.NetObjectFilterDefinition
// 0x0018 (0x0018 - 0x0000)
struct FNetObjectFilterDefinition final
{
public:
	class FName                                   FilterName;                                        // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ClassName;                                         // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ConfigClassName;                                   // 0x0010(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FNetObjectFilterDefinition) == 0x000004, "Wrong alignment on FNetObjectFilterDefinition");
static_assert(sizeof(FNetObjectFilterDefinition) == 0x000018, "Wrong size on FNetObjectFilterDefinition");
static_assert(offsetof(FNetObjectFilterDefinition, FilterName) == 0x000000, "Member 'FNetObjectFilterDefinition::FilterName' has a wrong offset!");
static_assert(offsetof(FNetObjectFilterDefinition, ClassName) == 0x000008, "Member 'FNetObjectFilterDefinition::ClassName' has a wrong offset!");
static_assert(offsetof(FNetObjectFilterDefinition, ConfigClassName) == 0x000010, "Member 'FNetObjectFilterDefinition::ConfigClassName' has a wrong offset!");

// ScriptStruct IrisCore.NetObjectPrioritizerDefinition
// 0x0028 (0x0028 - 0x0000)
struct FNetObjectPrioritizerDefinition final
{
public:
	class FName                                   PrioritizerName;                                   // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ClassName;                                         // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    Class;                                             // 0x0010(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   ConfigClassName;                                   // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	TSubclassOf<class UObject>                    ConfigClass;                                       // 0x0020(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FNetObjectPrioritizerDefinition) == 0x000008, "Wrong alignment on FNetObjectPrioritizerDefinition");
static_assert(sizeof(FNetObjectPrioritizerDefinition) == 0x000028, "Wrong size on FNetObjectPrioritizerDefinition");
static_assert(offsetof(FNetObjectPrioritizerDefinition, PrioritizerName) == 0x000000, "Member 'FNetObjectPrioritizerDefinition::PrioritizerName' has a wrong offset!");
static_assert(offsetof(FNetObjectPrioritizerDefinition, ClassName) == 0x000008, "Member 'FNetObjectPrioritizerDefinition::ClassName' has a wrong offset!");
static_assert(offsetof(FNetObjectPrioritizerDefinition, Class) == 0x000010, "Member 'FNetObjectPrioritizerDefinition::Class' has a wrong offset!");
static_assert(offsetof(FNetObjectPrioritizerDefinition, ConfigClassName) == 0x000018, "Member 'FNetObjectPrioritizerDefinition::ConfigClassName' has a wrong offset!");
static_assert(offsetof(FNetObjectPrioritizerDefinition, ConfigClass) == 0x000020, "Member 'FNetObjectPrioritizerDefinition::ConfigClass' has a wrong offset!");

// ScriptStruct IrisCore.BoolNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FBoolNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FBoolNetSerializerConfig) == 0x000008, "Wrong alignment on FBoolNetSerializerConfig");
static_assert(sizeof(FBoolNetSerializerConfig) == 0x000010, "Wrong size on FBoolNetSerializerConfig");

// ScriptStruct IrisCore.StructNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FStructNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         Pad_10[0x8];                                       // 0x0010(0x0008)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FStructNetSerializerConfig) == 0x000008, "Wrong alignment on FStructNetSerializerConfig");
static_assert(sizeof(FStructNetSerializerConfig) == 0x000018, "Wrong size on FStructNetSerializerConfig");

// ScriptStruct IrisCore.NopNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FNopNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FNopNetSerializerConfig) == 0x000008, "Wrong alignment on FNopNetSerializerConfig");
static_assert(sizeof(FNopNetSerializerConfig) == 0x000010, "Wrong size on FNopNetSerializerConfig");

// ScriptStruct IrisCore.ObjectNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FObjectNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FObjectNetSerializerConfig) == 0x000008, "Wrong alignment on FObjectNetSerializerConfig");
static_assert(sizeof(FObjectNetSerializerConfig) == 0x000010, "Wrong size on FObjectNetSerializerConfig");

// ScriptStruct IrisCore.WeakObjectNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FWeakObjectNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FWeakObjectNetSerializerConfig) == 0x000008, "Wrong alignment on FWeakObjectNetSerializerConfig");
static_assert(sizeof(FWeakObjectNetSerializerConfig) == 0x000010, "Wrong size on FWeakObjectNetSerializerConfig");

// ScriptStruct IrisCore.ScriptInterfaceNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FScriptInterfaceNetSerializerConfig final : public FNetSerializerConfig
{
public:
	TSubclassOf<class UObject>                    InterfaceClass;                                    // 0x0010(0x0008)(ZeroConstructor, NoDestructor, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FScriptInterfaceNetSerializerConfig) == 0x000008, "Wrong alignment on FScriptInterfaceNetSerializerConfig");
static_assert(sizeof(FScriptInterfaceNetSerializerConfig) == 0x000018, "Wrong size on FScriptInterfaceNetSerializerConfig");
static_assert(offsetof(FScriptInterfaceNetSerializerConfig, InterfaceClass) == 0x000010, "Member 'FScriptInterfaceNetSerializerConfig::InterfaceClass' has a wrong offset!");

// ScriptStruct IrisCore.ObjectReplicationBridgePollConfig
// 0x0010 (0x0010 - 0x0000)
struct FObjectReplicationBridgePollConfig final
{
public:
	class FName                                   ClassName;                                         // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	float                                         PollFrequency;                                     // 0x0008(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bIncludeSubclasses;                                // 0x000C(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_D[0x3];                                        // 0x000D(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FObjectReplicationBridgePollConfig) == 0x000004, "Wrong alignment on FObjectReplicationBridgePollConfig");
static_assert(sizeof(FObjectReplicationBridgePollConfig) == 0x000010, "Wrong size on FObjectReplicationBridgePollConfig");
static_assert(offsetof(FObjectReplicationBridgePollConfig, ClassName) == 0x000000, "Member 'FObjectReplicationBridgePollConfig::ClassName' has a wrong offset!");
static_assert(offsetof(FObjectReplicationBridgePollConfig, PollFrequency) == 0x000008, "Member 'FObjectReplicationBridgePollConfig::PollFrequency' has a wrong offset!");
static_assert(offsetof(FObjectReplicationBridgePollConfig, bIncludeSubclasses) == 0x00000C, "Member 'FObjectReplicationBridgePollConfig::bIncludeSubclasses' has a wrong offset!");

// ScriptStruct IrisCore.ObjectReplicationBridgeFilterConfig
// 0x0010 (0x0010 - 0x0000)
struct FObjectReplicationBridgeFilterConfig final
{
public:
	class FName                                   ClassName;                                         // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	class FName                                   DynamicFilterName;                                 // 0x0008(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
};
static_assert(alignof(FObjectReplicationBridgeFilterConfig) == 0x000004, "Wrong alignment on FObjectReplicationBridgeFilterConfig");
static_assert(sizeof(FObjectReplicationBridgeFilterConfig) == 0x000010, "Wrong size on FObjectReplicationBridgeFilterConfig");
static_assert(offsetof(FObjectReplicationBridgeFilterConfig, ClassName) == 0x000000, "Member 'FObjectReplicationBridgeFilterConfig::ClassName' has a wrong offset!");
static_assert(offsetof(FObjectReplicationBridgeFilterConfig, DynamicFilterName) == 0x000008, "Member 'FObjectReplicationBridgeFilterConfig::DynamicFilterName' has a wrong offset!");

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

// ScriptStruct IrisCore.ObjectReplicationBridgeDeltaCompressionConfig
// 0x000C (0x000C - 0x0000)
struct FObjectReplicationBridgeDeltaCompressionConfig final
{
public:
	class FName                                   ClassName;                                         // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bEnableDeltaCompression;                           // 0x0008(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FObjectReplicationBridgeDeltaCompressionConfig) == 0x000004, "Wrong alignment on FObjectReplicationBridgeDeltaCompressionConfig");
static_assert(sizeof(FObjectReplicationBridgeDeltaCompressionConfig) == 0x00000C, "Wrong size on FObjectReplicationBridgeDeltaCompressionConfig");
static_assert(offsetof(FObjectReplicationBridgeDeltaCompressionConfig, ClassName) == 0x000000, "Member 'FObjectReplicationBridgeDeltaCompressionConfig::ClassName' has a wrong offset!");
static_assert(offsetof(FObjectReplicationBridgeDeltaCompressionConfig, bEnableDeltaCompression) == 0x000008, "Member 'FObjectReplicationBridgeDeltaCompressionConfig::bEnableDeltaCompression' has a wrong offset!");

// ScriptStruct IrisCore.PackedInt64NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FPackedInt64NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FPackedInt64NetSerializerConfig) == 0x000008, "Wrong alignment on FPackedInt64NetSerializerConfig");
static_assert(sizeof(FPackedInt64NetSerializerConfig) == 0x000010, "Wrong size on FPackedInt64NetSerializerConfig");

// ScriptStruct IrisCore.PackedUint64NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FPackedUint64NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FPackedUint64NetSerializerConfig) == 0x000008, "Wrong alignment on FPackedUint64NetSerializerConfig");
static_assert(sizeof(FPackedUint64NetSerializerConfig) == 0x000010, "Wrong size on FPackedUint64NetSerializerConfig");

// ScriptStruct IrisCore.PackedInt32NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FPackedInt32NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FPackedInt32NetSerializerConfig) == 0x000008, "Wrong alignment on FPackedInt32NetSerializerConfig");
static_assert(sizeof(FPackedInt32NetSerializerConfig) == 0x000010, "Wrong size on FPackedInt32NetSerializerConfig");

// ScriptStruct IrisCore.PackedUint32NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FPackedUint32NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FPackedUint32NetSerializerConfig) == 0x000008, "Wrong alignment on FPackedUint32NetSerializerConfig");
static_assert(sizeof(FPackedUint32NetSerializerConfig) == 0x000010, "Wrong size on FPackedUint32NetSerializerConfig");

// ScriptStruct IrisCore.VectorNetQuantizeNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVectorNetQuantizeNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVectorNetQuantizeNetSerializerConfig) == 0x000008, "Wrong alignment on FVectorNetQuantizeNetSerializerConfig");
static_assert(sizeof(FVectorNetQuantizeNetSerializerConfig) == 0x000010, "Wrong size on FVectorNetQuantizeNetSerializerConfig");

// ScriptStruct IrisCore.VectorNetQuantize10NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVectorNetQuantize10NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVectorNetQuantize10NetSerializerConfig) == 0x000008, "Wrong alignment on FVectorNetQuantize10NetSerializerConfig");
static_assert(sizeof(FVectorNetQuantize10NetSerializerConfig) == 0x000010, "Wrong size on FVectorNetQuantize10NetSerializerConfig");

// ScriptStruct IrisCore.VectorNetQuantize100NetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVectorNetQuantize100NetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVectorNetQuantize100NetSerializerConfig) == 0x000008, "Wrong alignment on FVectorNetQuantize100NetSerializerConfig");
static_assert(sizeof(FVectorNetQuantize100NetSerializerConfig) == 0x000010, "Wrong size on FVectorNetQuantize100NetSerializerConfig");

// ScriptStruct IrisCore.VectorNetQuantizeNormalNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVectorNetQuantizeNormalNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVectorNetQuantizeNormalNetSerializerConfig) == 0x000008, "Wrong alignment on FVectorNetQuantizeNormalNetSerializerConfig");
static_assert(sizeof(FVectorNetQuantizeNormalNetSerializerConfig) == 0x000010, "Wrong size on FVectorNetQuantizeNormalNetSerializerConfig");

// ScriptStruct IrisCore.PolymorphicStructNetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FPolymorphicStructNetSerializerConfig : public FNetSerializerConfig
{
public:
	uint8                                         Pad_10[0x18];                                      // 0x0010(0x0018)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FPolymorphicStructNetSerializerConfig) == 0x000008, "Wrong alignment on FPolymorphicStructNetSerializerConfig");
static_assert(sizeof(FPolymorphicStructNetSerializerConfig) == 0x000028, "Wrong size on FPolymorphicStructNetSerializerConfig");

// ScriptStruct IrisCore.PolymorphicArrayStructNetSerializerConfig
// 0x0000 (0x0028 - 0x0028)
struct FPolymorphicArrayStructNetSerializerConfig : public FPolymorphicStructNetSerializerConfig
{
};
static_assert(alignof(FPolymorphicArrayStructNetSerializerConfig) == 0x000008, "Wrong alignment on FPolymorphicArrayStructNetSerializerConfig");
static_assert(sizeof(FPolymorphicArrayStructNetSerializerConfig) == 0x000028, "Wrong size on FPolymorphicArrayStructNetSerializerConfig");

// ScriptStruct IrisCore.UnitQuatNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FUnitQuatNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FUnitQuatNetSerializerConfig) == 0x000008, "Wrong alignment on FUnitQuatNetSerializerConfig");
static_assert(sizeof(FUnitQuatNetSerializerConfig) == 0x000010, "Wrong size on FUnitQuatNetSerializerConfig");

// ScriptStruct IrisCore.UnitQuat4fNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FUnitQuat4fNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FUnitQuat4fNetSerializerConfig) == 0x000008, "Wrong alignment on FUnitQuat4fNetSerializerConfig");
static_assert(sizeof(FUnitQuat4fNetSerializerConfig) == 0x000010, "Wrong size on FUnitQuat4fNetSerializerConfig");

// ScriptStruct IrisCore.UnitQuat4dNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FUnitQuat4dNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FUnitQuat4dNetSerializerConfig) == 0x000008, "Wrong alignment on FUnitQuat4dNetSerializerConfig");
static_assert(sizeof(FUnitQuat4dNetSerializerConfig) == 0x000010, "Wrong size on FUnitQuat4dNetSerializerConfig");

// ScriptStruct IrisCore.RotatorNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FRotatorNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FRotatorNetSerializerConfig) == 0x000008, "Wrong alignment on FRotatorNetSerializerConfig");
static_assert(sizeof(FRotatorNetSerializerConfig) == 0x000010, "Wrong size on FRotatorNetSerializerConfig");

// ScriptStruct IrisCore.RotatorAsByteNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FRotatorAsByteNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FRotatorAsByteNetSerializerConfig) == 0x000008, "Wrong alignment on FRotatorAsByteNetSerializerConfig");
static_assert(sizeof(FRotatorAsByteNetSerializerConfig) == 0x000010, "Wrong size on FRotatorAsByteNetSerializerConfig");

// ScriptStruct IrisCore.RotatorAsShortNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FRotatorAsShortNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FRotatorAsShortNetSerializerConfig) == 0x000008, "Wrong alignment on FRotatorAsShortNetSerializerConfig");
static_assert(sizeof(FRotatorAsShortNetSerializerConfig) == 0x000010, "Wrong size on FRotatorAsShortNetSerializerConfig");

// ScriptStruct IrisCore.SoftObjectNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FSoftObjectNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FSoftObjectNetSerializerConfig) == 0x000008, "Wrong alignment on FSoftObjectNetSerializerConfig");
static_assert(sizeof(FSoftObjectNetSerializerConfig) == 0x000010, "Wrong size on FSoftObjectNetSerializerConfig");

// ScriptStruct IrisCore.SoftClassPathNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FSoftClassPathNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FSoftClassPathNetSerializerConfig) == 0x000008, "Wrong alignment on FSoftClassPathNetSerializerConfig");
static_assert(sizeof(FSoftClassPathNetSerializerConfig) == 0x000010, "Wrong size on FSoftClassPathNetSerializerConfig");

// ScriptStruct IrisCore.StringNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FStringNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FStringNetSerializerConfig) == 0x000008, "Wrong alignment on FStringNetSerializerConfig");
static_assert(sizeof(FStringNetSerializerConfig) == 0x000010, "Wrong size on FStringNetSerializerConfig");

// ScriptStruct IrisCore.UintNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FUintNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         BitCount;                                          // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_11[0x7];                                       // 0x0011(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FUintNetSerializerConfig) == 0x000008, "Wrong alignment on FUintNetSerializerConfig");
static_assert(sizeof(FUintNetSerializerConfig) == 0x000018, "Wrong size on FUintNetSerializerConfig");
static_assert(offsetof(FUintNetSerializerConfig, BitCount) == 0x000010, "Member 'FUintNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Uint8RangeNetSerializerConfig
// 0x0008 (0x0018 - 0x0010)
struct FUint8RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint8                                         LowerBound;                                        // 0x0010(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         UpperBound;                                        // 0x0011(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0012(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_13[0x5];                                       // 0x0013(0x0005)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FUint8RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FUint8RangeNetSerializerConfig");
static_assert(sizeof(FUint8RangeNetSerializerConfig) == 0x000018, "Wrong size on FUint8RangeNetSerializerConfig");
static_assert(offsetof(FUint8RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FUint8RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FUint8RangeNetSerializerConfig, UpperBound) == 0x000011, "Member 'FUint8RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FUint8RangeNetSerializerConfig, BitCount) == 0x000012, "Member 'FUint8RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Uint32RangeNetSerializerConfig
// 0x0010 (0x0020 - 0x0010)
struct FUint32RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint32                                        LowerBound;                                        // 0x0010(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint32                                        UpperBound;                                        // 0x0014(0x0004)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0018(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_19[0x7];                                       // 0x0019(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FUint32RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FUint32RangeNetSerializerConfig");
static_assert(sizeof(FUint32RangeNetSerializerConfig) == 0x000020, "Wrong size on FUint32RangeNetSerializerConfig");
static_assert(offsetof(FUint32RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FUint32RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FUint32RangeNetSerializerConfig, UpperBound) == 0x000014, "Member 'FUint32RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FUint32RangeNetSerializerConfig, BitCount) == 0x000018, "Member 'FUint32RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.Uint64RangeNetSerializerConfig
// 0x0018 (0x0028 - 0x0010)
struct FUint64RangeNetSerializerConfig final : public FNetSerializerConfig
{
public:
	uint64                                        LowerBound;                                        // 0x0010(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint64                                        UpperBound;                                        // 0x0018(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         BitCount;                                          // 0x0020(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_21[0x7];                                       // 0x0021(0x0007)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FUint64RangeNetSerializerConfig) == 0x000008, "Wrong alignment on FUint64RangeNetSerializerConfig");
static_assert(sizeof(FUint64RangeNetSerializerConfig) == 0x000028, "Wrong size on FUint64RangeNetSerializerConfig");
static_assert(offsetof(FUint64RangeNetSerializerConfig, LowerBound) == 0x000010, "Member 'FUint64RangeNetSerializerConfig::LowerBound' has a wrong offset!");
static_assert(offsetof(FUint64RangeNetSerializerConfig, UpperBound) == 0x000018, "Member 'FUint64RangeNetSerializerConfig::UpperBound' has a wrong offset!");
static_assert(offsetof(FUint64RangeNetSerializerConfig, BitCount) == 0x000020, "Member 'FUint64RangeNetSerializerConfig::BitCount' has a wrong offset!");

// ScriptStruct IrisCore.VectorNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVectorNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVectorNetSerializerConfig) == 0x000008, "Wrong alignment on FVectorNetSerializerConfig");
static_assert(sizeof(FVectorNetSerializerConfig) == 0x000010, "Wrong size on FVectorNetSerializerConfig");

// ScriptStruct IrisCore.Vector3fNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVector3fNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVector3fNetSerializerConfig) == 0x000008, "Wrong alignment on FVector3fNetSerializerConfig");
static_assert(sizeof(FVector3fNetSerializerConfig) == 0x000010, "Wrong size on FVector3fNetSerializerConfig");

// ScriptStruct IrisCore.Vector3dNetSerializerConfig
// 0x0000 (0x0010 - 0x0010)
struct FVector3dNetSerializerConfig final : public FNetSerializerConfig
{
};
static_assert(alignof(FVector3dNetSerializerConfig) == 0x000008, "Wrong alignment on FVector3dNetSerializerConfig");
static_assert(sizeof(FVector3dNetSerializerConfig) == 0x000010, "Wrong size on FVector3dNetSerializerConfig");

// ScriptStruct IrisCore.SupportsStructNetSerializerConfig
// 0x000C (0x000C - 0x0000)
struct FSupportsStructNetSerializerConfig final
{
public:
	class FName                                   StructName;                                        // 0x0000(0x0008)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	bool                                          bCanUseStructNetSerializer;                        // 0x0008(0x0001)(ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
	uint8                                         Pad_9[0x3];                                        // 0x0009(0x0003)(Fixing Struct Size After Last Property [ Dumper-7 ])
};
static_assert(alignof(FSupportsStructNetSerializerConfig) == 0x000004, "Wrong alignment on FSupportsStructNetSerializerConfig");
static_assert(sizeof(FSupportsStructNetSerializerConfig) == 0x00000C, "Wrong size on FSupportsStructNetSerializerConfig");
static_assert(offsetof(FSupportsStructNetSerializerConfig, StructName) == 0x000000, "Member 'FSupportsStructNetSerializerConfig::StructName' has a wrong offset!");
static_assert(offsetof(FSupportsStructNetSerializerConfig, bCanUseStructNetSerializer) == 0x000008, "Member 'FSupportsStructNetSerializerConfig::bCanUseStructNetSerializer' has a wrong offset!");

}

