// Copyright Epic Games, Inc. All Rights Reserved.
/*===========================================================================
	Generated code exported from UnrealHeaderTool.
	DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/

#include "UObject/GeneratedCppIncludes.h"
#include "VentuzEditorPlugin/Public/VentuzDataGetterNode.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeVentuzDataGetterNode() {}
// Cross Module References
	VENTUZEDITORPLUGIN_API UEnum* Z_Construct_UEnum_VentuzEditorPlugin_VentuzType();
	UPackage* Z_Construct_UPackage__Script_VentuzEditorPlugin();
	VENTUZEDITORPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz();
	VENTUZEDITORPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeField();
	VENTUZEDITORPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz();
	VENTUZPLUGIN_API UEnum* Z_Construct_UEnum_VentuzPlugin_VentuzCommunicationDirection();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2ESyncNodeBase_NoRegister();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2ESyncNodeBase();
	BLUEPRINTGRAPH_API UClass* Z_Construct_UClass_UK2Node();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2EGetData_NoRegister();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2EGetData();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2ESendData_NoRegister();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzE2ESendData();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzGetValue_NoRegister();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzGetValue();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzSendValue_NoRegister();
	VENTUZEDITORPLUGIN_API UClass* Z_Construct_UClass_UVentuzSendValue();
// End Cross Module References
	static UEnum* VentuzType_StaticEnum()
	{
		static UEnum* Singleton = nullptr;
		if (!Singleton)
		{
			Singleton = GetStaticEnum(Z_Construct_UEnum_VentuzEditorPlugin_VentuzType, Z_Construct_UPackage__Script_VentuzEditorPlugin(), TEXT("VentuzType"));
		}
		return Singleton;
	}
	template<> VENTUZEDITORPLUGIN_API UEnum* StaticEnum<VentuzType>()
	{
		return VentuzType_StaticEnum();
	}
	static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_VentuzType(VentuzType_StaticEnum, TEXT("/Script/VentuzEditorPlugin"), TEXT("VentuzType"), false, nullptr, nullptr);
	uint32 Get_Z_Construct_UEnum_VentuzEditorPlugin_VentuzType_Hash() { return 3511444870U; }
	UEnum* Z_Construct_UEnum_VentuzEditorPlugin_VentuzType()
	{
#if WITH_HOT_RELOAD
		UPackage* Outer = Z_Construct_UPackage__Script_VentuzEditorPlugin();
		static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("VentuzType"), 0, Get_Z_Construct_UEnum_VentuzEditorPlugin_VentuzType_Hash(), false);
#else
		static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
		if (!ReturnEnum)
		{
			static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
				{ "VentuzType::Float", (int64)VentuzType::Float },
				{ "VentuzType::Int", (int64)VentuzType::Int },
				{ "VentuzType::Bool", (int64)VentuzType::Bool },
				{ "VentuzType::String", (int64)VentuzType::String },
				{ "VentuzType::FloatArray", (int64)VentuzType::FloatArray },
				{ "VentuzType::IntArray", (int64)VentuzType::IntArray },
				{ "VentuzType::BoolArray", (int64)VentuzType::BoolArray },
				{ "VentuzType::StringArray", (int64)VentuzType::StringArray },
			};
#if WITH_METADATA
			const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
				{ "Bool.DisplayName", "Boolean" },
				{ "Bool.Name", "VentuzType::Bool" },
				{ "BoolArray.DisplayName", "BooleanArray" },
				{ "BoolArray.Name", "VentuzType::BoolArray" },
				{ "Comment", "// needs to be in sync with UE4Interface.cs Ventuz.Kernel.E2E.FieldType and UE4ComCommon.h::E2EFieldType\n" },
				{ "Float.DisplayName", "Float" },
				{ "Float.Name", "VentuzType::Float" },
				{ "FloatArray.DisplayName", "FloatArray" },
				{ "FloatArray.Name", "VentuzType::FloatArray" },
				{ "Int.DisplayName", "Integer" },
				{ "Int.Name", "VentuzType::Int" },
				{ "IntArray.DisplayName", "IntegerArray" },
				{ "IntArray.Name", "VentuzType::IntArray" },
				{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
				{ "String.DisplayName", "String" },
				{ "String.Name", "VentuzType::String" },
				{ "StringArray.DisplayName", "StringArray" },
				{ "StringArray.Name", "VentuzType::StringArray" },
				{ "ToolTip", "needs to be in sync with UE4Interface.cs Ventuz.Kernel.E2E.FieldType and UE4ComCommon.h::E2EFieldType" },
			};
#endif
			static const UE4CodeGen_Private::FEnumParams EnumParams = {
				(UObject*(*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
				nullptr,
				"VentuzType",
				"VentuzType",
				Enumerators,
				UE_ARRAY_COUNT(Enumerators),
				RF_Public|RF_Transient|RF_MarkAsNative,
				EEnumFlags::None,
				UE4CodeGen_Private::EDynamicType::NotDynamic,
				(uint8)UEnum::ECppForm::EnumClass,
				METADATA_PARAMS(Enum_MetaDataParams, UE_ARRAY_COUNT(Enum_MetaDataParams))
			};
			UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
		}
		return ReturnEnum;
	}

static_assert(std::is_polymorphic<FVentuzNodeFieldFromVentuz>() == std::is_polymorphic<FVentuzNodeField>(), "USTRUCT FVentuzNodeFieldFromVentuz cannot be polymorphic unless super FVentuzNodeField is polymorphic");

class UScriptStruct* FVentuzNodeFieldFromVentuz::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern VENTUZEDITORPLUGIN_API uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz, Z_Construct_UPackage__Script_VentuzEditorPlugin(), TEXT("VentuzNodeFieldFromVentuz"), sizeof(FVentuzNodeFieldFromVentuz), Get_Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Hash());
	}
	return Singleton;
}
template<> VENTUZEDITORPLUGIN_API UScriptStruct* StaticStruct<FVentuzNodeFieldFromVentuz>()
{
	return FVentuzNodeFieldFromVentuz::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVentuzNodeFieldFromVentuz(FVentuzNodeFieldFromVentuz::StaticStruct, TEXT("/Script/VentuzEditorPlugin"), TEXT("VentuzNodeFieldFromVentuz"), false, nullptr, nullptr);
static struct FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldFromVentuz
{
	FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldFromVentuz()
	{
		UScriptStruct::DeferCppStructOps<FVentuzNodeFieldFromVentuz>(FName(TEXT("VentuzNodeFieldFromVentuz")));
	}
} ScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldFromVentuz;
	struct Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::Struct_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVentuzNodeFieldFromVentuz>();
	}
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
		Z_Construct_UScriptStruct_FVentuzNodeField,
		&NewStructOps,
		"VentuzNodeFieldFromVentuz",
		sizeof(FVentuzNodeFieldFromVentuz),
		alignof(FVentuzNodeFieldFromVentuz),
		nullptr,
		0,
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_VentuzEditorPlugin();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VentuzNodeFieldFromVentuz"), sizeof(FVentuzNodeFieldFromVentuz), Get_Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz_Hash() { return 972381485U; }

static_assert(std::is_polymorphic<FVentuzNodeFieldToVentuz>() == std::is_polymorphic<FVentuzNodeField>(), "USTRUCT FVentuzNodeFieldToVentuz cannot be polymorphic unless super FVentuzNodeField is polymorphic");

class UScriptStruct* FVentuzNodeFieldToVentuz::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern VENTUZEDITORPLUGIN_API uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz, Z_Construct_UPackage__Script_VentuzEditorPlugin(), TEXT("VentuzNodeFieldToVentuz"), sizeof(FVentuzNodeFieldToVentuz), Get_Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Hash());
	}
	return Singleton;
}
template<> VENTUZEDITORPLUGIN_API UScriptStruct* StaticStruct<FVentuzNodeFieldToVentuz>()
{
	return FVentuzNodeFieldToVentuz::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVentuzNodeFieldToVentuz(FVentuzNodeFieldToVentuz::StaticStruct, TEXT("/Script/VentuzEditorPlugin"), TEXT("VentuzNodeFieldToVentuz"), false, nullptr, nullptr);
static struct FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldToVentuz
{
	FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldToVentuz()
	{
		UScriptStruct::DeferCppStructOps<FVentuzNodeFieldToVentuz>(FName(TEXT("VentuzNodeFieldToVentuz")));
	}
} ScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeFieldToVentuz;
	struct Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::Struct_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVentuzNodeFieldToVentuz>();
	}
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
		Z_Construct_UScriptStruct_FVentuzNodeField,
		&NewStructOps,
		"VentuzNodeFieldToVentuz",
		sizeof(FVentuzNodeFieldToVentuz),
		alignof(FVentuzNodeFieldToVentuz),
		nullptr,
		0,
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_VentuzEditorPlugin();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VentuzNodeFieldToVentuz"), sizeof(FVentuzNodeFieldToVentuz), Get_Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz_Hash() { return 1761717396U; }
class UScriptStruct* FVentuzNodeField::StaticStruct()
{
	static class UScriptStruct* Singleton = NULL;
	if (!Singleton)
	{
		extern VENTUZEDITORPLUGIN_API uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeField_Hash();
		Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FVentuzNodeField, Z_Construct_UPackage__Script_VentuzEditorPlugin(), TEXT("VentuzNodeField"), sizeof(FVentuzNodeField), Get_Z_Construct_UScriptStruct_FVentuzNodeField_Hash());
	}
	return Singleton;
}
template<> VENTUZEDITORPLUGIN_API UScriptStruct* StaticStruct<FVentuzNodeField>()
{
	return FVentuzNodeField::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FVentuzNodeField(FVentuzNodeField::StaticStruct, TEXT("/Script/VentuzEditorPlugin"), TEXT("VentuzNodeField"), false, nullptr, nullptr);
static struct FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeField
{
	FScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeField()
	{
		UScriptStruct::DeferCppStructOps<FVentuzNodeField>(FName(TEXT("VentuzNodeField")));
	}
} ScriptStruct_VentuzEditorPlugin_StaticRegisterNativesFVentuzNodeField;
	struct Z_Construct_UScriptStruct_FVentuzNodeField_Statics
	{
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
		static void* NewStructOps();
		static const UE4CodeGen_Private::FUnsizedIntPropertyParams NewProp_direction_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_direction_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_direction;
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_fieldType_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_fieldType_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_fieldType;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_fieldName_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_fieldName;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const UE4CodeGen_Private::FStructParams ReturnStructParams;
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeField_Statics::Struct_MetaDataParams[] = {
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	void* Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewStructOps()
	{
		return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FVentuzNodeField>();
	}
	const UE4CodeGen_Private::FUnsizedIntPropertyParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction_MetaData[] = {
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction = { "direction", nullptr, (EPropertyFlags)0x0010000000020001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVentuzNodeField, direction), Z_Construct_UEnum_VentuzPlugin_VentuzCommunicationDirection, METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction_MetaData)) };
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType_MetaData[] = {
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType = { "fieldType", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVentuzNodeField, fieldType), Z_Construct_UEnum_VentuzEditorPlugin_VentuzType, METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType_MetaData)) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldName_MetaData[] = {
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldName = { "fieldName", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(FVentuzNodeField, fieldName), METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldName_MetaData, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldName_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UScriptStruct_FVentuzNodeField_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_direction,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldType,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UScriptStruct_FVentuzNodeField_Statics::NewProp_fieldName,
	};
	const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FVentuzNodeField_Statics::ReturnStructParams = {
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
		nullptr,
		&NewStructOps,
		"VentuzNodeField",
		sizeof(FVentuzNodeField),
		alignof(FVentuzNodeField),
		Z_Construct_UScriptStruct_FVentuzNodeField_Statics::PropPointers,
		UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::PropPointers),
		RF_Public|RF_Transient|RF_MarkAsNative,
		EStructFlags(0x00000001),
		METADATA_PARAMS(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::Struct_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UScriptStruct_FVentuzNodeField_Statics::Struct_MetaDataParams))
	};
	UScriptStruct* Z_Construct_UScriptStruct_FVentuzNodeField()
	{
#if WITH_HOT_RELOAD
		extern uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeField_Hash();
		UPackage* Outer = Z_Construct_UPackage__Script_VentuzEditorPlugin();
		static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("VentuzNodeField"), sizeof(FVentuzNodeField), Get_Z_Construct_UScriptStruct_FVentuzNodeField_Hash(), false);
#else
		static UScriptStruct* ReturnStruct = nullptr;
#endif
		if (!ReturnStruct)
		{
			UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FVentuzNodeField_Statics::ReturnStructParams);
		}
		return ReturnStruct;
	}
	uint32 Get_Z_Construct_UScriptStruct_FVentuzNodeField_Hash() { return 1218142165U; }
	void UVentuzE2ESyncNodeBase::StaticRegisterNativesUVentuzE2ESyncNodeBase()
	{
	}
	UClass* Z_Construct_UClass_UVentuzE2ESyncNodeBase_NoRegister()
	{
		return UVentuzE2ESyncNodeBase::StaticClass();
	}
	struct Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_nodeInVentuzToSyncFrom_MetaData[];
#endif
		static const UE4CodeGen_Private::FStrPropertyParams NewProp_nodeInVentuzToSyncFrom;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UK2Node,
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::Class_MetaDataParams[] = {
		{ "IncludePath", "VentuzDataGetterNode.h" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::NewProp_nodeInVentuzToSyncFrom_MetaData[] = {
		{ "Category", "Custom Data Model Sync" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::NewProp_nodeInVentuzToSyncFrom = { "nodeInVentuzToSyncFrom", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UVentuzE2ESyncNodeBase, nodeInVentuzToSyncFrom), METADATA_PARAMS(Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::NewProp_nodeInVentuzToSyncFrom_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::NewProp_nodeInVentuzToSyncFrom_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::NewProp_nodeInVentuzToSyncFrom,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzE2ESyncNodeBase>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::ClassParams = {
		&UVentuzE2ESyncNodeBase::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::PropPointers),
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UVentuzE2ESyncNodeBase()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UVentuzE2ESyncNodeBase_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UVentuzE2ESyncNodeBase, 1639300461);
	template<> VENTUZEDITORPLUGIN_API UClass* StaticClass<UVentuzE2ESyncNodeBase>()
	{
		return UVentuzE2ESyncNodeBase::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UVentuzE2ESyncNodeBase(Z_Construct_UClass_UVentuzE2ESyncNodeBase, &UVentuzE2ESyncNodeBase::StaticClass, TEXT("/Script/VentuzEditorPlugin"), TEXT("UVentuzE2ESyncNodeBase"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzE2ESyncNodeBase);
	void UVentuzE2EGetData::StaticRegisterNativesUVentuzE2EGetData()
	{
	}
	UClass* Z_Construct_UClass_UVentuzE2EGetData_NoRegister()
	{
		return UVentuzE2EGetData::StaticClass();
	}
	struct Z_Construct_UClass_UVentuzE2EGetData_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_fromVentuzFields_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_fromVentuzFields_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_fromVentuzFields;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UVentuzE2EGetData_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UVentuzE2ESyncNodeBase,
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2EGetData_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "//////////////////////////////////////////////////////////////////////////\n// From Ventuz Multi Field Node\n" },
		{ "IncludePath", "VentuzDataGetterNode.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
		{ "ToolTip", "From Ventuz Multi Field Node" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields_Inner = { "fromVentuzFields", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FVentuzNodeFieldFromVentuz, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields_MetaData[] = {
		{ "Category", "Custom Data Model Fields" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields = { "fromVentuzFields", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UVentuzE2EGetData, fromVentuzFields), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UVentuzE2EGetData_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzE2EGetData_Statics::NewProp_fromVentuzFields,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UVentuzE2EGetData_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzE2EGetData>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UVentuzE2EGetData_Statics::ClassParams = {
		&UVentuzE2EGetData::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UVentuzE2EGetData_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2EGetData_Statics::PropPointers),
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UVentuzE2EGetData_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2EGetData_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UVentuzE2EGetData()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UVentuzE2EGetData_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UVentuzE2EGetData, 681401134);
	template<> VENTUZEDITORPLUGIN_API UClass* StaticClass<UVentuzE2EGetData>()
	{
		return UVentuzE2EGetData::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UVentuzE2EGetData(Z_Construct_UClass_UVentuzE2EGetData, &UVentuzE2EGetData::StaticClass, TEXT("/Script/VentuzEditorPlugin"), TEXT("UVentuzE2EGetData"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzE2EGetData);
	void UVentuzE2ESendData::StaticRegisterNativesUVentuzE2ESendData()
	{
	}
	UClass* Z_Construct_UClass_UVentuzE2ESendData_NoRegister()
	{
		return UVentuzE2ESendData::StaticClass();
	}
	struct Z_Construct_UClass_UVentuzE2ESendData_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FStructPropertyParams NewProp_toVentuzFields_Inner;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_toVentuzFields_MetaData[];
#endif
		static const UE4CodeGen_Private::FArrayPropertyParams NewProp_toVentuzFields;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UVentuzE2ESendData_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UVentuzE2ESyncNodeBase,
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2ESendData_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "//////////////////////////////////////////////////////////////////////////\n// To Ventuz Multi Field Node\n" },
		{ "IncludePath", "VentuzDataGetterNode.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
		{ "ToolTip", "To Ventuz Multi Field Node" },
	};
#endif
	const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields_Inner = { "toVentuzFields", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FVentuzNodeFieldToVentuz, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields_MetaData[] = {
		{ "Category", "Custom Data Model Fields" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields = { "toVentuzFields", nullptr, (EPropertyFlags)0x0010000000000001, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UVentuzE2ESendData, toVentuzFields), EArrayPropertyFlags::None, METADATA_PARAMS(Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UVentuzE2ESendData_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields_Inner,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzE2ESendData_Statics::NewProp_toVentuzFields,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UVentuzE2ESendData_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzE2ESendData>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UVentuzE2ESendData_Statics::ClassParams = {
		&UVentuzE2ESendData::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UVentuzE2ESendData_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESendData_Statics::PropPointers),
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UVentuzE2ESendData_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzE2ESendData_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UVentuzE2ESendData()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UVentuzE2ESendData_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UVentuzE2ESendData, 4292750695);
	template<> VENTUZEDITORPLUGIN_API UClass* StaticClass<UVentuzE2ESendData>()
	{
		return UVentuzE2ESendData::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UVentuzE2ESendData(Z_Construct_UClass_UVentuzE2ESendData, &UVentuzE2ESendData::StaticClass, TEXT("/Script/VentuzEditorPlugin"), TEXT("UVentuzE2ESendData"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzE2ESendData);
	void UVentuzGetValue::StaticRegisterNativesUVentuzGetValue()
	{
	}
	UClass* Z_Construct_UClass_UVentuzGetValue_NoRegister()
	{
		return UVentuzGetValue::StaticClass();
	}
	struct Z_Construct_UClass_UVentuzGetValue_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_type_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_type_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_type;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UVentuzGetValue_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UK2Node,
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzGetValue_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "//////////////////////////////////////////////////////////////////////////\n// From Ventuz Single Field Node\n" },
		{ "IncludePath", "VentuzDataGetterNode.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
		{ "ToolTip", "From Ventuz Single Field Node" },
	};
#endif
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type_MetaData[] = {
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type = { "type", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UVentuzGetValue, type), Z_Construct_UEnum_VentuzEditorPlugin_VentuzType, METADATA_PARAMS(Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UVentuzGetValue_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzGetValue_Statics::NewProp_type,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UVentuzGetValue_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzGetValue>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UVentuzGetValue_Statics::ClassParams = {
		&UVentuzGetValue::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UVentuzGetValue_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzGetValue_Statics::PropPointers),
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UVentuzGetValue_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzGetValue_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UVentuzGetValue()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UVentuzGetValue_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UVentuzGetValue, 3757664503);
	template<> VENTUZEDITORPLUGIN_API UClass* StaticClass<UVentuzGetValue>()
	{
		return UVentuzGetValue::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UVentuzGetValue(Z_Construct_UClass_UVentuzGetValue, &UVentuzGetValue::StaticClass, TEXT("/Script/VentuzEditorPlugin"), TEXT("UVentuzGetValue"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzGetValue);
	void UVentuzSendValue::StaticRegisterNativesUVentuzSendValue()
	{
	}
	UClass* Z_Construct_UClass_UVentuzSendValue_NoRegister()
	{
		return UVentuzSendValue::StaticClass();
	}
	struct Z_Construct_UClass_UVentuzSendValue_Statics
	{
		static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
		static const UE4CodeGen_Private::FBytePropertyParams NewProp_type_Underlying;
#if WITH_METADATA
		static const UE4CodeGen_Private::FMetaDataPairParam NewProp_type_MetaData[];
#endif
		static const UE4CodeGen_Private::FEnumPropertyParams NewProp_type;
		static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
		static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
		static const UE4CodeGen_Private::FClassParams ClassParams;
	};
	UObject* (*const Z_Construct_UClass_UVentuzSendValue_Statics::DependentSingletons[])() = {
		(UObject* (*)())Z_Construct_UClass_UK2Node,
		(UObject* (*)())Z_Construct_UPackage__Script_VentuzEditorPlugin,
	};
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzSendValue_Statics::Class_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "Comment", "//////////////////////////////////////////////////////////////////////////\n// To Ventuz Single Field Node\n" },
		{ "IncludePath", "VentuzDataGetterNode.h" },
		{ "IsBlueprintBase", "true" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
		{ "ToolTip", "To Ventuz Single Field Node" },
	};
#endif
	const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
	const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type_MetaData[] = {
		{ "Category", "Ventuz" },
		{ "ModuleRelativePath", "Public/VentuzDataGetterNode.h" },
	};
#endif
	const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type = { "type", nullptr, (EPropertyFlags)0x0010000000000005, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(UVentuzSendValue, type), Z_Construct_UEnum_VentuzEditorPlugin_VentuzType, METADATA_PARAMS(Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type_MetaData, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type_MetaData)) };
	const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UVentuzSendValue_Statics::PropPointers[] = {
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type_Underlying,
		(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UVentuzSendValue_Statics::NewProp_type,
	};
	const FCppClassTypeInfoStatic Z_Construct_UClass_UVentuzSendValue_Statics::StaticCppClassTypeInfo = {
		TCppClassTypeTraits<UVentuzSendValue>::IsAbstract,
	};
	const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UVentuzSendValue_Statics::ClassParams = {
		&UVentuzSendValue::StaticClass,
		nullptr,
		&StaticCppClassTypeInfo,
		DependentSingletons,
		nullptr,
		Z_Construct_UClass_UVentuzSendValue_Statics::PropPointers,
		nullptr,
		UE_ARRAY_COUNT(DependentSingletons),
		0,
		UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzSendValue_Statics::PropPointers),
		0,
		0x001000A0u,
		METADATA_PARAMS(Z_Construct_UClass_UVentuzSendValue_Statics::Class_MetaDataParams, UE_ARRAY_COUNT(Z_Construct_UClass_UVentuzSendValue_Statics::Class_MetaDataParams))
	};
	UClass* Z_Construct_UClass_UVentuzSendValue()
	{
		static UClass* OuterClass = nullptr;
		if (!OuterClass)
		{
			UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UVentuzSendValue_Statics::ClassParams);
		}
		return OuterClass;
	}
	IMPLEMENT_CLASS(UVentuzSendValue, 3681826701);
	template<> VENTUZEDITORPLUGIN_API UClass* StaticClass<UVentuzSendValue>()
	{
		return UVentuzSendValue::StaticClass();
	}
	static FCompiledInDefer Z_CompiledInDefer_UClass_UVentuzSendValue(Z_Construct_UClass_UVentuzSendValue, &UVentuzSendValue::StaticClass, TEXT("/Script/VentuzEditorPlugin"), TEXT("UVentuzSendValue"), false, nullptr, nullptr, nullptr);
	DEFINE_VTABLE_PTR_HELPER_CTOR(UVentuzSendValue);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
