// 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 "AGXUnrealBarrier/Public/Wire/AGX_WireEnums.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeAGX_WireEnums() {}
// Cross Module References
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireSide();
	AGXUNREALBARRIER_API UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType();
	UPackage* Z_Construct_UPackage__Script_AGXUnrealBarrier();
// End Cross Module References
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EWireNodeType;
	static UEnum* EWireNodeType_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EWireNodeType.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EWireNodeType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EWireNodeType"));
		}
		return Z_Registration_Info_UEnum_EWireNodeType.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EWireNodeType>()
	{
		return EWireNodeType_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enumerators[] = {
		{ "EWireNodeType::Free", (int64)EWireNodeType::Free },
		{ "EWireNodeType::Eye", (int64)EWireNodeType::Eye },
		{ "EWireNodeType::BodyFixed", (int64)EWireNodeType::BodyFixed },
		{ "EWireNodeType::NUM_USER_CREATABLE", (int64)EWireNodeType::NUM_USER_CREATABLE },
		{ "EWireNodeType::Connecting", (int64)EWireNodeType::Connecting },
		{ "EWireNodeType::Stop", (int64)EWireNodeType::Stop },
		{ "EWireNodeType::Contact", (int64)EWireNodeType::Contact },
		{ "EWireNodeType::ShapeContact", (int64)EWireNodeType::ShapeContact },
		{ "EWireNodeType::Other", (int64)EWireNodeType::Other },
		{ "EWireNodeType::NUM_NODE_TYPES", (int64)EWireNodeType::NUM_NODE_TYPES },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enum_MetaDataParams[] = {
		{ "BlueprintType", "true" },
		{ "BodyFixed.Name", "EWireNodeType::BodyFixed" },
		{ "Comment", "/**\n * Types of wire nodes we support in AGX Dynamics for Unreal.\n *\n * Suitable for array indexing.\n */" },
		{ "Connecting.HIDDEN", "" },
		{ "Connecting.Name", "EWireNodeType::Connecting" },
		{ "Contact.Comment", "// Internal node created by Wire Winch.\n" },
		{ "Contact.HIDDEN", "" },
		{ "Contact.Name", "EWireNodeType::Contact" },
		{ "Contact.ToolTip", "Internal node created by Wire Winch." },
		{ "Eye.Name", "EWireNodeType::Eye" },
		{ "Free.Name", "EWireNodeType::Free" },
		{ "ModuleRelativePath", "Public/Wire/AGX_WireEnums.h" },
		{ "NUM_NODE_TYPES.Comment", "// Any other node type that we don't allow a user to create directly.\n" },
		{ "NUM_NODE_TYPES.HIDDEN", "" },
		{ "NUM_NODE_TYPES.Name", "EWireNodeType::NUM_NODE_TYPES" },
		{ "NUM_NODE_TYPES.ToolTip", "Any other node type that we don't allow a user to create directly." },
		{ "NUM_USER_CREATABLE.HIDDEN", "" },
		{ "NUM_USER_CREATABLE.Name", "EWireNodeType::NUM_USER_CREATABLE" },
		{ "Other.Comment", "// Internal node created by dynamics contacts.\n" },
		{ "Other.HIDDEN", "" },
		{ "Other.Name", "EWireNodeType::Other" },
		{ "Other.ToolTip", "Internal node created by dynamics contacts." },
		{ "ShapeContact.Comment", "// Internal node created by dynamics contacts.\n" },
		{ "ShapeContact.HIDDEN", "" },
		{ "ShapeContact.Name", "EWireNodeType::ShapeContact" },
		{ "ShapeContact.ToolTip", "Internal node created by dynamics contacts." },
		{ "Stop.HIDDEN", "" },
		{ "Stop.Name", "EWireNodeType::Stop" },
		{ "ToolTip", "Types of wire nodes we support in AGX Dynamics for Unreal.\n\nSuitable for array indexing." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EWireNodeType",
		"EWireNodeType",
		Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType()
	{
		if (!Z_Registration_Info_UEnum_EWireNodeType.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EWireNodeType.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeType_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EWireNodeType.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EWireNodeNativeType;
	static UEnum* EWireNodeNativeType_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EWireNodeNativeType.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EWireNodeNativeType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EWireNodeNativeType"));
		}
		return Z_Registration_Info_UEnum_EWireNodeNativeType.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EWireNodeNativeType>()
	{
		return EWireNodeNativeType_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enumerators[] = {
		{ "EWireNodeNativeType::NOT_DEFINED", (int64)EWireNodeNativeType::NOT_DEFINED },
		{ "EWireNodeNativeType::Eye", (int64)EWireNodeNativeType::Eye },
		{ "EWireNodeNativeType::Missing", (int64)EWireNodeNativeType::Missing },
		{ "EWireNodeNativeType::Connecting", (int64)EWireNodeNativeType::Connecting },
		{ "EWireNodeNativeType::Free", (int64)EWireNodeNativeType::Free },
		{ "EWireNodeNativeType::Contact", (int64)EWireNodeNativeType::Contact },
		{ "EWireNodeNativeType::BodyFixed", (int64)EWireNodeNativeType::BodyFixed },
		{ "EWireNodeNativeType::Stop", (int64)EWireNodeNativeType::Stop },
		{ "EWireNodeNativeType::ShapeContact", (int64)EWireNodeNativeType::ShapeContact },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enum_MetaDataParams[] = {
		{ "BodyFixed.Name", "EWireNodeNativeType::BodyFixed" },
		{ "Comment", "/**\n * All wire node types in AGX Dynamics for Unreal.\n *\n * Bitfield, not suitable for array indexing\n */" },
		{ "Connecting.Name", "EWireNodeNativeType::Connecting" },
		{ "Contact.Name", "EWireNodeNativeType::Contact" },
		{ "Eye.Name", "EWireNodeNativeType::Eye" },
		{ "Free.Name", "EWireNodeNativeType::Free" },
		{ "Missing.Name", "EWireNodeNativeType::Missing" },
		{ "ModuleRelativePath", "Public/Wire/AGX_WireEnums.h" },
		{ "NOT_DEFINED.Comment", "// These much match the values of agxWire::Node::Type in agxWire/Node.h.\n" },
		{ "NOT_DEFINED.Name", "EWireNodeNativeType::NOT_DEFINED" },
		{ "NOT_DEFINED.ToolTip", "These much match the values of agxWire::Node::Type in agxWire/Node.h." },
		{ "ShapeContact.Name", "EWireNodeNativeType::ShapeContact" },
		{ "Stop.Name", "EWireNodeNativeType::Stop" },
		{ "ToolTip", "All wire node types in AGX Dynamics for Unreal.\n\nBitfield, not suitable for array indexing" },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EWireNodeNativeType",
		"EWireNodeNativeType",
		Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType()
	{
		if (!Z_Registration_Info_UEnum_EWireNodeNativeType.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EWireNodeNativeType.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EWireNodeNativeType_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EWireNodeNativeType.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EWireWinchOwnerType;
	static UEnum* EWireWinchOwnerType_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EWireWinchOwnerType.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EWireWinchOwnerType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EWireWinchOwnerType"));
		}
		return Z_Registration_Info_UEnum_EWireWinchOwnerType.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EWireWinchOwnerType>()
	{
		return EWireWinchOwnerType_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enumerators[] = {
		{ "EWireWinchOwnerType::None", (int64)EWireWinchOwnerType::None },
		{ "EWireWinchOwnerType::Wire", (int64)EWireWinchOwnerType::Wire },
		{ "EWireWinchOwnerType::WireWinch", (int64)EWireWinchOwnerType::WireWinch },
		{ "EWireWinchOwnerType::Other", (int64)EWireWinchOwnerType::Other },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enum_MetaDataParams[] = {
		{ "Comment", "/**\n * The type of Component that this Wire Winch is part of, or which type of Component this Wire Winch\n * points to if we are currently modifying a Wire Component.\n */" },
		{ "ModuleRelativePath", "Public/Wire/AGX_WireEnums.h" },
		{ "None.Comment", "// No which.\n" },
		{ "None.Name", "EWireWinchOwnerType::None" },
		{ "None.ToolTip", "No which." },
		{ "Other.Comment", "// When used as an Outer designator, the Wire Winch is part of something that is neither a Wire\n// Component nor a Wire Winch Component. Much of the Wire Winch Details functionality is\n// disabled in this case.\n//\n// When used as a Target designator, the Wire relinquish all responsibility of the the Wire\n// Winch settings setup and will use whatever UAGX_WireComponent::BorrowedBeginWinch points to.\n" },
		{ "Other.Name", "EWireWinchOwnerType::Other" },
		{ "Other.ToolTip", "When used as an Outer designator, the Wire Winch is part of something that is neither a Wire\nComponent nor a Wire Winch Component. Much of the Wire Winch Details functionality is\ndisabled in this case.\n\nWhen used as a Target designator, the Wire relinquish all responsibility of the the Wire\nWinch settings setup and will use whatever UAGX_WireComponent::BorrowedBeginWinch points to." },
		{ "ToolTip", "The type of Component that this Wire Winch is part of, or which type of Component this Wire Winch\npoints to if we are currently modifying a Wire Component." },
		{ "Wire.Comment", "// When used as an Outer designator, the Wire Winch is on one of the two ends of a Wire\n// Component. We are not editing an actual Wire Winch, but a reference to one.\n//\n// When used as a Target designator, a new Wire Winch instance should be created for the Wire\n// Component.\n" },
		{ "Wire.Name", "EWireWinchOwnerType::Wire" },
		{ "Wire.ToolTip", "When used as an Outer designator, the Wire Winch is on one of the two ends of a Wire\nComponent. We are not editing an actual Wire Winch, but a reference to one.\n\nWhen used as a Target designator, a new Wire Winch instance should be created for the Wire\nComponent." },
		{ "WireWinch.Comment", "// When used as an Outer designator, the Wire Winch is on a Wire Winch Component.\n//\n// When used as a Target designator, the Wire should have a pointer to the Wire Winch inside a\n// Wire Winch Component.\n" },
		{ "WireWinch.Name", "EWireWinchOwnerType::WireWinch" },
		{ "WireWinch.ToolTip", "When used as an Outer designator, the Wire Winch is on a Wire Winch Component.\n\nWhen used as a Target designator, the Wire should have a pointer to the Wire Winch inside a\nWire Winch Component." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EWireWinchOwnerType",
		"EWireWinchOwnerType",
		Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType()
	{
		if (!Z_Registration_Info_UEnum_EWireWinchOwnerType.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EWireWinchOwnerType.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EWireWinchOwnerType_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EWireWinchOwnerType.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EWireSide;
	static UEnum* EWireSide_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EWireSide.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EWireSide.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EWireSide, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EWireSide"));
		}
		return Z_Registration_Info_UEnum_EWireSide.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EWireSide>()
	{
		return EWireSide_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enumerators[] = {
		{ "EWireSide::None", (int64)EWireSide::None },
		{ "EWireSide::Begin", (int64)EWireSide::Begin },
		{ "EWireSide::End", (int64)EWireSide::End },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enum_MetaDataParams[] = {
		{ "Begin.Name", "EWireSide::Begin" },
		{ "BlueprintType", "true" },
		{ "Comment", "/**\n * Used to select which side of a wire is being operator on. The Begin side is the side represented\n * by the wire's first route node, while the end side is the on at the node last in the wires route\n * nodes list.\n */" },
		{ "End.Name", "EWireSide::End" },
		{ "ModuleRelativePath", "Public/Wire/AGX_WireEnums.h" },
		{ "None.Name", "EWireSide::None" },
		{ "ToolTip", "Used to select which side of a wire is being operator on. The Begin side is the side represented\nby the wire's first route node, while the end side is the on at the node last in the wires route\nnodes list." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EWireSide",
		"EWireSide",
		Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWireSide()
	{
		if (!Z_Registration_Info_UEnum_EWireSide.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EWireSide.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EWireSide_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EWireSide.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EWinchSide;
	static UEnum* EWinchSide_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EWinchSide.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EWinchSide.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide, (UObject*)Z_Construct_UPackage__Script_AGXUnrealBarrier(), TEXT("EWinchSide"));
		}
		return Z_Registration_Info_UEnum_EWinchSide.OuterSingleton;
	}
	template<> AGXUNREALBARRIER_API UEnum* StaticEnum<EWinchSide>()
	{
		return EWinchSide_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics
	{
		static const UECodeGen_Private::FEnumeratorParam Enumerators[];
#if WITH_METADATA
		static const UECodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[];
#endif
		static const UECodeGen_Private::FEnumParams EnumParams;
	};
	const UECodeGen_Private::FEnumeratorParam Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enumerators[] = {
		{ "EWinchSide::None", (int64)EWinchSide::None },
		{ "EWinchSide::Location", (int64)EWinchSide::Location },
		{ "EWinchSide::Rotation", (int64)EWinchSide::Rotation },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enum_MetaDataParams[] = {
		{ "Comment", "/*\n * Used to select either the location Hit Proxy or the rotation Hit Proxy when manipulating a Wire\n * Winch using the Component Visualizer.\n */" },
		{ "Location.Name", "EWinchSide::Location" },
		{ "ModuleRelativePath", "Public/Wire/AGX_WireEnums.h" },
		{ "None.Name", "EWinchSide::None" },
		{ "Rotation.Name", "EWinchSide::Rotation" },
		{ "ToolTip", "* Used to select either the location Hit Proxy or the rotation Hit Proxy when manipulating a Wire\n* Winch using the Component Visualizer." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnrealBarrier,
		nullptr,
		"EWinchSide",
		"EWinchSide",
		Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide()
	{
		if (!Z_Registration_Info_UEnum_EWinchSide.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EWinchSide.InnerSingleton, Z_Construct_UEnum_AGXUnrealBarrier_EWinchSide_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EWinchSide.InnerSingleton;
	}
	struct Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Wire_AGX_WireEnums_h_Statics
	{
		static const FEnumRegisterCompiledInInfo EnumInfo[];
	};
	const FEnumRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Wire_AGX_WireEnums_h_Statics::EnumInfo[] = {
		{ EWireNodeType_StaticEnum, TEXT("EWireNodeType"), &Z_Registration_Info_UEnum_EWireNodeType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1144359566U) },
		{ EWireNodeNativeType_StaticEnum, TEXT("EWireNodeNativeType"), &Z_Registration_Info_UEnum_EWireNodeNativeType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 267149596U) },
		{ EWireWinchOwnerType_StaticEnum, TEXT("EWireWinchOwnerType"), &Z_Registration_Info_UEnum_EWireWinchOwnerType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2864077937U) },
		{ EWireSide_StaticEnum, TEXT("EWireSide"), &Z_Registration_Info_UEnum_EWireSide, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2954210291U) },
		{ EWinchSide_StaticEnum, TEXT("EWinchSide"), &Z_Registration_Info_UEnum_EWinchSide, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2518578059U) },
	};
	static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Wire_AGX_WireEnums_h_4126629697(TEXT("/Script/AGXUnrealBarrier"),
		nullptr, 0,
		nullptr, 0,
		Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Wire_AGX_WireEnums_h_Statics::EnumInfo, UE_ARRAY_COUNT(Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnrealBarrier_Public_Wire_AGX_WireEnums_h_Statics::EnumInfo));
PRAGMA_ENABLE_DEPRECATION_WARNINGS
