// 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 "AGXUnreal/Public/Constraints/AGX_ConstraintEnums.h"
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeAGX_ConstraintEnums() {}
// Cross Module References
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource();
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_SolveType();
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EDofFlag();
	AGXUNREAL_API UEnum* Z_Construct_UEnum_AGXUnreal_EGenericDofIndex();
	UPackage* Z_Construct_UPackage__Script_AGXUnreal();
// End Cross Module References
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_SolveType;
	static UEnum* EAGX_SolveType_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_SolveType.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_SolveType.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnreal_EAGX_SolveType, (UObject*)Z_Construct_UPackage__Script_AGXUnreal(), TEXT("EAGX_SolveType"));
		}
		return Z_Registration_Info_UEnum_EAGX_SolveType.OuterSingleton;
	}
	template<> AGXUNREAL_API UEnum* StaticEnum<EAGX_SolveType>()
	{
		return EAGX_SolveType_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_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_AGXUnreal_EAGX_SolveType_Statics::Enumerators[] = {
		{ "StDirect", (int64)StDirect },
		{ "StIterative", (int64)StIterative },
		{ "StDirectAndIterative", (int64)StDirectAndIterative },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::Enum_MetaDataParams[] = {
		{ "Comment", "/** Specifies in what solvers the constraint will be solved. */" },
		{ "ModuleRelativePath", "Public/Constraints/AGX_ConstraintEnums.h" },
		{ "StDirect.Comment", "/** Solved only in the DIRECT solver. */" },
		{ "StDirect.DisplayName", "Direct" },
		{ "StDirect.Name", "StDirect" },
		{ "StDirect.ToolTip", "Solved only in the DIRECT solver." },
		{ "StDirectAndIterative.Comment", "/** Solved both in the ITERATIVE and the DIRECT solver. */" },
		{ "StDirectAndIterative.DisplayName", "Direct & Iterative" },
		{ "StDirectAndIterative.Name", "StDirectAndIterative" },
		{ "StDirectAndIterative.ToolTip", "Solved both in the ITERATIVE and the DIRECT solver." },
		{ "StIterative.Comment", "/** Solved only in the ITERATIVE solver. */" },
		{ "StIterative.DisplayName", "Iterative" },
		{ "StIterative.Name", "StIterative" },
		{ "StIterative.ToolTip", "Solved only in the ITERATIVE solver." },
		{ "ToolTip", "Specifies in what solvers the constraint will be solved." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal,
		nullptr,
		"EAGX_SolveType",
		"EAGX_SolveType",
		Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::Regular,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_SolveType()
	{
		if (!Z_Registration_Info_UEnum_EAGX_SolveType.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_SolveType.InnerSingleton, Z_Construct_UEnum_AGXUnreal_EAGX_SolveType_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_SolveType.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EAGX_FrameDefiningSource;
	static UEnum* EAGX_FrameDefiningSource_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource, (UObject*)Z_Construct_UPackage__Script_AGXUnreal(), TEXT("EAGX_FrameDefiningSource"));
		}
		return Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.OuterSingleton;
	}
	template<> AGXUNREAL_API UEnum* StaticEnum<EAGX_FrameDefiningSource>()
	{
		return EAGX_FrameDefiningSource_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_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_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enumerators[] = {
		{ "Constraint", (int64)Constraint },
		{ "RigidBody", (int64)RigidBody },
		{ "Other", (int64)Other },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enum_MetaDataParams[] = {
		{ "Comment", "/** Specifies which Actor or Component is used to define the transform of the attachment frame of\n * the Constraint's Body Attachment. */" },
		{ "Constraint.Comment", "/** The transformation of the Constraint itself is used to define the transform of the\n\x09   attachment frame. */" },
		{ "Constraint.DisplayName", "Constraint" },
		{ "Constraint.Name", "Constraint" },
		{ "Constraint.ToolTip", "The transformation of the Constraint itself is used to define the transform of the\n         attachment frame." },
		{ "ModuleRelativePath", "Public/Constraints/AGX_ConstraintEnums.h" },
		{ "Other.Comment", "/** The transformation of some other Actor or Component is used to define the transform of the\n\x09   attachment frame. */" },
		{ "Other.DisplayName", "Other" },
		{ "Other.Name", "Other" },
		{ "Other.ToolTip", "The transformation of some other Actor or Component is used to define the transform of the\n         attachment frame." },
		{ "RigidBody.Comment", "/** The transformation of the Rigid Body is used to define the transform of the attachment\n\x09   frame. */" },
		{ "RigidBody.DisplayName", "RigidBody" },
		{ "RigidBody.Name", "RigidBody" },
		{ "RigidBody.ToolTip", "The transformation of the Rigid Body is used to define the transform of the attachment\n         frame." },
		{ "ToolTip", "Specifies which Actor or Component is used to define the transform of the attachment frame of\nthe Constraint's Body Attachment." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal,
		nullptr,
		"EAGX_FrameDefiningSource",
		"EAGX_FrameDefiningSource",
		Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::Regular,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource()
	{
		if (!Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.InnerSingleton, Z_Construct_UEnum_AGXUnreal_EAGX_FrameDefiningSource_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EAGX_FrameDefiningSource.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EGenericDofIndex;
	static UEnum* EGenericDofIndex_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EGenericDofIndex.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EGenericDofIndex.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnreal_EGenericDofIndex, (UObject*)Z_Construct_UPackage__Script_AGXUnreal(), TEXT("EGenericDofIndex"));
		}
		return Z_Registration_Info_UEnum_EGenericDofIndex.OuterSingleton;
	}
	template<> AGXUNREAL_API UEnum* StaticEnum<EGenericDofIndex>()
	{
		return EGenericDofIndex_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_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_AGXUnreal_EGenericDofIndex_Statics::Enumerators[] = {
		{ "EGenericDofIndex::AllDof", (int64)EGenericDofIndex::AllDof },
		{ "EGenericDofIndex::Translational1", (int64)EGenericDofIndex::Translational1 },
		{ "EGenericDofIndex::Translational2", (int64)EGenericDofIndex::Translational2 },
		{ "EGenericDofIndex::Translational3", (int64)EGenericDofIndex::Translational3 },
		{ "EGenericDofIndex::Rotational1", (int64)EGenericDofIndex::Rotational1 },
		{ "EGenericDofIndex::Rotational2", (int64)EGenericDofIndex::Rotational2 },
		{ "EGenericDofIndex::Rotational3", (int64)EGenericDofIndex::Rotational3 },
		{ "EGenericDofIndex::NumDofs", (int64)EGenericDofIndex::NumDofs },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::Enum_MetaDataParams[] = {
		{ "AllDof.Comment", "/** All degrees of freedom */" },
		{ "AllDof.DisplayName", "All" },
		{ "AllDof.Name", "EGenericDofIndex::AllDof" },
		{ "AllDof.ToolTip", "All degrees of freedom" },
		{ "Comment", "/**\n * Constraint type independent index of Degree of Freedom(DOF).Does never change\n * index order layout, even in derived constraints, contrary to the AGX's native\n * constraint-specific DOF indexes.\n */" },
		{ "ModuleRelativePath", "Public/Constraints/AGX_ConstraintEnums.h" },
		{ "NumDofs.Hidden", "" },
		{ "NumDofs.Name", "EGenericDofIndex::NumDofs" },
		{ "Rotational1.Comment", "/** DOF corresponding to the first rotational axis */" },
		{ "Rotational1.DisplayName", "Rotation1" },
		{ "Rotational1.Name", "EGenericDofIndex::Rotational1" },
		{ "Rotational1.ToolTip", "DOF corresponding to the first rotational axis" },
		{ "Rotational2.Comment", "/** DOF corresponding to the second rotational axis */" },
		{ "Rotational2.DisplayName", "Rotation2" },
		{ "Rotational2.Name", "EGenericDofIndex::Rotational2" },
		{ "Rotational2.ToolTip", "DOF corresponding to the second rotational axis" },
		{ "Rotational3.Comment", "/** DOF for rotation around Z-axis */" },
		{ "Rotational3.DisplayName", "Rotation3" },
		{ "Rotational3.Name", "EGenericDofIndex::Rotational3" },
		{ "Rotational3.ToolTip", "DOF for rotation around Z-axis" },
		{ "ToolTip", "Constraint type independent index of Degree of Freedom(DOF).Does never change\nindex order layout, even in derived constraints, contrary to the AGX's native\nconstraint-specific DOF indexes." },
		{ "Translational1.Comment", "/** DOF for the first translational axis */" },
		{ "Translational1.DisplayName", "Translation1" },
		{ "Translational1.Name", "EGenericDofIndex::Translational1" },
		{ "Translational1.ToolTip", "DOF for the first translational axis" },
		{ "Translational2.Comment", "/** DOF for the second translational axis */" },
		{ "Translational2.DisplayName", "Translation2" },
		{ "Translational2.Name", "EGenericDofIndex::Translational2" },
		{ "Translational2.ToolTip", "DOF for the second translational axis" },
		{ "Translational3.Comment", "/** DOF for the third translational axis */" },
		{ "Translational3.DisplayName", "Translation3" },
		{ "Translational3.Name", "EGenericDofIndex::Translational3" },
		{ "Translational3.ToolTip", "DOF for the third translational axis" },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal,
		nullptr,
		"EGenericDofIndex",
		"EGenericDofIndex",
		Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnreal_EGenericDofIndex()
	{
		if (!Z_Registration_Info_UEnum_EGenericDofIndex.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EGenericDofIndex.InnerSingleton, Z_Construct_UEnum_AGXUnreal_EGenericDofIndex_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EGenericDofIndex.InnerSingleton;
	}
	static FEnumRegistrationInfo Z_Registration_Info_UEnum_EDofFlag;
	static UEnum* EDofFlag_StaticEnum()
	{
		if (!Z_Registration_Info_UEnum_EDofFlag.OuterSingleton)
		{
			Z_Registration_Info_UEnum_EDofFlag.OuterSingleton = GetStaticEnum(Z_Construct_UEnum_AGXUnreal_EDofFlag, (UObject*)Z_Construct_UPackage__Script_AGXUnreal(), TEXT("EDofFlag"));
		}
		return Z_Registration_Info_UEnum_EDofFlag.OuterSingleton;
	}
	template<> AGXUNREAL_API UEnum* StaticEnum<EDofFlag>()
	{
		return EDofFlag_StaticEnum();
	}
	struct Z_Construct_UEnum_AGXUnreal_EDofFlag_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_AGXUnreal_EDofFlag_Statics::Enumerators[] = {
		{ "EDofFlag::DOF_FLAG_ALL", (int64)EDofFlag::DOF_FLAG_ALL },
		{ "EDofFlag::DofFlagTranslational1", (int64)EDofFlag::DofFlagTranslational1 },
		{ "EDofFlag::DofFlagTranslational2", (int64)EDofFlag::DofFlagTranslational2 },
		{ "EDofFlag::DofFlagTranslational3", (int64)EDofFlag::DofFlagTranslational3 },
		{ "EDofFlag::DofFlagRotational1", (int64)EDofFlag::DofFlagRotational1 },
		{ "EDofFlag::DofFlagRotational2", (int64)EDofFlag::DofFlagRotational2 },
		{ "EDofFlag::DofFlagRotational3", (int64)EDofFlag::DofFlagRotational3 },
	};
#if WITH_METADATA
	const UECodeGen_Private::FMetaDataPairParam Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::Enum_MetaDataParams[] = {
		{ "Bitflags", "" },
		{ "Comment", "/**\n * Flags used to be able to identify DOFs and combine them into a bitmask.\n */" },
		{ "DOF_FLAG_ALL.DisplayName", "All" },
		{ "DOF_FLAG_ALL.Name", "EDofFlag::DOF_FLAG_ALL" },
		{ "DofFlagRotational1.DisplayName", "Rotation1" },
		{ "DofFlagRotational1.Name", "EDofFlag::DofFlagRotational1" },
		{ "DofFlagRotational2.DisplayName", "Rotation2" },
		{ "DofFlagRotational2.Name", "EDofFlag::DofFlagRotational2" },
		{ "DofFlagRotational3.DisplayName", "Rotation3" },
		{ "DofFlagRotational3.Name", "EDofFlag::DofFlagRotational3" },
		{ "DofFlagTranslational1.Comment", "//\x09""DOF_FLAG_NONE = 0 UMETA(DisplayName = \"None\"), /// \\todo Consider adding this. When would it\n// be used?\n" },
		{ "DofFlagTranslational1.DisplayName", "Translation1" },
		{ "DofFlagTranslational1.Name", "EDofFlag::DofFlagTranslational1" },
		{ "DofFlagTranslational1.ToolTip", "DOF_FLAG_NONE = 0 UMETA(DisplayName = \"None\"),  \\todo Consider adding this. When would it\nbe used?" },
		{ "DofFlagTranslational2.DisplayName", "Translation2" },
		{ "DofFlagTranslational2.Name", "EDofFlag::DofFlagTranslational2" },
		{ "DofFlagTranslational3.DisplayName", "Translation3" },
		{ "DofFlagTranslational3.Name", "EDofFlag::DofFlagTranslational3" },
		{ "ModuleRelativePath", "Public/Constraints/AGX_ConstraintEnums.h" },
		{ "ToolTip", "Flags used to be able to identify DOFs and combine them into a bitmask." },
	};
#endif
	const UECodeGen_Private::FEnumParams Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::EnumParams = {
		(UObject*(*)())Z_Construct_UPackage__Script_AGXUnreal,
		nullptr,
		"EDofFlag",
		"EDofFlag",
		Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::Enumerators,
		RF_Public|RF_Transient|RF_MarkAsNative,
		UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::Enumerators),
		EEnumFlags::None,
		(uint8)UEnum::ECppForm::EnumClass,
		METADATA_PARAMS(UE_ARRAY_COUNT(Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::Enum_MetaDataParams), Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::Enum_MetaDataParams)
	};
	UEnum* Z_Construct_UEnum_AGXUnreal_EDofFlag()
	{
		if (!Z_Registration_Info_UEnum_EDofFlag.InnerSingleton)
		{
			UECodeGen_Private::ConstructUEnum(Z_Registration_Info_UEnum_EDofFlag.InnerSingleton, Z_Construct_UEnum_AGXUnreal_EDofFlag_Statics::EnumParams);
		}
		return Z_Registration_Info_UEnum_EDofFlag.InnerSingleton;
	}
	struct Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_Constraints_AGX_ConstraintEnums_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_AGXUnreal_Public_Constraints_AGX_ConstraintEnums_h_Statics::EnumInfo[] = {
		{ EAGX_SolveType_StaticEnum, TEXT("EAGX_SolveType"), &Z_Registration_Info_UEnum_EAGX_SolveType, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1778901504U) },
		{ EAGX_FrameDefiningSource_StaticEnum, TEXT("EAGX_FrameDefiningSource"), &Z_Registration_Info_UEnum_EAGX_FrameDefiningSource, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 2494021846U) },
		{ EGenericDofIndex_StaticEnum, TEXT("EGenericDofIndex"), &Z_Registration_Info_UEnum_EGenericDofIndex, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 3518285832U) },
		{ EDofFlag_StaticEnum, TEXT("EDofFlag"), &Z_Registration_Info_UEnum_EDofFlag, CONSTRUCT_RELOAD_VERSION_INFO(FEnumReloadVersionInfo, 1180093694U) },
	};
	static FRegisterCompiledInInfo Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_Constraints_AGX_ConstraintEnums_h_1397233851(TEXT("/Script/AGXUnreal"),
		nullptr, 0,
		nullptr, 0,
		Z_CompiledInDeferFile_FID_GitLab_Runner_builds_9YzzThLq_0_algoryx_unreal_agxunreal_staging_selfhosted_build_AGXUnreal_HostProject_Plugins_AGXUnreal_Source_AGXUnreal_Public_Constraints_AGX_ConstraintEnums_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_AGXUnreal_Public_Constraints_AGX_ConstraintEnums_h_Statics::EnumInfo));
PRAGMA_ENABLE_DEPRECATION_WARNINGS
