// Copyright (c) 2024 Codemongous LLC. All Rights Reserved.

#include "SourcifyCoreUEWrapperModule.h"

#include "AIGraph.h"
#include "AnimationGraph.h"
#include "BaseWidgetBlueprint.h"
#include "BehaviorTreeGraph.h"
#include "BehaviorTree/BehaviorTree.h"
#include "BehaviorTree/BlackboardData.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType_Enum.h"
#include "BehaviorTree/Blackboard/BlackboardKeyType.h"
#include "Blueprint/UserWidgetBlueprint.h"
#include "Blueprint/WidgetBlueprintGeneratedClass.h"
#include "Blueprint/WidgetTree.h"
#include "Components/MeshComponent.h"
#include "Components/Visual.h"
#include "Components/Widget.h"
#include "Components/WidgetComponent.h"
#include "EdGraphSchema_K2.h"
#include "Engine/DataTable.h"
#include "Engine/Level.h"
#include "Engine/LevelScriptBlueprint.h"
#include "Engine/SCS_Node.h"
#include "Engine/UserDefinedEnum.h"
#include "Engine/UserDefinedStruct.h"
#include "Engine/World.h"
#include "GeneralProjectSettings.h"
#include "K2Node_AddComponent.h"
#include "K2Node_AddDelegate.h"
#include "K2Node_AssignDelegate.h"
#include "K2Node_BaseMCDelegate.h"
#include "K2Node_BreakStruct.h"
#include "K2Node_CallArrayFunction.h"
#include "K2Node_CallParentFunction.h"
#include "K2Node_CastByteToEnum.h"
#include "K2Node_ComponentBoundEvent.h"
#include "K2Node_CreateDelegate.h"
#include "K2Node_CustomEvent.h"
#include "K2Node_DynamicCast.h"
#include "K2Node_EnumEquality.h"
#include "K2Node_ForEachElementInEnum.h"
#include "K2Node_FunctionEntry.h"
#include "K2Node_FunctionResult.h"
#include "K2Node_FunctionTerminator.h"
#include "K2Node_GetArrayItem.h"
#include "K2Node_MacroInstance.h"
#include "K2Node_MakeStruct.h"
#include "K2Node_Message.h"
#include "K2Node_Select.h"
#include "K2Node_SetFieldsInStruct.h"
#include "K2Node_StructMemberGet.h"
#include "K2Node_StructMemberSet.h"
#include "K2Node_StructOperation.h"
#include "K2Node_Switch.h"
#include "K2Node_SwitchEnum.h"
#include "K2Node_VariableGet.h"
#include "K2Node_VariableSet.h"
#include "LevelSequence.h"
#include "Modules/ModuleManager.h"
#include "MovieSceneSequence.h"
#include "MovieSceneSignedObject.h"
#include "StateTree.h"
#include "SCW_AActor.h"
#include "SCW_Base.h"
#include "SCW_FArrayProperty.h"
#include "SCW_FAssetData.h"
#include "SCW_FBlackboardEntry.h"
#include "SCW_FBoolProperty.h"
#include "SCW_FBPInterfaceDescription.h"
#include "SCW_FBPVariableDescription.h"
#include "SCW_FByteProperty.h"
#include "SCW_FClassProperty.h"
#include "SCW_FComponentKey.h"
#include "SCW_FDelegateProperty.h"
#include "SCW_FDoubleProperty.h"
#include "SCW_FEdGraphPinType.h"
#include "SCW_FEdGraphTerminalType.h"
#include "SCW_FEnumProperty.h"
#include "SCW_FField.h"
#include "SCW_FFieldVariant.h"
#include "SCW_FFloatProperty.h"
#include "SCW_FGraphNodeCreator.h"
#include "SCW_FImplementedInterface.h"
#include "SCW_FInterfaceProperty.h"
#include "SCW_FMapProperty.h"
#include "SCW_FMemberReference.h"
#include "SCW_FMulticastDelegateProperty.h"
#include "SCW_FNameProperty.h"
#include "SCW_FNumericProperty.h"
#include "SCW_FObjectProperty.h"
#include "SCW_FObjectPropertyBase.h"
#include "SCW_FOptionalPinFromProperty.h"
#include "SCW_FProperty.h"
#include "SCW_FPropertyChangedEvent.h"
#include "SCW_FSetProperty.h"
#include "SCW_FSimpleMemberReference.h"
#include "SCW_FSlowTask.h"
#include "SCW_FSoftClassProperty.h"
#include "SCW_FSoftObjectProperty.h"
#include "SCW_FStrProperty.h"
#include "SCW_FStructProperty.h"
#include "SCW_FStructVariableDescription.h"
#include "SCW_FSubobjectData.h"
#include "SCW_FSubobjectDataHandle.h"
#include "SCW_FTextProperty.h"
#include "SCW_FUserPinInfo.h"
#include "SCW_FWeakObjectProperty.h"
#include "SCW_UAIGraph.h"
#include "SCW_UActorComponent.h"
#include "SCW_UAnimationGraph.h"
#include "SCW_UAnimBlueprint.h"
#include "SCW_UBaseWidgetBlueprint.h"
#include "SCW_UBehaviorTree.h"
#include "SCW_UBehaviorTreeGraph.h"
#include "SCW_UBlackboardData.h"
#include "SCW_UBlackboardKeyType.h"
#include "SCW_UBlackboardKeyType_Enum.h"
#include "SCW_UBlueprint.h"
#include "SCW_UBlueprintGeneratedClass.h"
#include "SCW_UClass.h"
#include "SCW_UDataAsset.h"
#include "SCW_UDataTable.h"
#include "SCW_UEdGraph.h"
#include "SCW_UEdGraphNode.h"
#include "SCW_UEdGraphPin.h"
#include "SCW_UEdGraphSchema.h"
#include "SCW_UEdGraphSchema_K2.h"
#include "SCW_UEnum.h"
#include "SCW_UField.h"
#include "SCW_UFunction.h"
#include "SCW_UGeneralProjectSettings.h"
#include "SCW_UInheritableComponentHandler.h"
#include "SCW_UInterface.h"
#include "SCW_UK2Node.h"
#include "SCW_UK2Node_AddComponent.h"
#include "SCW_UK2Node_AddDelegate.h"
#include "SCW_UK2Node_AssignDelegate.h"
#include "SCW_UK2Node_BaseMCDelegate.h"
#include "SCW_UK2Node_BreakStruct.h"
#include "SCW_UK2Node_CallArrayFunction.h"
#include "SCW_UK2Node_CallFunction.h"
#include "SCW_UK2Node_CallParentFunction.h"
#include "SCW_UK2Node_CastByteToEnum.h"
#include "SCW_UK2Node_ComponentBoundEvent.h"
#include "SCW_UK2Node_CreateDelegate.h"
#include "SCW_UK2Node_CustomEvent.h"
#include "SCW_UK2Node_DynamicCast.h"
#include "SCW_UK2Node_EditablePinBase.h"
#include "SCW_UK2Node_EnumEquality.h"
#include "SCW_UK2Node_Event.h"
#include "SCW_UK2Node_ForEachElementInEnum.h"
#include "SCW_UK2Node_FunctionEntry.h"
#include "SCW_UK2Node_FunctionResult.h"
#include "SCW_UK2Node_FunctionTerminator.h"
#include "SCW_UK2Node_GetArrayItem.h"
#include "SCW_UK2Node_MacroInstance.h"
#include "SCW_UK2Node_MakeStruct.h"
#include "SCW_UK2Node_Message.h"
#include "SCW_UK2Node_Select.h"
#include "SCW_UK2Node_SetFieldsInStruct.h"
#include "SCW_UK2Node_StructMemberGet.h"
#include "SCW_UK2Node_StructMemberSet.h"
#include "SCW_UK2Node_StructOperation.h"
#include "SCW_UK2Node_Switch.h"
#include "SCW_UK2Node_SwitchEnum.h"
#include "SCW_UK2Node_Tunnel.h"
#include "SCW_UK2Node_Variable.h"
#include "SCW_UK2Node_VariableGet.h"
#include "SCW_UK2Node_VariableSet.h"
#include "SCW_ULevel.h"
#include "SCW_ULevelScriptBlueprint.h"
#include "SCW_ULevelSequence.h"
#include "SCW_UMeshComponent.h"
#if ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)
#include "SCW_UMetaData.h"
#else
#include "SCW_FMetaData.h"
#endif // ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)
#include "SCW_UMovieSceneSequence.h"
#include "SCW_UMovieSceneSignedObject.h"
#include "SCW_UObjectRedirector.h"
#include "SCW_UnrealEngine.h"
#include "SCW_UObject.h"
#include "SCW_UPackage.h"
#include "SCW_UPrimitiveComponent.h"
#include "SCW_UPropertyWrapper.h"
#include "SCW_USceneComponent.h"
#include "SCW_UScriptStruct.h"
#include "SCW_USCS_Node.h"
#include "SCW_USimpleConstructionScript.h"
#if ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5,5,0)
#include "SCW_UStateTree.h"
#endif
#include "SCW_UStruct.h"
#include "SCW_UUserDefinedEnum.h"
#include "SCW_UUserDefinedStruct.h"
#include "SCW_UUserDefinedStructEditorData.h"
#include "SCW_UUserWidgetBlueprint.h"
#include "SCW_UVisual.h"
#include "SCW_UWidget.h"
#include "SCW_UWidgetBlueprint.h"
#include "SCW_UWidgetBlueprintGeneratedClass.h"
#include "SCW_UWidgetComponent.h"
#include "SCW_UWidgetTree.h"
#include "SCW_UWorld.h"
#include "UObject/NoExportTypes.h"
#include "UserDefinedStructure/UserDefinedStructEditorData.h"
#include "WidgetBlueprint.h"

using namespace Sourcify;
using std::dynamic_pointer_cast;

IMPLEMENT_MODULE(FSourcifyCoreUEWrapper, SourcifyCoreUEWrapper);

void FSourcifyCoreUEWrapper::StartupModule()
{
}

void FSourcifyCoreUEWrapper::ShutdownModule()
{
}

ISCW_UnrealEnginePtr FSourcifyCoreUEWrapper::CreateEngineInterface() const
{
	return std::make_shared<SCW_UnrealEngine>();
}

UBlueprint* FSourcifyCoreUEWrapper::Unwrap(ISCW_UBlueprintConstPtr Blueprint)
{
	return dynamic_cast<const SCW_UBlueprint*>(Blueprint.get())->ToUBlueprintRawPtr();
}

UObject* FSourcifyCoreUEWrapper::Unwrap(ISCW_UObjectConstPtr Object)
{
	return dynamic_cast<const SCW_UObject*>(Object.get())->ToUObjectRawPtr();
}

UPackage* FSourcifyCoreUEWrapper::Unwrap(ISCW_UPackageConstPtr Package)
{
	return dynamic_cast<const SCW_UPackage*>(Package.get())->ToUPackage();
}

// PUBLIC WRAPPERS BEGIN
ISCW_AActorPtr FSourcifyCoreUEWrapper::Wrap(AActor& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_AActor>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FArrayPropertyPtr FSourcifyCoreUEWrapper::Wrap(FArrayProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FArrayProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FAssetDataPtr FSourcifyCoreUEWrapper::Wrap(FAssetData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FAssetData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FBPInterfaceDescriptionPtr FSourcifyCoreUEWrapper::Wrap(FBPInterfaceDescription& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FBPInterfaceDescription>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FBPVariableDescriptionPtr FSourcifyCoreUEWrapper::Wrap(FBPVariableDescription& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FBPVariableDescription>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FBlackboardEntryPtr FSourcifyCoreUEWrapper::Wrap(FBlackboardEntry& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FBlackboardEntry>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FBoolPropertyPtr FSourcifyCoreUEWrapper::Wrap(FBoolProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FBoolProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FBytePropertyPtr FSourcifyCoreUEWrapper::Wrap(FByteProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FByteProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FClassPropertyPtr FSourcifyCoreUEWrapper::Wrap(FClassProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FClassProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FComponentKeyPtr FSourcifyCoreUEWrapper::Wrap(FComponentKey& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FComponentKey>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FDelegatePropertyPtr FSourcifyCoreUEWrapper::Wrap(FDelegateProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FDelegateProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FDoublePropertyPtr FSourcifyCoreUEWrapper::Wrap(FDoubleProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FDoubleProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FEdGraphPinTypePtr FSourcifyCoreUEWrapper::Wrap(FEdGraphPinType& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FEdGraphPinType>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FEdGraphTerminalTypePtr FSourcifyCoreUEWrapper::Wrap(FEdGraphTerminalType& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FEdGraphTerminalType>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FEnumPropertyPtr FSourcifyCoreUEWrapper::Wrap(FEnumProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FEnumProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FFieldPtr FSourcifyCoreUEWrapper::Wrap(FField& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FField>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FFieldVariantPtr FSourcifyCoreUEWrapper::Wrap(FFieldVariant& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FFieldVariant>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FFloatPropertyPtr FSourcifyCoreUEWrapper::Wrap(FFloatProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FFloatProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FGraphNodeCreator_UK2Node_EventPtr FSourcifyCoreUEWrapper::Wrap(FGraphNodeCreator<UK2Node_Event>& objectToWrap) const
{
	return dynamic_pointer_cast<ISCW_FGraphNodeCreator_UK2Node_Event>(WrapInternal(objectToWrap));
}
ISCW_FGraphNodeCreator_UK2Node_CreateDelegatePtr FSourcifyCoreUEWrapper::Wrap(FGraphNodeCreator<UK2Node_CreateDelegate>& objectToWrap) const
{
	return dynamic_pointer_cast<ISCW_FGraphNodeCreator_UK2Node_CreateDelegate>(WrapInternal(objectToWrap));
}
ISCW_FImplementedInterfacePtr FSourcifyCoreUEWrapper::Wrap(FImplementedInterface& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FImplementedInterface>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FInterfacePropertyPtr FSourcifyCoreUEWrapper::Wrap(FInterfaceProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FInterfaceProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FMapPropertyPtr FSourcifyCoreUEWrapper::Wrap(FMapProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FMapProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FMemberReferencePtr FSourcifyCoreUEWrapper::Wrap(FMemberReference& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FMemberReference>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FMulticastDelegatePropertyPtr FSourcifyCoreUEWrapper::Wrap(FMulticastDelegateProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FMulticastDelegateProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FNamePropertyPtr FSourcifyCoreUEWrapper::Wrap(FNameProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FNameProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FNumericPropertyPtr FSourcifyCoreUEWrapper::Wrap(FNumericProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FNumericProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FObjectPropertyPtr FSourcifyCoreUEWrapper::Wrap(FObjectProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FObjectProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FObjectPropertyBasePtr FSourcifyCoreUEWrapper::Wrap(FObjectPropertyBase& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FObjectPropertyBase>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FOptionalPinFromPropertyPtr FSourcifyCoreUEWrapper::Wrap(FOptionalPinFromProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FOptionalPinFromProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FPropertyPtr FSourcifyCoreUEWrapper::Wrap(FProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FPropertyChangedEventPtr FSourcifyCoreUEWrapper::Wrap(FPropertyChangedEvent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FPropertyChangedEvent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSetPropertyPtr FSourcifyCoreUEWrapper::Wrap(FSetProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSetProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSimpleMemberReferencePtr FSourcifyCoreUEWrapper::Wrap(FSimpleMemberReference& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSimpleMemberReference>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSlowTaskPtr FSourcifyCoreUEWrapper::Wrap(FSlowTask& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSlowTask>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSoftClassPropertyPtr FSourcifyCoreUEWrapper::Wrap(FSoftClassProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSoftClassProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSoftObjectPropertyPtr FSourcifyCoreUEWrapper::Wrap(FSoftObjectProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSoftObjectProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FStrPropertyPtr FSourcifyCoreUEWrapper::Wrap(FStrProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FStrProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FStructPropertyPtr FSourcifyCoreUEWrapper::Wrap(FStructProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FStructProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FStructVariableDescriptionPtr FSourcifyCoreUEWrapper::Wrap(FStructVariableDescription& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FStructVariableDescription>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSubobjectDataPtr FSourcifyCoreUEWrapper::Wrap(FSubobjectData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSubobjectData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FSubobjectDataHandlePtr FSourcifyCoreUEWrapper::Wrap(FSubobjectDataHandle& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FSubobjectDataHandle>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FTextPropertyPtr FSourcifyCoreUEWrapper::Wrap(FTextProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FTextProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FUserPinInfoPtr FSourcifyCoreUEWrapper::Wrap(FUserPinInfo& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FUserPinInfo>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_FWeakObjectPropertyPtr FSourcifyCoreUEWrapper::Wrap(FWeakObjectProperty& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FWeakObjectProperty>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UAIGraphPtr FSourcifyCoreUEWrapper::Wrap(UAIGraph& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UAIGraph>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UActorComponentPtr FSourcifyCoreUEWrapper::Wrap(UActorComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UActorComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UAnimBlueprintPtr FSourcifyCoreUEWrapper::Wrap(UAnimBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UAnimBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UAnimationGraphPtr FSourcifyCoreUEWrapper::Wrap(UAnimationGraph& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UAnimationGraph>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBaseWidgetBlueprintPtr FSourcifyCoreUEWrapper::Wrap(UBaseWidgetBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBaseWidgetBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBehaviorTreePtr FSourcifyCoreUEWrapper::Wrap(UBehaviorTree& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBehaviorTree>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBehaviorTreeGraphPtr FSourcifyCoreUEWrapper::Wrap(UBehaviorTreeGraph& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBehaviorTreeGraph>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBlackboardDataPtr FSourcifyCoreUEWrapper::Wrap(UBlackboardData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBlackboardData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBlackboardKeyTypePtr FSourcifyCoreUEWrapper::Wrap(UBlackboardKeyType& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBlackboardKeyType>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBlackboardKeyType_EnumPtr FSourcifyCoreUEWrapper::Wrap(UBlackboardKeyType_Enum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBlackboardKeyType_Enum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBlueprintPtr FSourcifyCoreUEWrapper::Wrap(UBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UBlueprintGeneratedClassPtr FSourcifyCoreUEWrapper::Wrap(UBlueprintGeneratedClass& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UBlueprintGeneratedClass>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UClassPtr FSourcifyCoreUEWrapper::Wrap(UClass& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UClass>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UDataAssetPtr FSourcifyCoreUEWrapper::Wrap(UDataAsset& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UDataAsset>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UDataTablePtr FSourcifyCoreUEWrapper::Wrap(UDataTable& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UDataTable>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEdGraphPtr FSourcifyCoreUEWrapper::Wrap(UEdGraph& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEdGraph>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEdGraphNodePtr FSourcifyCoreUEWrapper::Wrap(UEdGraphNode& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEdGraphNode>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEdGraphPinPtr FSourcifyCoreUEWrapper::Wrap(UEdGraphPin& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEdGraphPin>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEdGraphSchemaPtr FSourcifyCoreUEWrapper::Wrap(UEdGraphSchema& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEdGraphSchema>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEdGraphSchema_K2Ptr FSourcifyCoreUEWrapper::Wrap(UEdGraphSchema_K2& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEdGraphSchema_K2>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UEnumPtr FSourcifyCoreUEWrapper::Wrap(UEnum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UEnum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UFieldPtr FSourcifyCoreUEWrapper::Wrap(UField& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UField>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UFunctionPtr FSourcifyCoreUEWrapper::Wrap(UFunction& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UFunction>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UGeneralProjectSettingsPtr FSourcifyCoreUEWrapper::Wrap(UGeneralProjectSettings& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UGeneralProjectSettings>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UInheritableComponentHandlerPtr FSourcifyCoreUEWrapper::Wrap(UInheritableComponentHandler& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UInheritableComponentHandler>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UInterfacePtr FSourcifyCoreUEWrapper::Wrap(UInterface& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UInterface>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2NodePtr FSourcifyCoreUEWrapper::Wrap(UK2Node& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_AddComponentPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_AddComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_AddComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_AddDelegatePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_AddDelegate& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_AddDelegate>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_AssignDelegatePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_AssignDelegate& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_AssignDelegate>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_BaseMCDelegatePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_BaseMCDelegate& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_BaseMCDelegate>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_BreakStructPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_BreakStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_BreakStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CallArrayFunctionPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CallArrayFunction& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CallArrayFunction>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CallFunctionPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CallFunction& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CallFunction>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CallParentFunctionPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CallParentFunction& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CallParentFunction>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CastByteToEnumPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CastByteToEnum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CastByteToEnum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_ComponentBoundEventPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_ComponentBoundEvent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_ComponentBoundEvent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CreateDelegatePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CreateDelegate& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CreateDelegate>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_CustomEventPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_CustomEvent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_CustomEvent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_DynamicCastPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_DynamicCast& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_DynamicCast>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_EditablePinBasePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_EditablePinBase& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_EditablePinBase>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_EnumEqualityPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_EnumEquality& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_EnumEquality>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_EventPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Event& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Event>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_ForEachElementInEnumPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_ForEachElementInEnum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_ForEachElementInEnum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_FunctionEntryPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_FunctionEntry& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_FunctionEntry>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_FunctionResultPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_FunctionResult& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_FunctionResult>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_FunctionTerminatorPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_FunctionTerminator& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_FunctionTerminator>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_GetArrayItemPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_GetArrayItem& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_GetArrayItem>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_MacroInstancePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_MacroInstance& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_MacroInstance>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_MakeStructPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_MakeStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_MakeStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_MessagePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Message& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Message>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_SelectPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Select& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Select>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_SetFieldsInStructPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_SetFieldsInStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_SetFieldsInStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_StructMemberGetPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_StructMemberGet& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_StructMemberGet>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_StructMemberSetPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_StructMemberSet& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_StructMemberSet>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_StructOperationPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_StructOperation& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_StructOperation>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_SwitchPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Switch& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Switch>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_SwitchEnumPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_SwitchEnum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_SwitchEnum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_TunnelPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Tunnel& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Tunnel>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_VariablePtr FSourcifyCoreUEWrapper::Wrap(UK2Node_Variable& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_Variable>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_VariableGetPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_VariableGet& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_VariableGet>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UK2Node_VariableSetPtr FSourcifyCoreUEWrapper::Wrap(UK2Node_VariableSet& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UK2Node_VariableSet>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_ULevelPtr FSourcifyCoreUEWrapper::Wrap(ULevel& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_ULevel>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_ULevelScriptBlueprintPtr FSourcifyCoreUEWrapper::Wrap(ULevelScriptBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_ULevelScriptBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_ULevelSequencePtr FSourcifyCoreUEWrapper::Wrap(ULevelSequence& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_ULevelSequence>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UMeshComponentPtr FSourcifyCoreUEWrapper::Wrap(UMeshComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UMeshComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
#if ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)
ISCW_UMetaDataPtr FSourcifyCoreUEWrapper::Wrap(UMetaData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UMetaData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
#else
ISCW_FMetaDataPtr FSourcifyCoreUEWrapper::Wrap(FMetaData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_FMetaData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
#endif // ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)
ISCW_UMovieSceneSequencePtr FSourcifyCoreUEWrapper::Wrap(UMovieSceneSequence& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UMovieSceneSequence>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UMovieSceneSignedObjectPtr FSourcifyCoreUEWrapper::Wrap(UMovieSceneSignedObject& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UMovieSceneSignedObject>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UObjectPtr FSourcifyCoreUEWrapper::Wrap(UObject& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UObject>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UObjectRedirectorPtr FSourcifyCoreUEWrapper::Wrap(UObjectRedirector& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UObjectRedirector>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UPackagePtr FSourcifyCoreUEWrapper::Wrap(UPackage& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UPackage>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UPrimitiveComponentPtr FSourcifyCoreUEWrapper::Wrap(UPrimitiveComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UPrimitiveComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UPropertyWrapperPtr FSourcifyCoreUEWrapper::Wrap(UPropertyWrapper& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UPropertyWrapper>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_USCS_NodePtr FSourcifyCoreUEWrapper::Wrap(USCS_Node& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_USCS_Node>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_USceneComponentPtr FSourcifyCoreUEWrapper::Wrap(USceneComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_USceneComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UScriptStructPtr FSourcifyCoreUEWrapper::Wrap(UScriptStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UScriptStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_USimpleConstructionScriptPtr FSourcifyCoreUEWrapper::Wrap(USimpleConstructionScript& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_USimpleConstructionScript>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
#if ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5,6,0)
ISCW_UStateTreePtr FSourcifyCoreUEWrapper::Wrap(UStateTree& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UStateTree>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
#endif // ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5,6,0)
ISCW_UStructPtr FSourcifyCoreUEWrapper::Wrap(UStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UUserDefinedEnumPtr FSourcifyCoreUEWrapper::Wrap(UUserDefinedEnum& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UUserDefinedEnum>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UUserDefinedStructPtr FSourcifyCoreUEWrapper::Wrap(UUserDefinedStruct& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UUserDefinedStruct>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UUserDefinedStructEditorDataPtr FSourcifyCoreUEWrapper::Wrap(UUserDefinedStructEditorData& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UUserDefinedStructEditorData>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UUserWidgetBlueprintPtr FSourcifyCoreUEWrapper::Wrap(UUserWidgetBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UUserWidgetBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UVisualPtr FSourcifyCoreUEWrapper::Wrap(UVisual& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UVisual>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWidgetPtr FSourcifyCoreUEWrapper::Wrap(UWidget& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWidget>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWidgetBlueprintPtr FSourcifyCoreUEWrapper::Wrap(UWidgetBlueprint& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWidgetBlueprint>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWidgetBlueprintGeneratedClassPtr FSourcifyCoreUEWrapper::Wrap(UWidgetBlueprintGeneratedClass& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWidgetBlueprintGeneratedClass>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWidgetComponentPtr FSourcifyCoreUEWrapper::Wrap(UWidgetComponent& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWidgetComponent>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWidgetTreePtr FSourcifyCoreUEWrapper::Wrap(UWidgetTree& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWidgetTree>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
ISCW_UWorldPtr FSourcifyCoreUEWrapper::Wrap(UWorld& objectToWrap) const
{
	auto wrappedPtr = dynamic_pointer_cast<ISCW_UWorld>(WrapInternal(objectToWrap));
	check(wrappedPtr);
	return wrappedPtr;
}
// PUBLIC WRAPPERS END

// PRIVATE WRAPPERS BEGIN
ISCW_FAssetDataPtr FSourcifyCoreUEWrapper::WrapInternal(FAssetData& objectToWrap) const
{
	return { new SCW_FAssetData { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FBlackboardEntryPtr FSourcifyCoreUEWrapper::WrapInternal(FBlackboardEntry& objectToWrap) const
{
	return { new SCW_FBlackboardEntry { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FBPInterfaceDescriptionPtr FSourcifyCoreUEWrapper::WrapInternal(FBPInterfaceDescription& objectToWrap) const
{
	return { new SCW_FBPInterfaceDescription { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FBPVariableDescriptionPtr FSourcifyCoreUEWrapper::WrapInternal(FBPVariableDescription& objectToWrap) const
{
	return { new SCW_FBPVariableDescription { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FComponentKeyPtr FSourcifyCoreUEWrapper::WrapInternal(FComponentKey& objectToWrap) const
{
	return { new SCW_FComponentKey { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FEdGraphPinTypePtr FSourcifyCoreUEWrapper::WrapInternal(FEdGraphPinType& objectToWrap) const
{
	return { new SCW_FEdGraphPinType { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FEdGraphTerminalTypePtr FSourcifyCoreUEWrapper::WrapInternal(FEdGraphTerminalType& objectToWrap) const
{
	return { new SCW_FEdGraphTerminalType { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FFieldPtr FSourcifyCoreUEWrapper::WrapInternal(FField& objectToWrap) const
{
	if (FClassProperty* asFClassProperty = CastField<FClassProperty>(&objectToWrap))
	{
		return { new SCW_FClassProperty { asFClassProperty }, SCW_Base::Deleter{} };
	}
	if (FSoftClassProperty* asFSoftClassProperty = CastField<FSoftClassProperty>(&objectToWrap))
	{
		return { new SCW_FSoftClassProperty { asFSoftClassProperty }, SCW_Base::Deleter{} };
	}
	if (FByteProperty* asFByteProperty = CastField<FByteProperty>(&objectToWrap))
	{
		return { new SCW_FByteProperty { asFByteProperty }, SCW_Base::Deleter{} };
	}
	if (FDoubleProperty* asFDoubleProperty = CastField<FDoubleProperty>(&objectToWrap))
	{
		return { new SCW_FDoubleProperty { asFDoubleProperty }, SCW_Base::Deleter{} };
	}
	if (FFloatProperty* asFFloatProperty = CastField<FFloatProperty>(&objectToWrap))
	{
		return { new SCW_FFloatProperty { asFFloatProperty }, SCW_Base::Deleter{} };
	}
	if (FObjectProperty* asFObjectProperty = CastField<FObjectProperty>(&objectToWrap))
	{
		return { new SCW_FObjectProperty { asFObjectProperty }, SCW_Base::Deleter{} };
	}
	if (FSoftObjectProperty* asFSoftObjectProperty = CastField<FSoftObjectProperty>(&objectToWrap))
	{
		return { new SCW_FSoftObjectProperty { asFSoftObjectProperty }, SCW_Base::Deleter{} };
	}
	if (FWeakObjectProperty* asFWeakObjectProperty = CastField<FWeakObjectProperty>(&objectToWrap))
	{
		return { new SCW_FWeakObjectProperty { asFWeakObjectProperty }, SCW_Base::Deleter{} };
	}
	if (FArrayProperty* asFArrayProperty = CastField<FArrayProperty>(&objectToWrap))
	{
		return { new SCW_FArrayProperty { asFArrayProperty }, SCW_Base::Deleter{} };
	}
	if (FBoolProperty* asFBoolProperty = CastField<FBoolProperty>(&objectToWrap))
	{
		return { new SCW_FBoolProperty { asFBoolProperty }, SCW_Base::Deleter{} };
	}
	if (FDelegateProperty* asFDelegateProperty = CastField<FDelegateProperty>(&objectToWrap))
	{
		return { new SCW_FDelegateProperty { asFDelegateProperty }, SCW_Base::Deleter{} };
	}
	if (FEnumProperty* asFEnumProperty = CastField<FEnumProperty>(&objectToWrap))
	{
		return { new SCW_FEnumProperty { asFEnumProperty }, SCW_Base::Deleter{} };
	}
	if (FInterfaceProperty* asFInterfaceProperty = CastField<FInterfaceProperty>(&objectToWrap))
	{
		return { new SCW_FInterfaceProperty { asFInterfaceProperty }, SCW_Base::Deleter{} };
	}
	if (FMapProperty* asFMapProperty = CastField<FMapProperty>(&objectToWrap))
	{
		return { new SCW_FMapProperty { asFMapProperty }, SCW_Base::Deleter{} };
	}
	if (FMulticastDelegateProperty* asFMulticastDelegateProperty = CastField<FMulticastDelegateProperty>(&objectToWrap))
	{
		return { new SCW_FMulticastDelegateProperty { asFMulticastDelegateProperty }, SCW_Base::Deleter{} };
	}
	if (FNameProperty* asFNameProperty = CastField<FNameProperty>(&objectToWrap))
	{
		return { new SCW_FNameProperty { asFNameProperty }, SCW_Base::Deleter{} };
	}
	if (FNumericProperty* asFNumericProperty = CastField<FNumericProperty>(&objectToWrap))
	{
		return { new SCW_FNumericProperty { asFNumericProperty }, SCW_Base::Deleter{} };
	}
	if (FObjectPropertyBase* asFObjectPropertyBase = CastField<FObjectPropertyBase>(&objectToWrap))
	{
		return { new SCW_FObjectPropertyBase { asFObjectPropertyBase }, SCW_Base::Deleter{} };
	}
	if (FSetProperty* asFSetProperty = CastField<FSetProperty>(&objectToWrap))
	{
		return { new SCW_FSetProperty { asFSetProperty }, SCW_Base::Deleter{} };
	}
	if (FStrProperty* asFStrProperty = CastField<FStrProperty>(&objectToWrap))
	{
		return { new SCW_FStrProperty { asFStrProperty }, SCW_Base::Deleter{} };
	}
	if (FStructProperty* asFStructProperty = CastField<FStructProperty>(&objectToWrap))
	{
		return { new SCW_FStructProperty { asFStructProperty }, SCW_Base::Deleter{} };
	}
	if (FTextProperty* asFTextProperty = CastField<FTextProperty>(&objectToWrap))
	{
		return { new SCW_FTextProperty { asFTextProperty }, SCW_Base::Deleter{} };
	}
	if (FProperty* asFProperty = CastField<FProperty>(&objectToWrap))
	{
		return { new SCW_FProperty { asFProperty }, SCW_Base::Deleter{} };
	}
	return { new SCW_FField { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FFieldVariantPtr FSourcifyCoreUEWrapper::WrapInternal(FFieldVariant& objectToWrap) const
{
	return { new SCW_FFieldVariant { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FGraphNodeCreator_UK2Node_EventPtr FSourcifyCoreUEWrapper::WrapInternal(FGraphNodeCreator<UK2Node_Event>& objectToWrap) const
{
	return { new SCW_FGraphNodeCreator_UK2Node_Event { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FGraphNodeCreator_UK2Node_CreateDelegatePtr FSourcifyCoreUEWrapper::WrapInternal(FGraphNodeCreator<UK2Node_CreateDelegate>& objectToWrap) const
{
	return { new SCW_FGraphNodeCreator_UK2Node_CreateDelegate { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FImplementedInterfacePtr FSourcifyCoreUEWrapper::WrapInternal(FImplementedInterface& objectToWrap) const
{
	return { new SCW_FImplementedInterface { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FMemberReferencePtr FSourcifyCoreUEWrapper::WrapInternal(FMemberReference& objectToWrap) const
{
	return { new SCW_FMemberReference { &objectToWrap }, SCW_Base::Deleter{} };
}

#if ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5, 6, 0)
ISCW_FMetaDataPtr FSourcifyCoreUEWrapper::WrapInternal(FMetaData& objectToWrap) const
{
	return { new SCW_FMetaData { &objectToWrap }, SCW_Base::Deleter{} };
}
#endif

ISCW_FOptionalPinFromPropertyPtr FSourcifyCoreUEWrapper::WrapInternal(FOptionalPinFromProperty& objectToWrap) const
{
	return { new SCW_FOptionalPinFromProperty { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FPropertyChangedEventPtr FSourcifyCoreUEWrapper::WrapInternal(FPropertyChangedEvent& objectToWrap) const
{
	return { new SCW_FPropertyChangedEvent { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FSimpleMemberReferencePtr FSourcifyCoreUEWrapper::WrapInternal(FSimpleMemberReference& objectToWrap) const
{
	return { new SCW_FSimpleMemberReference { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FSlowTaskPtr FSourcifyCoreUEWrapper::WrapInternal(FSlowTask& objectToWrap) const
{
	return { new SCW_FSlowTask { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FStructVariableDescriptionPtr FSourcifyCoreUEWrapper::WrapInternal(FStructVariableDescription& objectToWrap) const
{
	return { new SCW_FStructVariableDescription { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FSubobjectDataPtr FSourcifyCoreUEWrapper::WrapInternal(FSubobjectData& objectToWrap) const
{
	return { new SCW_FSubobjectData { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FSubobjectDataHandlePtr FSourcifyCoreUEWrapper::WrapInternal(FSubobjectDataHandle& objectToWrap) const
{
	return { new SCW_FSubobjectDataHandle { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_FUserPinInfoPtr FSourcifyCoreUEWrapper::WrapInternal(FUserPinInfo& objectToWrap) const
{
	return { new SCW_FUserPinInfo { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_UEdGraphPinPtr FSourcifyCoreUEWrapper::WrapInternal(UEdGraphPin& objectToWrap) const
{
	return { new SCW_UEdGraphPin { &objectToWrap }, SCW_Base::Deleter{} };
}

ISCW_UObjectPtr FSourcifyCoreUEWrapper::WrapInternal(UObject& objectToWrap) const
{
	if (UK2Node_SetFieldsInStruct* asUK2Node_SetFieldsInStruct = Cast<UK2Node_SetFieldsInStruct>(&objectToWrap))
	{
		return { new SCW_UK2Node_SetFieldsInStruct { asUK2Node_SetFieldsInStruct }, SCW_Base::Deleter{} };
	}
	if (UK2Node_BreakStruct* asUK2Node_BreakStruct = Cast<UK2Node_BreakStruct>(&objectToWrap))
	{
		return { new SCW_UK2Node_BreakStruct { asUK2Node_BreakStruct }, SCW_Base::Deleter{} };
	}
	if (UK2Node_MakeStruct* asUK2Node_MakeStruct = Cast<UK2Node_MakeStruct>(&objectToWrap))
	{
		return { new SCW_UK2Node_MakeStruct { asUK2Node_MakeStruct }, SCW_Base::Deleter{} };
	}
	if (UWidgetComponent* asUWidgetComponent = Cast<UWidgetComponent>(&objectToWrap))
	{
		return { new SCW_UWidgetComponent { asUWidgetComponent }, SCW_Base::Deleter{} };
	}
	if (UK2Node_AssignDelegate* asUK2Node_AssignDelegate = Cast<UK2Node_AssignDelegate>(&objectToWrap))
	{
		return { new SCW_UK2Node_AssignDelegate { asUK2Node_AssignDelegate }, SCW_Base::Deleter{} };
	}
	if (UK2Node_ComponentBoundEvent* asUK2Node_ComponentBoundEvent = Cast<UK2Node_ComponentBoundEvent>(&objectToWrap))
	{
		return { new SCW_UK2Node_ComponentBoundEvent { asUK2Node_ComponentBoundEvent }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CustomEvent* asUK2Node_CustomEvent = Cast<UK2Node_CustomEvent>(&objectToWrap))
	{
		return { new SCW_UK2Node_CustomEvent { asUK2Node_CustomEvent }, SCW_Base::Deleter{} };
	}
	if (UK2Node_FunctionEntry* asUK2Node_FunctionEntry = Cast<UK2Node_FunctionEntry>(&objectToWrap))
	{
		return { new SCW_UK2Node_FunctionEntry { asUK2Node_FunctionEntry }, SCW_Base::Deleter{} };
	}
	if (UK2Node_FunctionResult* asUK2Node_FunctionResult = Cast<UK2Node_FunctionResult>(&objectToWrap))
	{
		return { new SCW_UK2Node_FunctionResult { asUK2Node_FunctionResult }, SCW_Base::Deleter{} };
	}
	if (UK2Node_MacroInstance* asUK2Node_MacroInstance = Cast<UK2Node_MacroInstance>(&objectToWrap))
	{
		return { new SCW_UK2Node_MacroInstance { asUK2Node_MacroInstance }, SCW_Base::Deleter{} };
	}
	if (UK2Node_StructMemberGet* asUK2Node_StructMemberGet = Cast<UK2Node_StructMemberGet>(&objectToWrap))
	{
		return { new SCW_UK2Node_StructMemberGet { asUK2Node_StructMemberGet }, SCW_Base::Deleter{} };
	}
	if (UK2Node_StructMemberSet* asUK2Node_StructMemberSet = Cast<UK2Node_StructMemberSet>(&objectToWrap))
	{
		return { new SCW_UK2Node_StructMemberSet { asUK2Node_StructMemberSet }, SCW_Base::Deleter{} };
	}
	if (UWidgetBlueprintGeneratedClass* asUWidgetBlueprintGeneratedClass = Cast<UWidgetBlueprintGeneratedClass>(&objectToWrap))
	{
		return { new SCW_UWidgetBlueprintGeneratedClass { asUWidgetBlueprintGeneratedClass }, SCW_Base::Deleter{} };
	}
	if (UMeshComponent* asUMeshComponent = Cast<UMeshComponent>(&objectToWrap))
	{
		return { new SCW_UMeshComponent { asUMeshComponent }, SCW_Base::Deleter{} };
	}
	if (UWidgetBlueprint* asUWidgetBlueprint = Cast<UWidgetBlueprint>(&objectToWrap))
	{
		return { new SCW_UWidgetBlueprint { asUWidgetBlueprint }, SCW_Base::Deleter{} };
	}
	if (UK2Node_AddDelegate* asUK2Node_AddDelegate = Cast<UK2Node_AddDelegate>(&objectToWrap))
	{
		return { new SCW_UK2Node_AddDelegate { asUK2Node_AddDelegate }, SCW_Base::Deleter{} };
	}
	if (UK2Node_AddComponent* asUK2Node_AddComponent = Cast<UK2Node_AddComponent>(&objectToWrap))
	{
		return { new SCW_UK2Node_AddComponent { asUK2Node_AddComponent }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CallArrayFunction* asUK2Node_CallArrayFunction = Cast<UK2Node_CallArrayFunction>(&objectToWrap))
	{
		return { new SCW_UK2Node_CallArrayFunction { asUK2Node_CallArrayFunction }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CallParentFunction* asUK2Node_CallParentFunction = Cast<UK2Node_CallParentFunction>(&objectToWrap))
	{
		return { new SCW_UK2Node_CallParentFunction { asUK2Node_CallParentFunction }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Message* asUK2Node_Message = Cast<UK2Node_Message>(&objectToWrap))
	{
		return { new SCW_UK2Node_Message { asUK2Node_Message }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Event* asUK2Node_Event = Cast<UK2Node_Event>(&objectToWrap))
	{
		return { new SCW_UK2Node_Event { asUK2Node_Event }, SCW_Base::Deleter{} };
	}
	if (UK2Node_FunctionTerminator* asUK2Node_FunctionTerminator = Cast<UK2Node_FunctionTerminator>(&objectToWrap))
	{
		return { new SCW_UK2Node_FunctionTerminator { asUK2Node_FunctionTerminator }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Tunnel* asUK2Node_Tunnel = Cast<UK2Node_Tunnel>(&objectToWrap))
	{
		return { new SCW_UK2Node_Tunnel { asUK2Node_Tunnel }, SCW_Base::Deleter{} };
	}
	if (UK2Node_SwitchEnum* asUK2Node_SwitchEnum = Cast<UK2Node_SwitchEnum>(&objectToWrap))
	{
		return { new SCW_UK2Node_SwitchEnum { asUK2Node_SwitchEnum }, SCW_Base::Deleter{} };
	}
	if (UK2Node_StructOperation* asUK2Node_StructOperation = Cast<UK2Node_StructOperation>(&objectToWrap))
	{
		return { new SCW_UK2Node_StructOperation { asUK2Node_StructOperation }, SCW_Base::Deleter{} };
	}
	if (UK2Node_VariableGet* asUK2Node_VariableGet = Cast<UK2Node_VariableGet>(&objectToWrap))
	{
		return { new SCW_UK2Node_VariableGet { asUK2Node_VariableGet }, SCW_Base::Deleter{} };
	}
	if (UK2Node_VariableSet* asUK2Node_VariableSet = Cast<UK2Node_VariableSet>(&objectToWrap))
	{
		return { new SCW_UK2Node_VariableSet { asUK2Node_VariableSet }, SCW_Base::Deleter{} };
	}
	if (UBlueprintGeneratedClass* asUBlueprintGeneratedClass = Cast<UBlueprintGeneratedClass>(&objectToWrap))
	{
		return { new SCW_UBlueprintGeneratedClass { asUBlueprintGeneratedClass }, SCW_Base::Deleter{} };
	}
	if (UUserDefinedStruct* asUUserDefinedStruct = Cast<UUserDefinedStruct>(&objectToWrap))
	{
		return { new SCW_UUserDefinedStruct { asUUserDefinedStruct }, SCW_Base::Deleter{} };
	}
	if (UPrimitiveComponent* asUPrimitiveComponent = Cast<UPrimitiveComponent>(&objectToWrap))
	{
		return { new SCW_UPrimitiveComponent { asUPrimitiveComponent }, SCW_Base::Deleter{} };
	}
	if (UBaseWidgetBlueprint* asUBaseWidgetBlueprint = Cast<UBaseWidgetBlueprint>(&objectToWrap))
	{
		return { new SCW_UBaseWidgetBlueprint { asUBaseWidgetBlueprint }, SCW_Base::Deleter{} };
	}
	if (UBehaviorTreeGraph* asUBehaviorTreeGraph = Cast<UBehaviorTreeGraph>(&objectToWrap))
	{
		return { new SCW_UBehaviorTreeGraph { asUBehaviorTreeGraph }, SCW_Base::Deleter{} };
	}
	if (UK2Node_BaseMCDelegate* asUK2Node_BaseMCDelegate = Cast<UK2Node_BaseMCDelegate>(&objectToWrap))
	{
		return { new SCW_UK2Node_BaseMCDelegate { asUK2Node_BaseMCDelegate }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CallFunction* asUK2Node_CallFunction = Cast<UK2Node_CallFunction>(&objectToWrap))
	{
		return { new SCW_UK2Node_CallFunction { asUK2Node_CallFunction }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CastByteToEnum* asUK2Node_CastByteToEnum = Cast<UK2Node_CastByteToEnum>(&objectToWrap))
	{
		return { new SCW_UK2Node_CastByteToEnum { asUK2Node_CastByteToEnum }, SCW_Base::Deleter{} };
	}
	if (UK2Node_CreateDelegate* asUK2Node_CreateDelegate = Cast<UK2Node_CreateDelegate>(&objectToWrap))
	{
		return { new SCW_UK2Node_CreateDelegate { asUK2Node_CreateDelegate }, SCW_Base::Deleter{} };
	}
	if (UK2Node_DynamicCast* asUK2Node_DynamicCast = Cast<UK2Node_DynamicCast>(&objectToWrap))
	{
		return { new SCW_UK2Node_DynamicCast { asUK2Node_DynamicCast }, SCW_Base::Deleter{} };
	}
	if (UK2Node_EditablePinBase* asUK2Node_EditablePinBase = Cast<UK2Node_EditablePinBase>(&objectToWrap))
	{
		return { new SCW_UK2Node_EditablePinBase { asUK2Node_EditablePinBase }, SCW_Base::Deleter{} };
	}
	if (UK2Node_EnumEquality* asUK2Node_EnumEquality = Cast<UK2Node_EnumEquality>(&objectToWrap))
	{
		return { new SCW_UK2Node_EnumEquality { asUK2Node_EnumEquality }, SCW_Base::Deleter{} };
	}
	if (UK2Node_ForEachElementInEnum* asUK2Node_ForEachElementInEnum = Cast<UK2Node_ForEachElementInEnum>(&objectToWrap))
	{
		return { new SCW_UK2Node_ForEachElementInEnum { asUK2Node_ForEachElementInEnum }, SCW_Base::Deleter{} };
	}
	if (UK2Node_GetArrayItem* asUK2Node_GetArrayItem = Cast<UK2Node_GetArrayItem>(&objectToWrap))
	{
		return { new SCW_UK2Node_GetArrayItem { asUK2Node_GetArrayItem }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Select* asUK2Node_Select = Cast<UK2Node_Select>(&objectToWrap))
	{
		return { new SCW_UK2Node_Select { asUK2Node_Select }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Switch* asUK2Node_Switch = Cast<UK2Node_Switch>(&objectToWrap))
	{
		return { new SCW_UK2Node_Switch { asUK2Node_Switch }, SCW_Base::Deleter{} };
	}
	if (UK2Node_Variable* asUK2Node_Variable = Cast<UK2Node_Variable>(&objectToWrap))
	{
		return { new SCW_UK2Node_Variable { asUK2Node_Variable }, SCW_Base::Deleter{} };
	}
	if (UUserDefinedEnum* asUUserDefinedEnum = Cast<UUserDefinedEnum>(&objectToWrap))
	{
		return { new SCW_UUserDefinedEnum { asUUserDefinedEnum }, SCW_Base::Deleter{} };
	}
	if (UClass* asUClass = Cast<UClass>(&objectToWrap))
	{
		return { new SCW_UClass { asUClass }, SCW_Base::Deleter{} };
	}
	if (UFunction* asUFunction = Cast<UFunction>(&objectToWrap))
	{
		return { new SCW_UFunction { asUFunction }, SCW_Base::Deleter{} };
	}
	if (UScriptStruct* asUScriptStruct = Cast<UScriptStruct>(&objectToWrap))
	{
		return { new SCW_UScriptStruct { asUScriptStruct }, SCW_Base::Deleter{} };
	}
	if (ULevelSequence* asULevelSequence = Cast<ULevelSequence>(&objectToWrap))
	{
		return { new SCW_ULevelSequence { asULevelSequence }, SCW_Base::Deleter{} };
	}
	if (USceneComponent* asUSceneComponent = Cast<USceneComponent>(&objectToWrap))
	{
		return { new SCW_USceneComponent { asUSceneComponent }, SCW_Base::Deleter{} };
	}
	if (UBlackboardKeyType_Enum* asUBlackboardKeyType_Enum = Cast<UBlackboardKeyType_Enum>(&objectToWrap))
	{
		return { new SCW_UBlackboardKeyType_Enum { asUBlackboardKeyType_Enum }, SCW_Base::Deleter{} };
	}
	if (UAnimBlueprint* asUAnimBlueprint = Cast<UAnimBlueprint>(&objectToWrap))
	{
		return { new SCW_UAnimBlueprint { asUAnimBlueprint }, SCW_Base::Deleter{} };
	}
	if (ULevelScriptBlueprint* asULevelScriptBlueprint = Cast<ULevelScriptBlueprint>(&objectToWrap))
	{
		return { new SCW_ULevelScriptBlueprint { asULevelScriptBlueprint }, SCW_Base::Deleter{} };
	}
	if (UUserWidgetBlueprint* asUUserWidgetBlueprint = Cast<UUserWidgetBlueprint>(&objectToWrap))
	{
		return { new SCW_UUserWidgetBlueprint { asUUserWidgetBlueprint }, SCW_Base::Deleter{} };
	}
	if (UBlackboardData* asUBlackboardData = Cast<UBlackboardData>(&objectToWrap))
	{
		return { new SCW_UBlackboardData { asUBlackboardData }, SCW_Base::Deleter{} };
	}
	if (UAIGraph* asUAIGraph = Cast<UAIGraph>(&objectToWrap))
	{
		return { new SCW_UAIGraph { asUAIGraph }, SCW_Base::Deleter{} };
	}
	if (UAnimationGraph* asUAnimationGraph = Cast<UAnimationGraph>(&objectToWrap))
	{
		return { new SCW_UAnimationGraph { asUAnimationGraph }, SCW_Base::Deleter{} };
	}
	if (UK2Node* asUK2Node = Cast<UK2Node>(&objectToWrap))
	{
		return { new SCW_UK2Node { asUK2Node }, SCW_Base::Deleter{} };
	}
	if (UEdGraphSchema_K2* asUEdGraphSchema_K2 = Cast<UEdGraphSchema_K2>(&objectToWrap))
	{
		return { new SCW_UEdGraphSchema_K2 { asUEdGraphSchema_K2 }, SCW_Base::Deleter{} };
	}
	if (UEnum* asUEnum = Cast<UEnum>(&objectToWrap))
	{
		return { new SCW_UEnum { asUEnum }, SCW_Base::Deleter{} };
	}
	if (UStruct* asUStruct = Cast<UStruct>(&objectToWrap))
	{
		return { new SCW_UStruct { asUStruct }, SCW_Base::Deleter{} };
	}
	if (UMovieSceneSequence* asUMovieSceneSequence = Cast<UMovieSceneSequence>(&objectToWrap))
	{
		return { new SCW_UMovieSceneSequence { asUMovieSceneSequence }, SCW_Base::Deleter{} };
	}
	if (UWidget* asUWidget = Cast<UWidget>(&objectToWrap))
	{
		return { new SCW_UWidget { asUWidget }, SCW_Base::Deleter{} };
	}
	if (AActor* asAActor = Cast<AActor>(&objectToWrap))
	{
		return { new SCW_AActor { asAActor }, SCW_Base::Deleter{} };
	}
	if (UActorComponent* asUActorComponent = Cast<UActorComponent>(&objectToWrap))
	{
		return { new SCW_UActorComponent { asUActorComponent }, SCW_Base::Deleter{} };
	}
	if (UBehaviorTree* asUBehaviorTree = Cast<UBehaviorTree>(&objectToWrap))
	{
		return { new SCW_UBehaviorTree { asUBehaviorTree }, SCW_Base::Deleter{} };
	}
	if (UBlackboardKeyType* asUBlackboardKeyType = Cast<UBlackboardKeyType>(&objectToWrap))
	{
		return { new SCW_UBlackboardKeyType { asUBlackboardKeyType }, SCW_Base::Deleter{} };
	}
	if (UBlueprint* asUBlueprint = Cast<UBlueprint>(&objectToWrap))
	{
		return { new SCW_UBlueprint { asUBlueprint }, SCW_Base::Deleter{} };
	}
#if ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5,6,0)
	if (UStateTree* asUStateTree = Cast<UStateTree>(&objectToWrap))
	{
		return { new SCW_UStateTree { asUStateTree }, SCW_Base::Deleter{} };
	}
#endif // ISCW_UE_VERSION_NEWER_THAN_OR_EQUAL(5,6,0)
	if (UDataAsset* asUDataAsset = Cast<UDataAsset>(&objectToWrap))
	{
		return { new SCW_UDataAsset { asUDataAsset }, SCW_Base::Deleter{} };
	}
	if (UDataTable* asUDataTable = Cast<UDataTable>(&objectToWrap))
	{
		return { new SCW_UDataTable { asUDataTable }, SCW_Base::Deleter{} };
	}
	if (UEdGraph* asUEdGraph = Cast<UEdGraph>(&objectToWrap))
	{
		return { new SCW_UEdGraph { asUEdGraph }, SCW_Base::Deleter{} };
	}
	if (UEdGraphNode* asUEdGraphNode = Cast<UEdGraphNode>(&objectToWrap))
	{
		return { new SCW_UEdGraphNode { asUEdGraphNode }, SCW_Base::Deleter{} };
	}
	if (UEdGraphSchema* asUEdGraphSchema = Cast<UEdGraphSchema>(&objectToWrap))
	{
		return { new SCW_UEdGraphSchema { asUEdGraphSchema }, SCW_Base::Deleter{} };
	}
	if (UField* asUField = Cast<UField>(&objectToWrap))
	{
		return { new SCW_UField { asUField }, SCW_Base::Deleter{} };
	}
	if (UGeneralProjectSettings* asUGeneralProjectSettings = Cast<UGeneralProjectSettings>(&objectToWrap))
	{
		return { new SCW_UGeneralProjectSettings { asUGeneralProjectSettings }, SCW_Base::Deleter{} };
	}
	if (UInheritableComponentHandler* asUInheritableComponentHandler = Cast<UInheritableComponentHandler>(&objectToWrap))
	{
		return { new SCW_UInheritableComponentHandler { asUInheritableComponentHandler }, SCW_Base::Deleter{} };
	}
	if (UInterface* asUInterface = Cast<UInterface>(&objectToWrap))
	{
		return { new SCW_UInterface { asUInterface }, SCW_Base::Deleter{} };
	}
	if (ULevel* asULevel = Cast<ULevel>(&objectToWrap))
	{
		return { new SCW_ULevel { asULevel }, SCW_Base::Deleter{} };
	}
	
// UMetaData is deprecated in UE 5.6 use FMetaData instead
#if ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)
	if (UMetaData* asUMetaData = Cast<UMetaData>(&objectToWrap))
	{
		return { new SCW_UMetaData { asUMetaData }, SCW_Base::Deleter{} };
	}
#endif // ISCW_UE_VERSION_OLDER_THAN(5, 6, 0)

	if (UMovieSceneSignedObject* asUMovieSceneSignedObject = Cast<UMovieSceneSignedObject>(&objectToWrap))
	{
		return { new SCW_UMovieSceneSignedObject { asUMovieSceneSignedObject }, SCW_Base::Deleter{} };
	}
	if (UObjectRedirector* asUObjectRedirector = Cast<UObjectRedirector>(&objectToWrap))
	{
		return { new SCW_UObjectRedirector { asUObjectRedirector }, SCW_Base::Deleter{} };
	}
	if (UPackage* asUPackage = Cast<UPackage>(&objectToWrap))
	{
		return { new SCW_UPackage { asUPackage }, SCW_Base::Deleter{} };
	}
	if (UPropertyWrapper* asUPropertyWrapper = Cast<UPropertyWrapper>(&objectToWrap))
	{
		return { new SCW_UPropertyWrapper { asUPropertyWrapper }, SCW_Base::Deleter{} };
	}
	if (USCS_Node* asUSCS_Node = Cast<USCS_Node>(&objectToWrap))
	{
		return { new SCW_USCS_Node { asUSCS_Node }, SCW_Base::Deleter{} };
	}
	if (USimpleConstructionScript* asUSimpleConstructionScript = Cast<USimpleConstructionScript>(&objectToWrap))
	{
		return { new SCW_USimpleConstructionScript { asUSimpleConstructionScript }, SCW_Base::Deleter{} };
	}
	if (UUserDefinedStructEditorData* asUUserDefinedStructEditorData = Cast<UUserDefinedStructEditorData>(&objectToWrap))
	{
		return { new SCW_UUserDefinedStructEditorData { asUUserDefinedStructEditorData }, SCW_Base::Deleter{} };
	}
	if (UVisual* asUVisual = Cast<UVisual>(&objectToWrap))
	{
		return { new SCW_UVisual { asUVisual }, SCW_Base::Deleter{} };
	}
	if (UWidgetTree* asUWidgetTree = Cast<UWidgetTree>(&objectToWrap))
	{
		return { new SCW_UWidgetTree { asUWidgetTree }, SCW_Base::Deleter{} };
	}
	if (UWorld* asUWorld = Cast<UWorld>(&objectToWrap))
	{
		return { new SCW_UWorld { asUWorld }, SCW_Base::Deleter{} };
	}
	return { new SCW_UObject { &objectToWrap }, SCW_Base::Deleter{} };
}

// PRIVATE WRAPPERS END